ofs-object 0.1.0-beta.1

package/dist/index.d.ts

@@ -0,0 +1,4887 @@
+import { Feature } from 'geojson';
+import { FeatureCollection } from 'geojson';
+import { Geometry } from 'geojson';
+import { LineString } from 'geojson';
+import { MultiLineString } from 'geojson';
+import { MultiPolygon } from 'geojson';
+import { Point } from 'geojson';
+import { Polygon } from 'geojson';
+import { Position } from 'geojson';
+import * as turf from '@turf/turf';
+
+export declare interface AddedLayer {
+    layerId: string;
+    name: string;
+    featureCount: number;
+    sourceCrs: string;
+}
+
+/**
+ * Add imported layers to a data source. Feature ids from the file are kept when unique within the layer;
+ * duplicates get new ids (reported).
+ */
+export declare function addImportedLayers(ds: OFSDataSource, imported: ImportedLayer[], issues?: ImportIssue[]): AddedLayer[];
+
+export declare interface AiExecutionFeedback {
+    success: boolean;
+    tool: string;
+    summary: string;
+    data?: any;
+    error?: string;
+    /** What the command expects, sent back when a call was refused so the model can retry */
+    help?: string[];
+    mapSnapshot?: {
+        activeLayerId: string | null;
+        totalLayers: number;
+        layerFeatureCounts: Record<string, number>;
+    };
+}
+
+export declare interface AiToolDeclaration {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: {
+            type: 'object';
+            properties: Record<string, any>;
+            required?: string[];
+        };
+    };
+}
+
+/**
+ * Signed distance field for recolorable (SDF) map icons, using the Felzenszwalb-Huttenlocher
+ * Euclidean distance transform (the same approach as mapbox/tiny-sdf).
+ *
+ * GL renders an SDF icon edge where the alpha value is 0.75 (191/255); halos grow outward from it.
+ */
+/**
+ * Convert coverage alpha (0-255, row-major) into SDF alpha values.
+ * @param radius Distance in pixels mapped across the full alpha range
+ * @param cutoff Share of the range inside the shape (0.25 puts the edge at 191)
+ */
+export declare function alphaToSdf(alpha: ArrayLike<number>, width: number, height: number, radius?: number, cutoff?: number): Uint8ClampedArray;
+
+export declare type AngleConvention = 'bearing' | 'cad';
+
+export declare interface AngleMeasure {
+    /** Angle at the middle point, 0–180° */
+    degrees: number;
+    /** Direction from the middle point to the first / third point, in the given convention */
+    firstAngleDeg: number;
+    secondAngleDeg: number;
+    firstMeters: number;
+    secondMeters: number;
+}
+
+declare type AnyFeature = Feature<Geometry, any>;
+
+/** Apply a class color / size / override on top of the base symbol */
+export declare function applyClassSymbol(base: SymbolStyle, classColor: string | undefined, classSize: number | undefined, override?: ClassSymbolOverride): SymbolStyle;
+
+/** 1 rai = 4 ngan = 400 square wa = 1600 m² */
+export declare const AREA_UNITS: Record<string, number>;
+
+export declare interface AreaMeasure {
+    /** Area in m² (holes subtracted) */
+    area: number;
+    /** Perimeter in m (all rings) */
+    perimeter: number;
+    /** Mean width 2A/P in m (0 when the perimeter is 0) */
+    width: number;
+}
+
+export declare class ArgumentError extends OFSError {
+    readonly command: string;
+    readonly issues: string[];
+    constructor(command: string, issues: string[], usage?: string);
+}
+
+/**
+ * Ask for a map point or free text. Falls back to text-only input on consoles without point picking.
+ */
+export declare function askPointOrText(consoleService: IOFSConsole, prompt: string, basePoint?: Coordinate | null): Promise<{
+    point: Coordinate;
+} | {
+    text: string;
+}>;
+
+/**
+ * Ask for a required point; throws when the user answers with an empty input.
+ */
+export declare function askRequiredPoint(consoleService: IOFSConsole, prompt: string, basePoint?: Coordinate | null): Promise<Coordinate>;
+
+export declare function assertValidPolygon(geometry: Polygon | MultiPolygon, what: string): void;
+
+export declare interface AttributeRow {
+    featureId: string | number;
+    selected: boolean;
+    values: Record<string, unknown>;
+}
+
+export declare interface AttributeTableOptions {
+    /** Called when a row is opened (double click): zoom the map to the feature */
+    onZoom?: (layerId: string, featureId: string | number) => void;
+    onClose?: () => void;
+    /** Ask before deleting a field (default: window.confirm) */
+    confirmDelete?: (field: FieldSchema, layerName: string) => boolean;
+}
+
+export declare abstract class BaseGLAdapter implements IMapAdapter {
+    abstract readonly engineName: 'maplibre' | 'mapbox';
+    protected map: any;
+    protected _isReady: boolean;
+    /**
+     * False when the map came from `attach()`: the host application created it and destroy()
+     * must leave it running, removing only what this adapter added.
+     */
+    protected ownsMap: boolean;
+    protected dataSource: OFSDataSource | null;
+    protected thematicEngine: OFSThematicEngine | null;
+    protected unsubscribers: (() => void)[];
+    protected clickHandlers: Set<(e: MapClickEvent) => void>;
+    protected dblClickHandlers: Set<(e: MapClickEvent) => void>;
+    protected contextMenuHandlers: Set<(e: MapClickEvent) => void>;
+    protected moveHandlers: Set<(e: MapClickEvent) => void>;
+    protected mouseDownHandlers: Set<(e: MapClickEvent) => void>;
+    protected mouseUpHandlers: Set<(e: MapClickEvent) => void>;
+    protected activeFeatureStateIds: Map<string, Set<string | number>>;
+    /** Feature object references last sent to each map source, used to compute incremental diffs */
+    protected renderedFeatures: Map<string, Map<string | number, Feature<Geometry, any>>>;
+    /** Compiled label expressions per layer (labels that are not a plain field) */
+    protected labelSources: Map<string, LabelSource>;
+    protected pendingSourceUpdates: Set<string>;
+    protected flushScheduled: boolean;
+    /** GL layers created for each data layer, with the property values last sent to the map */
+    protected glLayers: Map<string, GLLayerRecord[]>;
+    protected glLayerOwner: Map<string, string>;
+    protected glLayerZIndex: Map<string, number>;
+    private orderScheduled;
+    protected symbolImages: SymbolImageManager;
+    private unsubscribeIcons;
+    get isReady(): boolean;
+    abstract init(container: HTMLElement | string, options?: Record<string, any>): Promise<void>;
+    /**
+     * Use a map the host application created (Angular, React, Vue, or a plain page) instead of
+     * creating one. The map keeps belonging to the host: `destroy()` removes the layers, sources and
+     * listeners this adapter added and leaves the map itself alive.
+     *
+     * Resolves once the style is parsed, whether that happened before or after this call.
+     */
+    attach(map: any): Promise<void>;
+    /**
+     * Wait until the style is usable. `isStyleLoaded()` is checked first because `load` has often
+     * already fired by the time a host hands over its map, and `loaded()` is not used because it goes
+     * back to false whenever tiles are in flight.
+     */
+    protected whenStyleLoaded(map: any): Promise<void>;
+    bindDataSource(dataSource: OFSDataSource, thematicEngine?: OFSThematicEngine): void;
+    protected syncAllLayers(): void;
+    syncLayer(layer: OFSLayerData): void;
+    /** Reordering several layers emits one update per layer; restack once */
+    private scheduleLayerOrder;
+    /** GL layer ids that render a data layer, bottom to top */
+    getGLLayerIds(layerId: string): string[];
+    /** Data layer that owns a GL layer id */
+    protected dataLayerIdFor(glLayerId: string): string;
+    protected isLayerRendered(layer: OFSLayerData): boolean;
+    private serialize;
+    /** Set changed properties and reset properties that are no longer specified */
+    private applyProperties;
+    private safely;
+    /** Draw tool layers stay above data layers */
+    private drawLayerAnchor;
+    private removeGLLayer;
+    /** Stack all GL layers by data layer zIndex (each data layer's GL layers stay together, in order) */
+    protected applyLayerOrder(): void;
+    removeLayer(layerId: string): void;
+    /**
+     * Queue a source refresh for a layer. Multiple edits in the same animation frame
+     * (e.g. dragging a grip) are sent to the map once.
+     */
+    protected scheduleSourceUpdate(layerId: string): void;
+    /**
+     * Immediately send all queued source updates to the map.
+     */
+    flushPendingSourceUpdates(): void;
+    /**
+     * Build the full render collection for a layer and remember what was sent.
+     */
+    protected buildRenderCollection(layer: OFSLayerData): FeatureCollection<Geometry, any>;
+    /**
+     * Keep the label text generator of a layer up to date. Returns true when it changed, which means the
+     * whole source has to be resent (every feature's label text changes at once).
+     */
+    protected syncLabelSource(layer: OFSLayerData): boolean;
+    /**
+     * Send changes of a layer to its map source. Uses GeoJSONSource.updateData (MapLibre) with only
+     * the added / changed / removed features when possible, otherwise falls back to setData.
+     * Changed features are detected by object identity: OFSLayerData replaces the stored object on
+     * every add or update.
+     */
+    protected updateSourceData(layer: OFSLayerData): void;
+    protected updateSelectionState(layerId: string, featureIds: (string | number)[]): void;
+    setFeatureState(layerId: string, featureId: string | number, state: Record<string, any>): void;
+    getFeatureState(layerId: string, featureId: string | number): Record<string, any>;
+    setLayerVisibility(layerId: string, visible: boolean): void;
+    /** Layer opacity multiplies every symbol opacity, so it is applied by recompiling the style */
+    setLayerOpacity(layerId: string, opacity: number): void;
+    setLayerZIndex(_layerId: string, _zIndex: number): void;
+    fitBounds(bbox: BoundingBox, padding?: number): void;
+    flyTo(options: MapViewportOptions): void;
+    getCenter(): Coordinate;
+    setCenter(coord: Coordinate): void;
+    getZoom(): number;
+    setZoom(zoom: number): void;
+    getBounds(): BoundingBox;
+    onMapClick(handler: (e: MapClickEvent) => void): () => void;
+    onMapDblClick(handler: (e: MapClickEvent) => void): () => void;
+    onContextMenu(handler: (e: MapClickEvent) => void): () => void;
+    onMouseMove(handler: (e: MapClickEvent) => void): () => void;
+    onMouseDown(handler: (e: MapClickEvent) => void): () => void;
+    onMouseUp(handler: (e: MapClickEvent) => void): () => void;
+    setDoubleClickZoom(enabled: boolean): void;
+    /**
+     * Register a map listener and remember how to remove it, so a map owned by the host
+     * is left without our handlers after destroy().
+     */
+    protected listen(event: string, handler: (e: any) => void): void;
+    protected setupMapEventListeners(): void;
+    getRawMap<T = any>(): T;
+    /**
+     * Take every source and layer this adapter added off a map it does not own, so the host is
+     * handed back the map it created. Layers of the data source first, then anything named `_ofs_*`
+     * (the temporary drawing layers).
+     */
+    protected removeOwnLayers(): void;
+    destroy(): void;
+}
+
+export declare type BoundingBox = [number, number, number, number];
+
+/** Build contiguous breaks from ascending upper bounds, with colors, labels and counts */
+export declare function buildBreaks(sortedValues: number[], lower: number, uppers: number[], palette: Palette, reverse?: boolean): ClassBreak[];
+
+/**
+ * Expression evaluating to the class index of a feature, or -1. Null for single-symbol themes.
+ */
+export declare function buildClassIndexExpression(theme: ThematicDefinition): any[] | null;
+
+export declare function buildNetwork(points: Coordinate[], source: Coordinate, options?: NetworkOptions): NetworkResult;
+
+export declare const BUILTIN_MARKER_SHAPES: MarkerShape[];
+
+/** Points along a bulge segment (excluding the start point, including the end point) */
+export declare function bulgePoints(p1: Position, p2: Position, bulge: number, maxStepDeg: number): Position[];
+
+export declare class CADOperations {
+    /**
+     * Split a Polygon using a LineString.
+     * Creates a hairline buffer "blade" to perform difference, then flattens into pieces.
+     */
+    /**
+     * Extend a ray from startPt through endPt until safely outside the polygon's bounding box.
+     * Uses Cartesian unit vector in coordinate space to avoid spherical bearing drift.
+     */
+    private static extendRayOutside;
+    /**
+     * Prepare cutting line: ensures head and tail pierce outside the polygon if they stop inside.
+     * The cutting line is ALWAYS kept as a single continuous LineString (never decomposed into separate rays).
+     */
+    private static prepareCuttingLine;
+    /**
+     * Split a single Polygon by a single LineString using planar graph noded polygonization.
+     */
+    private static splitSinglePolygonByLine;
+    /**
+     * Split a Polygon using a LineString.
+     * Ensures cutting lines pierce completely through boundaries without leaving unsevered edges or dead-end slits.
+     */
+    static splitPolygonByLine(polygon: Feature<Polygon | MultiPolygon>, cuttingLine: Feature<LineString>): Feature<Polygon>[] | null;
+    /**
+     * Connect multiple LineStrings that share endpoints or are within tolerance
+     */
+    static connectLines(lines: Feature<LineString>[], toleranceMeters?: number, preserveFirstLineDirection?: boolean): Feature<LineString> | null;
+    /**
+     * Smooth a LineString using Bezier curve interpolation
+     */
+    static smoothLineBezier(line: Feature<LineString>, resolution?: number): Feature<LineString>;
+    /**
+     * Helper: extend a LineString forward and backward
+     */
+    private static extendLine;
+    /**
+     * Offset a LineString or Polygon (AutoCAD OFFSET), computed in planar meters.
+     * - LineString: parallel line with mitered joins (positive = right of direction, negative = left)
+     * - Polygon: sharp-cornered offset (positive = outward, negative = inward). An inward offset that
+     *   splits the shape returns a MultiPolygon; one that collapses it returns null.
+     * @param feature LineString or Polygon to offset
+     * @param distanceMeters Distance in meters
+     */
+    static offset(feature: Feature<LineString | Polygon>, distanceMeters: number): Feature<LineString | Polygon | MultiPolygon> | null;
+    /**
+     * Rotate a feature by angleDegrees around a pivot point (AutoCAD ROTATE), rigid in planar meters.
+     * @param feature Geometry feature to rotate
+     * @param angleDegrees Angle in degrees (clockwise)
+     * @param pivot Optional pivot point (defaults to feature centroid)
+     */
+    static rotate<T extends Geometry>(feature: Feature<T>, angleDegrees: number, pivot?: Coordinate): Feature<T>;
+    /**
+     * Scale a feature by scaleFactor around an origin point (AutoCAD SCALE), uniform in planar meters.
+     * @param feature Geometry feature to scale
+     * @param scaleFactor Scale multiplier (e.g. 1.5 = 150%, 0.8 = 80%)
+     * @param origin Optional origin point (defaults to feature centroid)
+     */
+    static scale<T extends Geometry>(feature: Feature<T>, scaleFactor: number, origin?: Coordinate): Feature<T>;
+    /**
+     * Explode a Polygon or MultiPolygon into individual LineString segments (AutoCAD EXPLODE)
+     */
+    static explode(feature: Feature<Polygon | MultiPolygon>): Feature<LineString>[];
+    /**
+     * Fillet (round corner) at a vertex with a true circular arc of radiusMeters (AutoCAD FILLET).
+     * Vertices other than the filleted corner keep their exact original coordinates.
+     * Returns null when the vertex cannot be filleted (endpoint of a line, straight corner,
+     * or radius too large for the adjacent segments). Use `maxFilletRadius` to find the limit.
+     */
+    static fillet(feature: Feature<Polygon | LineString>, vertexIndex: number, radiusMeters?: number): Feature<Polygon | LineString> | null;
+    /**
+     * Largest fillet radius (meters) that fits at the given vertex, or 0 if it cannot be filleted.
+     */
+    static maxFilletRadius(feature: Feature<Polygon | LineString>, vertexIndex: number): number;
+    private static getFilletCorner;
+    /**
+     * Translate / Move a feature by distance and bearing (AutoCAD MOVE), rigid in planar meters.
+     * @param feature Feature to translate
+     * @param distanceMeters Distance in meters
+     * @param bearingDegrees Direction in degrees (0 = North, 90 = East, 180 = South, 270 = West)
+     */
+    static translate<T extends Geometry>(feature: Feature<T>, distanceMeters: number, bearingDegrees: number): Feature<T>;
+    /**
+     * Translate a feature by planar offsets in meters (AutoCAD relative move @dx,dy)
+     * @param dxMeters Easting offset in meters (positive = East)
+     * @param dyMeters Northing offset in meters (positive = North)
+     */
+    static translateByMeters<T extends Geometry>(feature: Feature<T>, dxMeters: number, dyMeters: number): Feature<T>;
+    /**
+     * Move a feature by the displacement from `from` to `to` (AutoCAD MOVE base point -> second point).
+     * The base point lands exactly on the second point. The shape is measured on a ground-true plane at
+     * `from` and rebuilt on a plane at `to`, so edge lengths and true bearings are preserved even for
+     * long moves (a single plane would slowly rotate shapes moved kilometers away).
+     */
+    static translateByVector<T extends Geometry>(feature: Feature<T>, from: Coordinate, to: Coordinate): Feature<T>;
+    /**
+     * AutoCAD ALIGN: move source point 1 onto destination point 1, then (optionally) rotate so the
+     * direction source1->source2 matches destination1->destination2, and optionally scale so the
+     * lengths match. All steps are rigid / uniform on the ground plane.
+     */
+    static align<T extends Geometry>(feature: Feature<T>, source1: Coordinate, destination1: Coordinate, source2?: Coordinate | null, destination2?: Coordinate | null, scaleToFit?: boolean): Feature<T>;
+    /**
+     * Mirror a feature across the line through p1 and p2 (AutoCAD MIRROR).
+     * Polygon rings are reversed afterwards so their winding order is preserved.
+     */
+    static mirror<T extends Geometry>(feature: Feature<T>, p1: Coordinate, p2: Coordinate): Feature<T>;
+    /**
+     * Translate a feature by delta longitude and latitude
+     */
+    static translateByOffset<T extends Geometry>(feature: Feature<T>, dxLng: number, dyLat: number): Feature<T>;
+    /**
+     * Subtract a cutter feature from a target feature (AutoCAD SUBTRACT / Difference)
+     */
+    static difference(target: Feature<Polygon | MultiPolygon>, cutter: Feature<Polygon | MultiPolygon>): Feature<Polygon | MultiPolygon> | null;
+    /**
+     * Calculate intersection between two geometries (AutoCAD INTERSECT)
+     */
+    static intersect(featureA: Feature<Polygon | MultiPolygon>, featureB: Feature<Polygon | MultiPolygon>): Feature<Polygon | MultiPolygon> | null;
+    /**
+     * Simplify geometry using Douglas-Peucker algorithm
+     * @param feature Feature to simplify
+     * @param tolerance Tolerance in degrees (~0.0001 is ~10m)
+     */
+    static simplify<T extends Geometry>(feature: Feature<T>, tolerance?: number): Feature<T>;
+    /**
+     * Reverse coordinate direction of a LineString or Polygon ring
+     */
+    static reverse<T extends LineString | Polygon>(feature: Feature<T>): Feature<T>;
+    /**
+     * Clone feature with an optional new ID (AutoCAD COPY)
+     */
+    static cloneFeature<T extends Geometry>(feature: Feature<T>, newId?: string | number): Feature<T>;
+    /**
+     * Snap vertices of different features together when they are within toleranceMeters.
+     * Each vertex is moved onto the nearest vertex of an earlier feature in the list, so shared
+     * boundaries become exactly identical. Vertices within the same feature are never merged.
+     * Returns new features; inputs are not modified.
+     */
+    static snapVertices<T extends Geometry>(features: Feature<T>[], toleranceMeters?: number): Feature<T>[];
+    /**
+     * Remove redundant vertices that lie on a straight edge between their neighbors.
+     * A vertex is removed only if its perpendicular distance to the line through its neighbors is
+     * within toleranceMeters AND it lies between them, so real corners (even very shallow ones on
+     * long edges) are never removed. Remaining vertices keep their exact original coordinates.
+     * @param feature Polygon or MultiPolygon feature
+     * @param toleranceMeters Maximum perpendicular deviation in meters (default: 1 mm)
+     */
+    static cleanCollinearVertices<T extends Polygon | MultiPolygon>(feature: Feature<T>, toleranceMeters?: number): Feature<T>;
+    /**
+     * Split two overlapping polygons into mutually exclusive pieces:
+     * (A \ B, A ∩ B, B \ A)
+     */
+    static splitOverlappingPolygons(polyA: Feature<Polygon | MultiPolygon>, polyB: Feature<Polygon | MultiPolygon>): {
+        pieceA: Feature<Polygon>[];
+        overlap: Feature<Polygon>[];
+        pieceB: Feature<Polygon>[];
+    } | null;
+    /**
+     * Split a LineString by a Point, Coordinate, or another intersecting LineString (AutoCAD BREAK / SPLIT)
+     */
+    static splitLine(line: Feature<LineString>, splitter: Feature<Point | LineString> | Coordinate): Feature<LineString>[] | null;
+}
+
+/**
+ * Calculate bounding box from a list of coordinates.
+ */
+export declare function calculateBBox(coordinates: Coordinate[]): BoundingBox;
+
+export declare interface CalculateOptions {
+    onlySelected?: boolean;
+    /** Create the field when it does not exist yet (type defaults to the first result's type) */
+    createField?: FieldSchema | boolean;
+    /** Keep going when a feature fails instead of refusing the whole calculation (default: refuse) */
+    skipErrors?: boolean;
+}
+
+export declare interface CalculateResult {
+    field: string;
+    updated: number;
+    skipped: number;
+    errors: {
+        featureId: string | number;
+        message: string;
+    }[];
+}
+
+export declare interface CategoricalFieldStats {
+    distinctValues: string[];
+    frequencies: Record<string, number>;
+}
+
+export declare interface CategoricalThemeOptions {
+    reverse?: boolean;
+    baseSymbol?: SymbolStyleInput;
+}
+
+/**
+ * Index of the category whose value strictly equals `value` (type-sensitive: 1 and "1" differ, as in
+ * GL expressions), or -1.
+ */
+export declare function categoryIndexForValue(categories: CategoryItem[], value: unknown): number;
+
+export declare interface CategoryItem {
+    value: string | number | boolean;
+    color: string;
+    label: string;
+    count?: number;
+    visible?: boolean;
+    symbol?: ClassSymbolOverride;
+}
+
+/**
+ * Check one layer's features in one go. Features are not modified.
+ * On a large layer this can take a minute; `checkTopologyAsync` reports progress and can be stopped.
+ */
+export declare function checkTopology(features: AnyFeature[], layer: {
+    id: string;
+    name?: string;
+}, options?: TopologyOptions): TopologyReport;
+
+/**
+ * The same checks, handing control back between chunks so the page keeps responding.
+ * `onProgress` is called as the work moves on, and an aborted `signal` stops it with `TopologyCancelled`.
+ */
+export declare function checkTopologyAsync(features: AnyFeature[], layer: {
+    id: string;
+    name?: string;
+}, options?: TopologyOptions, control?: {
+    onProgress?: (progress: TopologyProgress) => void;
+    signal?: AbortSignal;
+    sliceMs?: number;
+}): Promise<TopologyReport>;
+
+export declare function childNamed(el: XmlElement, name: string): XmlElement | undefined;
+
+export declare function childrenNamed(el: XmlElement, name: string): XmlElement[];
+
+/**
+ * Graduated class. A value v belongs to the class when min < v <= max (the first class also includes
+ * v == min), the same rule QGIS uses. Rendering and counts both follow this rule.
+ */
+export declare interface ClassBreak {
+    min: number;
+    max: number;
+    color: string;
+    label: string;
+    count?: number;
+    /** Hidden classes are not drawn (default true) */
+    visible?: boolean;
+    /** Marker diameter / line width for graduated size mode */
+    size?: number;
+    symbol?: ClassSymbolOverride;
+}
+
+export declare type ClassificationMethod = 'equal_interval' | 'quantile' | 'natural_breaks' | 'pretty_breaks' | 'manual';
+
+export declare function classifyByMethod(method: ClassificationMethod, values: number[], numClasses: number, palette?: Palette, reverse?: boolean): ClassBreak[];
+
+/**
+ * Equal Interval Classification
+ */
+export declare function classifyEqualInterval(values: number[], numClasses: number, palette?: Palette, reverse?: boolean): ClassBreak[];
+
+/** Manual breaks from ascending upper bounds (the first class starts at the data minimum, or `lower`) */
+export declare function classifyManual(values: number[], uppers: number[], palette?: Palette, lower?: number, reverse?: boolean): ClassBreak[];
+
+/**
+ * Jenks Natural Breaks Classification (Fisher-Jenks: minimizes the sum of squared deviations from
+ * the class means).
+ */
+export declare function classifyNaturalBreaks(values: number[], numClasses: number, palette?: Palette, reverse?: boolean): ClassBreak[];
+
+/**
+ * Pretty Breaks: round boundaries (multiples of 1, 2 or 5 × 10^n) close to the requested class count.
+ * The first class starts at the data minimum and the last ends at the maximum.
+ */
+export declare function classifyPrettyBreaks(values: number[], numClasses: number, palette?: Palette, reverse?: boolean): ClassBreak[];
+
+/**
+ * Quantile Classification (equal count per class). Tied values cannot be split, so classes may hold
+ * unequal counts and duplicate boundaries collapse into fewer classes.
+ */
+export declare function classifyQuantile(values: number[], numClasses: number, palette?: Palette, reverse?: boolean): ClassBreak[];
+
+/**
+ * Categorical / Unique Values Classification. Values are compared by type (1 and "1" are different
+ * categories, matching how the map evaluates them) and sorted.
+ */
+export declare function classifyUniqueValues(values: (string | number | boolean)[], palette?: Palette, reverse?: boolean): CategoryItem[];
+
+/** Index of the class containing `value`, or -1 (non-numeric or outside all classes) */
+export declare function classIndexForValue(breaks: ClassBreak[], value: unknown): number;
+
+/** Number of decimals that keeps class boundaries readable and distinct */
+export declare function classLabelPrecision(breaks: {
+    min: number;
+    max: number;
+}[]): number;
+
+export declare interface ClassPatch {
+    color?: string;
+    label?: string;
+    min?: number;
+    max?: number;
+    size?: number;
+    visible?: boolean;
+    /** Merged into the existing override; pass null to clear all overrides */
+    symbol?: ClassSymbolOverride | null;
+}
+
+/** Per-class overrides of the data-driven symbol properties */
+export declare interface ClassSymbolOverride {
+    color?: string;
+    opacity?: number;
+    strokeColor?: string;
+    /** Polygon outline width or marker stroke width */
+    strokeWidth?: number;
+    /** Line width (line layers) or marker diameter (point layers) */
+    size?: number;
+    /** Hatch pattern for polygon classes; null forces no pattern */
+    pattern?: HatchPattern | null;
+    shape?: MarkerShape;
+    icon?: string;
+    rotationDeg?: number;
+}
+
+/**
+ * Check and convert one value for a field. Text is converted to the field type only when the meaning is
+ * unambiguous ("12" for a number field, "true"/"1" for a boolean); anything else is refused.
+ */
+export declare function coerceFieldValue(field: FieldSchema, raw: unknown): CoerceResult;
+
+export declare type CoerceResult = {
+    ok: true;
+    value: string | number | boolean | null;
+} | {
+    ok: false;
+    error: string;
+};
+
+/** Convert one raw value (string from the command line, or JSON value) to the schema's type */
+export declare function coerceValue(value: unknown, property: string, schema: any, issues: string[]): unknown;
+
+/** Vertices this close to a result edge are the same line (floating-point noise only) */
+export declare const COLLINEAR_RESTORE_METERS = 0.000001;
+
+export declare interface ColorRampDefinition {
+    name: string;
+    type: ColorRampType;
+    source: 'colorbrewer' | 'carto' | 'matplotlib' | 'ofs';
+    colors: string[];
+}
+
+/** CSS linear-gradient preview of a ramp (for pickers) */
+export declare function colorRampGradientCss(name: string, reverse?: boolean): string;
+
+/**
+ * Cartographic Color Ramps & Color Utilities
+ *
+ * Named ramps from ColorBrewer (Cynthia Brewer, Penn State), CARTOColors (CARTO) and matplotlib
+ * (viridis family). Names are case-insensitive ("YlGn", "ylgn").
+ *
+ * - Sequential / diverging ramps are interpolated in Lab space to any class count.
+ * - Qualitative ramps are never interpolated (blending two category colors gives a misleading third
+ *   color); their colors are used in order, and extra colors are generated deterministically.
+ */
+export declare type ColorRampType = 'sequential' | 'diverging' | 'qualitative';
+
+export declare interface CommandArgSpec {
+    /** Schema properties filled from the words before any --option, in order */
+    positional?: string[];
+    /**
+     * Property that collects every remaining word. A text property keeps the words exactly as they were
+     * typed (quotes and spacing included, e.g. an expression); an array property gets one entry per word.
+     */
+    rest?: string;
+    /** Extra option spellings: option name (without --) → property name */
+    aliases?: Record<string, string>;
+    /** Properties usable as `--flag` without a value (booleans are flags automatically) */
+    flags?: string[];
+    /** Options that stand for one fixed value, e.g. `--add` → mode "add", `--xy` → csvGeometry "xy" */
+    switches?: Record<string, {
+        property: string;
+        value: unknown;
+    }>;
+    /**
+     * Where a word goes when it does not fit a positional property that lists its values, e.g.
+     * `{ action: 'layerId' }`: "fields add …" is the action, "fields plots" is the layer.
+     */
+    fallback?: Record<string, string>;
+}
+
+export declare class CommandCancelledError extends OFSError {
+    constructor(message?: string);
+}
+
+export declare interface CommandEngineEvents {
+    'workflow:start': {
+        context: OFSWorkflowContext;
+    };
+    'workflow:step': {
+        context: OFSWorkflowContext;
+        commandName: string;
+    };
+    'workflow:waiting': {
+        context: OFSWorkflowContext;
+        prompt: string;
+    };
+    'workflow:completed': {
+        context: OFSWorkflowContext;
+    };
+    'workflow:failed': {
+        context: OFSWorkflowContext;
+        error: Error;
+    };
+    'workflow:cancelled': {
+        context: OFSWorkflowContext;
+    };
+}
+
+export declare interface CommandHistoryItem {
+    command: string;
+    status: 'success' | 'error';
+    durationMs: number;
+    errorMsg?: string;
+    resultSummary?: string;
+}
+
+/** Sort category values: numbers ascending, then booleans, then strings (natural, locale-aware) */
+export declare function compareCategoryValues(a: string | number | boolean, b: string | number | boolean): number;
+
+export declare interface CompiledExpression {
+    source: string;
+    /** Field names the expression reads */
+    fields: string[];
+    evaluate(feature: Feature<Geometry, any>, row?: number): ExpressionValue;
+    /** Evaluate as a filter: NULL and false are "no" */
+    test(feature: Feature<Geometry, any>, row?: number): boolean;
+}
+
+export declare interface CompiledGLLayer {
+    id: string;
+    role: GLLayerRole;
+    type: 'fill' | 'line' | 'circle' | 'symbol';
+    filter: any[];
+    paint: Record<string, any>;
+    layout: Record<string, any>;
+    /** Zoom range of the GL layer (labels only, so far) */
+    minzoom?: number;
+    maxzoom?: number;
+}
+
+export declare interface CompiledLayerStyle {
+    /** Paint of the main GL layer (kept for existing callers) */
+    paint: Record<string, any>;
+    layout?: Record<string, any>;
+    /** GL layers, bottom to top */
+    layers: CompiledGLLayer[];
+    /** Map images the layers reference (patterns, marker icons) */
+    images: SymbolImageRequest[];
+}
+
+/**
+ * Parse an expression once and reuse it for every feature.
+ * @param knownFields when given, unknown field names are an error instead of NULL
+ */
+export declare function compileExpression(source: string, knownFields?: Iterable<string>): CompiledExpression;
+
+/**
+ * Compile the label settings into a GL symbol layer. Expression labels read the text from the
+ * `_ofs_label` property the adapter fills in; field labels read the field directly.
+ */
+export declare function compileLabelLayer(label: LabelSettings | undefined, layerId: string, kind: 'polygon' | 'line' | 'point', layerOpacity?: number): CompiledGLLayer | null;
+
+/** Feature count per class (index -1 = matches no class), using the same rules the map renders with */
+export declare function computeClassCounts(theme: ThematicDefinition, layer: OFSLayerData): Map<number, number>;
+
+/**
+ * Everything a host application needs to render the transcript itself.
+ * The widget works without `mount()`: drive it with `submit()` and draw these events.
+ */
+export declare interface ConsoleEventMap {
+    'console:line': ConsoleLine;
+    'console:cleared': void;
+    /** A command started or finished waiting for input; `promptText` is null when nothing is pending */
+    'console:prompt': {
+        promptText: string | null;
+    };
+}
+
+/** Handles command-line text while no command is waiting for input (e.g. typed points while drawing) */
+export declare type ConsoleInputInterceptor = (text: string) => {
+    handled: boolean;
+    message?: string;
+    error?: string;
+};
+
+export declare interface ConsoleInputRequest {
+    promptText: string;
+    type?: 'text' | 'coordinate' | 'number' | 'confirmation';
+}
+
+export declare interface ConsoleLine {
+    kind: ConsoleLineKind;
+    text: string;
+    time: number;
+}
+
+export declare type ConsoleLineKind = 'system' | 'input' | 'output' | 'prompt' | 'error' | 'success';
+
+/**
+ * Source of map-picked points and cursor position for point prompts (implemented by OFSDrawTools)
+ */
+export declare interface ConsolePointProvider {
+    beginPointPick(options: {
+        basePoint?: Coordinate | null;
+    }, onPick: (coord: Coordinate) => void): () => void;
+    getCursorCoordinate(): Coordinate | null;
+    readonly inputFrame: InputFrame;
+}
+
+export declare interface ConstrainedPoint {
+    coordinate: Coordinate;
+    /** Locked direction in the frame's convention, when a constraint applied */
+    lockedAngle: number | null;
+    mode: 'ortho' | 'polar' | null;
+}
+
+/**
+ * Apply ORTHO (always lock to UCS axes) or POLAR tracking (lock when near an increment) to a cursor
+ * position relative to `anchor`. The cursor is projected onto the locked direction.
+ */
+export declare function constrainToAngle(anchor: Coordinate, cursor: Coordinate, options: {
+    ortho: boolean;
+    polar: PolarTrackingSettings;
+    frame: InputFrame;
+}): ConstrainedPoint;
+
+/**
+ * OFSObject Core Types
+ */
+export declare type Coordinate = [number, number];
+
+export declare type Coordinate3D = [number, number, number];
+
+export declare interface CoordinateInputContext {
+    /** Last placed point / base point that relative input is measured from */
+    basePoint?: Coordinate | null;
+    /** Current cursor position, used for direct distance entry */
+    cursor?: Coordinate | null;
+    frame?: InputFrame;
+}
+
+export declare type CoordinateInputResult = {
+    kind: 'point';
+    coordinate: Coordinate;
+    description: string;
+} | {
+    kind: 'error';
+    message: string;
+};
+
+/** Why a text is not a coordinate, naming the right order when the numbers were simply swapped */
+export declare function coordinateProblem(raw: string): string;
+
+export declare function createCadCommands(drawTools: OFSDrawTools, dataSource: OFSDataSource): OFSCommandProcess[];
+
+export declare function createDrawCommands(drawTools: OFSDrawTools, dataSource: OFSDataSource): OFSCommandProcess[];
+
+export declare function createIoCommands(dataSource: OFSDataSource, io: OFSFileIO, onImported?: (layerIds: string[]) => void): OFSCommandProcess[];
+
+export declare function createMapCommands(mapAdapter: IMapAdapter, dataSource: OFSDataSource, legendTools: OFSLegendTools, registry: OFSCommandRegistry): OFSCommandProcess[];
+
+export declare function createSpatialCommands(dataSource: OFSDataSource, drawTools: OFSDrawTools): OFSCommandProcess[];
+
+export declare function createSymbologyCommands(dataSource: OFSDataSource, legendTools: OFSLegendTools): OFSCommandProcess[];
+
+/**
+ * OGC WKT 1 with an explicit TOWGS84, for formats that store a CRS definition (GeoPackage). Only for the
+ * built-in Indian 1975 CRSs, whose EPSG codes alone make GDAL / QGIS choose their own datum transformation.
+ */
+export declare function crsToOgcWkt(crs: ResolvedCrs): string;
+
+/** WKT for .prj export (ESRI flavour for common CRSs) */
+export declare function crsToPrj(crs: ResolvedCrs): string;
+
+export declare interface DbfTable {
+    fields: (FieldDefinition & {
+        dbfType: string;
+        length: number;
+        decimals: number;
+    })[];
+    records: Record<string, any>[];
+    deleted: boolean[];
+    encoding: string;
+}
+
+export declare interface DbfWriteResult {
+    dbf: Uint8Array;
+    cpg: string;
+    fieldNames: Map<string, string>;
+}
+
+export declare function decodeEntities(text: string): string;
+
+export declare function decodeRecord(payload: Uint8Array): SqlValue[];
+
+/** Default tolerance for treating a vertex as lying on a straight edge (1 mm) */
+export declare const DEFAULT_COLLINEAR_TOLERANCE_METERS = 0.001;
+
+export declare const DEFAULT_DRAW_GUIDES: DrawGuideSettings;
+
+export declare const DEFAULT_HATCH: HatchPattern;
+
+export declare const DEFAULT_INPUT_FRAME: InputFrame;
+
+export declare const DEFAULT_MAX_GRID_POINTS = 50000;
+
+export declare const DEFAULT_MAX_NETWORK_POINTS = 5000;
+
+export declare const DEFAULT_POLAR_TRACKING: PolarTrackingSettings;
+
+export declare const DEFAULT_SYMBOL_COLOR = "#3b82f6";
+
+export declare const DEFAULT_TOPOLOGY_OPTIONS: ResolvedTopologyOptions;
+
+export declare function defaultSymbolStyle(color?: string): SymbolStyle;
+
+/** All descendants with a local name (depth-first, document order) */
+export declare function descendantsNamed(el: XmlElement, name: string, out?: XmlElement[]): XmlElement[];
+
+/** Help lines for one command, built from its schema */
+export declare function describeCommand(command: OFSCommandProcess): string[];
+
+export declare function describeTheme(theme: ThematicDefinition, layer: OFSLayerData): string[];
+
+/** Detect the encoding of character field bytes; returns null for pure ASCII */
+export declare function detectTextEncoding(samples: Uint8Array[]): {
+    encoding: string;
+    confidence: 'ascii' | 'valid-utf8' | 'thai-bytes' | 'guess';
+};
+
+/** Fields found in the features, in the order they first appear (internal properties are left out) */
+export declare function discoverFields(features: Feature<Geometry, any>[]): FieldSchema[];
+
+export declare interface DistanceMeasure {
+    segments: SegmentMeasure[];
+    totalMeters: number;
+    /** Straight line from the first to the last point */
+    closingMeters: number;
+}
+
+/** Save an exported image in the browser */
+export declare function downloadMapImage(image: MapImage): void;
+
+export declare interface DrawEvents {
+    'draw:mode-change': {
+        mode: DrawMode;
+    };
+    'draw:start': {
+        mode: DrawMode;
+        coordinate: Coordinate;
+    };
+    'draw:vertex-added': {
+        mode: DrawMode;
+        coordinate: Coordinate;
+        coordinates: Coordinate[];
+    };
+    'draw:move': {
+        coordinate: Coordinate;
+        isSnapped: boolean;
+        snapResult?: SnapResult;
+    };
+    'draw:complete': {
+        mode: DrawMode;
+        feature: Feature<Geometry, any>;
+        layerId: string;
+    };
+    'draw:cancel': {
+        mode: DrawMode;
+    };
+    'draw:ortho-change': {
+        enabled: boolean;
+    };
+    'draw:measure': {
+        distanceMeters: number;
+        bearingDegrees: number;
+        /** Direction in the configured angle convention, relative to the UCS */
+        angle: number;
+        /** Active angle constraint, if any */
+        constraint: 'ortho' | 'polar' | 'tracking' | null;
+        coordinate: Coordinate;
+    };
+    'draw:polar-change': {
+        enabled: boolean;
+        incrementDeg: number;
+    };
+    'draw:ucs-change': {
+        ucsRotationDeg: number;
+        convention: AngleConvention;
+    };
+    'draw:vertex-removed': {
+        mode: DrawMode;
+        coordinates: Coordinate[];
+    };
+    'draw:tracking-points': {
+        points: Coordinate[];
+    };
+    'draw:otrack-change': {
+        enabled: boolean;
+    };
+    'selection:draw-complete': {
+        mode: 'select-box' | 'select-polygon';
+        selectionPolygon: Feature<Polygon>;
+        selectedFeatures: Feature<Geometry, any>[];
+        count: number;
+    };
+    'selection:drag-progress': {
+        widthMeters: number;
+        heightMeters: number;
+        count: number;
+        coordinate: Coordinate;
+    };
+}
+
+/**
+ * Transient drawing guides: the crosshair across the map and the measurements written on it.
+ * These are never saved — for dimensions that stay with a feature see `3D-3` in ROADMAP.md.
+ */
+export declare interface DrawGuideSettings {
+    /** Dashed lines across the whole viewport through the anchor */
+    crosshair: boolean;
+    /** Length of the segment being dragged, written on the map */
+    dimensions: boolean;
+    /** Also measure the segments already drawn, not just the one under the cursor */
+    segmentLabels: boolean;
+    /** Area (and perimeter) of the polygon being drawn */
+    areaLabel: boolean;
+    /** What the crosshair follows: the cursor, like a CAD crosshair, or the last point clicked */
+    anchor: 'cursor' | 'vertex';
+    crosshairColor: string;
+    crosshairWidth: number;
+    /** Arc and degrees at each corner, always the angle of 180 degrees or less */
+    angles: boolean;
+    /** How far off the segment the dimension line sits, in screen pixels */
+    dimensionOffsetPixels: number;
+    /** Glyph names for the labels; the map style must provide them */
+    font: string[];
+}
+
+/** Minimal 2D context surface used by the drawing helpers (so they can be tested without a DOM) */
+export declare interface DrawingContext {
+    save(): void;
+    restore(): void;
+    beginPath(): void;
+    moveTo(x: number, y: number): void;
+    lineTo(x: number, y: number): void;
+    closePath(): void;
+    fill(): void;
+    stroke(): void;
+    fillRect(x: number, y: number, w: number, h: number): void;
+    strokeRect(x: number, y: number, w: number, h: number): void;
+    fillText(text: string, x: number, y: number): void;
+    translate(x: number, y: number): void;
+    rotate(angle: number): void;
+    fillStyle: string;
+    strokeStyle: string;
+    lineWidth: number;
+    font: string;
+    textAlign: string;
+    textBaseline: string;
+}
+
+export declare interface DrawInputResult {
+    /** True if the text was consumed as drawing input */
+    handled: boolean;
+    message?: string;
+    error?: string;
+}
+
+export declare type DrawMode = 'point' | 'line' | 'polygon' | 'circle' | 'rectangle' | 'select' | 'select-box' | 'select-polygon' | 'modify' | null;
+
+/**
+ * Draw a north arrow centred at (x, y). `bearingDeg` is the map rotation (the map's bearing), so the
+ * arrow turns the opposite way and keeps pointing at true north.
+ */
+export declare function drawNorthArrow(ctx: DrawingContext, x: number, y: number, size?: number, bearingDeg?: number): void;
+
+/** Draw a scale bar with its left end at (x, y) (y is the bottom of the bar) */
+export declare function drawScaleBar(ctx: DrawingContext, plan: ScaleBarPlan, x: number, y: number, style?: ScaleBarStyle): void;
+
+export declare class DuplicateFeatureIdError extends OFSError {
+    constructor(featureId: string | number, layerId?: string);
+}
+
+export declare interface DxfLayerInput {
+    name: string;
+    features: Feature<Geometry, Record<string, any>>[];
+}
+
+export declare interface DynamicInputState {
+    distanceMeters?: number | null;
+    angle?: number | null;
+    convention?: 'bearing' | 'cad';
+    constraint?: 'ortho' | 'polar' | 'tracking' | null;
+    snapType?: SnapType | null;
+}
+
+export declare function encodeRecord(values: SqlValue[]): Uint8Array;
+
+/** TIS-620 encoder (Thai U+0E01..U+0E5B <-> 0xA1..0xFB); unsupported characters become '?' */
+export declare function encodeTis620(text: string): {
+    bytes: Uint8Array;
+    lossy: boolean;
+};
+
+export declare function encodeVarint(input: number | bigint): number[];
+
+/** Escape text for use in HTML content or attribute values */
+export declare function escapeHtml(value: unknown): string;
+
+export declare function escapeXml(text: string): string;
+
+/**
+ * Euclidean distance in 2D coordinate space.
+ */
+export declare function euclideanDistance(p1: [number, number], p2: [number, number]): number;
+
+/** Evaluate an expression for one feature (parses every time; use compileExpression for many features) */
+export declare function evaluateExpression(source: string, feature: Feature<Geometry, any>, knownFields?: Iterable<string>): ExpressionValue;
+
+/**
+ * Framework-agnostic Typed Event Emitter
+ */
+export declare type EventHandler<T = any> = (data: T) => void;
+
+/** Expand a lng/lat bbox by a distance in meters */
+export declare function expandBBox(bbox: [number, number, number, number], meters: number): [number, number, number, number];
+
+export declare const EXPORT_FORMATS: ExportFormat[];
+
+export declare function exportCsv(features: Feature<Geometry, Record<string, any>>[], options?: ExportOptions, issues?: ImportIssue[]): ExportedFile;
+
+export declare function exportDxf(layers: DxfLayerInput[], options?: ExportOptions, issues?: ImportIssue[]): ExportedFile & {
+    crs: ResolvedCrs;
+};
+
+export declare interface ExportedFile {
+    filename: string;
+    mimeType: string;
+    data: Uint8Array | string;
+}
+
+export declare type ExportFormat = 'geojson' | 'shapefile' | 'gpkg' | 'kml' | 'kmz' | 'csv' | 'dxf';
+
+export declare function exportGeoJSON(features: Feature<Geometry, any>[], options?: ExportOptions): ExportedFile;
+
+export declare function exportGeoPackage(layers: GeoPackageLayerInput[], options?: ExportOptions, issues?: ImportIssue[]): ExportedFile;
+
+export declare function exportKml(features: Feature<Geometry, Record<string, any>>[], options?: ExportOptions): ExportedFile;
+
+export declare function exportKmlText(features: Feature<Geometry, Record<string, any>>[], options?: ExportOptions): string;
+
+export declare function exportKmz(features: Feature<Geometry, Record<string, any>>[], options?: ExportOptions): ExportedFile;
+
+/**
+ * Render the current map view into an image. Browser only (needs a canvas).
+ */
+export declare function exportMapImage(adapter: IMapAdapter, options?: MapExportOptions): MapImage;
+
+export declare interface ExportOptions {
+    /** Target CRS (default EPSG:4326; DXF defaults to the WGS 84 UTM zone of the data) */
+    crs?: string;
+    /** DBF / CSV text encoding: 'utf-8' (default) or 'tis-620' */
+    encoding?: string;
+    /** Decimal places for coordinates (default 8 for degrees, 3 for meters) */
+    precision?: number;
+    /** File name without extension */
+    name?: string;
+    /** CSV: 'wkt' column (default) or 'xy' columns (points only) */
+    csvGeometry?: 'wkt' | 'xy';
+}
+
+/** Zipped shapefile(s): one shapefile per geometry kind present */
+export declare function exportShapefileZip(features: Feature<Geometry, Record<string, any>>[], fields: FieldDefinition[], options?: ExportOptions, issues?: ImportIssue[]): ExportedFile;
+
+export declare const EXPRESSION_FUNCTIONS: Record<string, FunctionSpec>;
+
+export declare interface ExpressionContext {
+    feature: Feature<Geometry, any>;
+    /** 0-based position in the current result set (for $row) */
+    row?: number;
+}
+
+export declare class ExpressionError extends Error {
+    readonly position?: number | undefined;
+    constructor(message: string, position?: number | undefined);
+}
+
+export declare type ExpressionValue = string | number | boolean | null;
+
+export declare class FeatureNotFoundError extends OFSError {
+    constructor(featureId: string | number, layerId?: string);
+}
+
+declare type FeatureSource = OFSLayerData | Feature<Geometry, any>[];
+
+export declare type FeatureState = {
+    hover?: boolean;
+    selected?: boolean;
+    active?: boolean;
+    disabled?: boolean;
+    [key: string]: unknown;
+};
+
+export declare interface FieldDefinition {
+    name: string;
+    type: 'string' | 'number' | 'boolean' | 'date';
+    /** Original name when it had to be changed (e.g. DBF 10-character limit) */
+    sourceName?: string;
+}
+
+export declare interface FieldSchema {
+    name: string;
+    type: FieldType;
+    /** Original name in the source file when it had to be changed (DBF 10-character limit) */
+    sourceName?: string;
+    /** Label shown instead of the name */
+    alias?: string;
+    /** Value used for new features and for a new field */
+    defaultValue?: string | number | boolean | null;
+    /** Only these values are accepted (pick list) */
+    allowedValues?: (string | number | boolean)[];
+    /** NULL / empty is refused */
+    required?: boolean;
+    /** Decimals shown in the table (display only, values keep their precision) */
+    precision?: number;
+    /** Maximum text length */
+    length?: number;
+    min?: number;
+    max?: number;
+    /** The table refuses to edit this field */
+    readOnly?: boolean;
+}
+
+export declare interface FieldStatistics {
+    field: string;
+    type: FieldSchema['type'];
+    count: number;
+    nullCount: number;
+    min?: number | string;
+    max?: number | string;
+    sum?: number;
+    mean?: number;
+    median?: number;
+    stdDev?: number;
+    distinct?: number;
+    topValues?: {
+        value: string;
+        count: number;
+    }[];
+}
+
+export declare type FieldType = 'string' | 'number' | 'boolean' | 'date';
+
+/** Merge a gap polygon into a neighbouring polygon */
+export declare function fillGap(receiver: Polygon | MultiPolygon, gap: Polygon, neighbours?: Geometry[]): Polygon | MultiPolygon;
+
+export declare interface FillSymbol {
+    color: string;
+    opacity: number;
+    /** 'solid' fills with color, 'pattern' draws the hatch (over color when patternBackground), 'none' = outline only */
+    style: 'solid' | 'pattern' | 'none';
+    pattern?: HatchPattern;
+    /** With style 'pattern', also paint `color` behind the hatch */
+    patternBackground?: boolean;
+    outlineColor: string;
+    outlineWidth: number;
+    outlineOpacity: number;
+    /** Outline dash pattern in pixels (layer-wide) */
+    outlineDash?: number[];
+    /** Screen offset [x, y] in pixels (layer-wide) */
+    offset?: [number, number];
+}
+
+export declare function findField(fields: FieldSchema[], name: string): FieldSchema | undefined;
+
+/**
+ * Find the first feature (in any layer) that intersects `target`, uses the layer R-tree index
+ * to test only features whose bounding boxes overlap the target.
+ */
+export declare function findIntersectingFeature(dataSource: OFSDataSource, target: Feature<Geometry>, accept: (feature: Feature<Geometry, any>) => boolean): {
+    layerId: string;
+    feature: Feature<Geometry, any>;
+} | null;
+
+export declare function forEachPosition(geometry: Geometry, fn: (c: Position) => void): void;
+
+/** Degrees as "45°30'20"" (bearing) or "45.5056°" */
+export declare function formatAngle(degrees: number, convention?: AngleConvention | 'decimal'): string;
+
+/** "4,000.00 m² · 2.50 rai · 2-2-0.0 (rai-ngan-wa)" */
+export declare function formatArea(areaSqm: number, decimals?: number): string;
+
+export declare function formatClassLabel(min: number, max: number, precision: number): string;
+
+/**
+ * Build the command line text for an argument object, so an AI tool call runs through exactly the same
+ * path as typed input. Commands without an `args` spec get their arguments as JSON.
+ */
+export declare function formatCommandArgs(command: OFSCommandProcess, args: Record<string, unknown>): string;
+
+/**
+ * Format a coordinate for display, in the same lng,lat order the library reads,
+ * so a coordinate shown on screen can be typed straight back into a command.
+ */
+export declare function formatCoordinate(coord: Coordinate, precision?: number): string;
+
+/** Text shown in the HUD for a measurement state (pure, for reuse and testing) */
+export declare function formatDynamicInputLabel(state: DynamicInputState): string;
+
+/** Value as shown in the attribute table (precision applies to display only) */
+export declare function formatFieldValue(field: FieldSchema | undefined, value: unknown): string;
+
+/** "123.456 m" / "1.235 km" */
+export declare function formatLength(meters: number, decimals?: number): string;
+
+/** Thai land measure: "rai-ngan-wa" (1 rai = 4 ngan = 400 square wa) */
+export declare function formatRaiNganWa(areaSqm: number, decimals?: number): string;
+
+declare interface FunctionSpec {
+    minArgs: number;
+    maxArgs: number;
+    /** Short description for help output / UI */
+    help: string;
+    call: (args: ExpressionValue[], ctx: ExpressionContext) => ExpressionValue;
+}
+
+export declare function generateAiToolDeclarations(registry: OFSCommandRegistry): AiToolDeclaration[];
+
+/**
+ * Generate smooth Bezier curve through given control points.
+ */
+export declare function generateBezierCurve(points: Coordinate[], segments?: number): Coordinate[];
+
+/**
+ * Generate `count` colors from a ramp name or explicit color list.
+ * @param reverse Reverse the ramp direction (e.g. dark-to-light)
+ */
+export declare function generateColors(palette: PaletteName | string | string[], count: number, reverse?: boolean): string[];
+
+/** Generate a feature ID that is unique across the session */
+export declare function generateFeatureId(): string;
+
+export declare function geometryBBox(geometry: Geometry): [number, number, number, number];
+
+/** Convert a geometry from WGS84 lng/lat to `crs` */
+export declare function geometryFromWgs84<G extends Geometry>(geometry: G, crs: ResolvedCrs): G;
+
+export declare function geometryKind(type: string): ImportGeometryKind | null;
+
+/** Convert a geometry from `crs` to WGS84 lng/lat */
+export declare function geometryToWgs84<G extends Geometry>(geometry: G, crs: ResolvedCrs): G;
+
+export declare type GeometryType = 'Point' | 'MultiPoint' | 'LineString' | 'MultiLineString' | 'Polygon' | 'MultiPolygon' | 'GeometryCollection';
+
+export declare interface GeoPackageLayerInput {
+    name: string;
+    features: Feature<Geometry, Record<string, any>>[];
+    fields?: FieldDefinition[];
+}
+
+/** Look up a ramp by name (case-insensitive) */
+export declare function getColorRamp(name: string): ColorRampDefinition | undefined;
+
+/**
+ * Complete schema of a layer: the stored schema first, then fields that only exist in the data.
+ */
+export declare function getLayerSchema(layer: LayerLike): FieldSchema[];
+
+export declare function getMarkerIcon(name: string): MarkerIconDefinition | undefined;
+
+declare interface GLLayerRecord {
+    id: string;
+    type: string;
+    filter: string;
+    paint: Record<string, string>;
+    layout: Record<string, string>;
+    minzoom?: number;
+    maxzoom?: number;
+}
+
+export declare type GLLayerRole = 'fill' | 'pattern' | 'stroke' | 'line' | 'circle' | 'marker' | 'label';
+
+export declare type GraduatedMode = 'color' | 'size';
+
+export declare interface GraduatedThemeOptions {
+    reverse?: boolean;
+    mode?: GraduatedMode;
+    sizeRange?: [number, number];
+    baseSymbol?: SymbolStyleInput;
+}
+
+export declare interface GridOptions {
+    /** Distance between neighbouring points in meters */
+    spacingMeters: number;
+    /** Row spacing when it differs from the column spacing (square pattern only) */
+    rowSpacingMeters?: number;
+    pattern?: GridPattern;
+    /** Turn the grid this many degrees counter-clockwise from east */
+    rotateDegrees?: number;
+    /** Keep points at least this far inside the boundary */
+    insetMeters?: number;
+    /** Refuse rather than build a layout this large (default 50,000) */
+    maxPoints?: number;
+}
+
+export declare type GridPattern = 'square' | 'triangular';
+
+/**
+ * Fill `boundary` with points `spacingMeters` apart.
+ *
+ * @param boundary One or more polygons in lng/lat; a point is kept when it falls inside any of them
+ */
+export declare function gridPoints(boundary: (Polygon | MultiPolygon)[], options: GridOptions): GridResult;
+
+export declare interface GridResult {
+    points: Coordinate[];
+    /** Points the pattern produced before the boundary was applied */
+    candidates: number;
+    pattern: GridPattern;
+    spacingMeters: number;
+    rowSpacingMeters: number;
+}
+
+export declare class GridTooLargeError extends OFSError {
+    constructor(count: number, max: number, spacingMeters: number);
+}
+
+export declare interface GripHandle {
+    id: string;
+    coordinate: Coordinate;
+    type: 'vertex' | 'midpoint' | 'center';
+    index: number;
+    ringIndex: number;
+    partIndex?: number;
+}
+
+export declare interface GripsEditorEvents {
+    'grip:select': {
+        handle: GripHandle;
+    };
+    'grip:move': {
+        handle: GripHandle;
+        coordinate: Coordinate;
+    };
+    'grip:commit': {
+        featureId: string | number;
+        layerId: string;
+    };
+    'grip:delete-vertex': {
+        featureId: string | number;
+        index: number;
+    };
+    'grip:clear': void;
+}
+
+/** Stable short hash for image ids */
+export declare function hashString(text: string): string;
+
+/** True for CRSs whose datum shift is project-specific (EPSG code alone is ambiguous in other software) */
+export declare function hasProjectDatumShift(crs: ResolvedCrs): boolean;
+
+export declare function hatchImageId(pattern: HatchPattern): string;
+
+/** Hatch fill pattern, rasterized into a seamless map image */
+export declare interface HatchPattern {
+    kind: 'lines' | 'cross' | 'dots';
+    color: string;
+    /** Distance between lines / dots in pixels */
+    spacing: number;
+    /** Line angle in degrees counter-clockwise from horizontal (0 = "—", 45 = "/", 90 = "|"), as in QGIS */
+    angleDeg: number;
+    /** Line width, or dot diameter, in pixels */
+    lineWidth: number;
+    /** Optional dash pattern along the hatch lines, in pixels */
+    dash?: number[];
+}
+
+export declare interface HatchTilePlan {
+    /** Tile side in device pixels */
+    size: number;
+    pixelRatio: number;
+    color: string;
+    /** Line width / dot diameter in device pixels */
+    lineWidth: number;
+    /** Segments [x1, y1, x2, y2] in device pixels (may extend past the tile; clip when drawing) */
+    segments: [number, number, number, number][];
+    /** Dot centers in device pixels (including wrapped copies near the edges) */
+    dots: [number, number][];
+    /** Dash pattern in device pixels; each segment starts at a dash period boundary */
+    dash: number[] | null;
+    effectiveAngleDeg: number;
+    effectiveSpacing: number;
+}
+
+/**
+ * Calculate distance between two coordinates in meters (Haversine formula).
+ */
+export declare function haversineDistance(c1: Coordinate, c2: Coordinate): number;
+
+export declare interface IMapAdapter {
+    readonly engineName: 'maplibre' | 'mapbox';
+    readonly isReady: boolean;
+    /** Create the map engine in a DOM container */
+    init(container: HTMLElement | string, options?: Record<string, any>): Promise<void>;
+    /**
+     * Use a map the host application created and still owns. Resolves once its style is ready;
+     * `destroy()` then removes only what OFSObject added and leaves the map running.
+     */
+    attach(map: unknown): Promise<void>;
+    /** Bind to central data source and thematic engine */
+    bindDataSource(dataSource: OFSDataSource, thematicEngine?: OFSThematicEngine): void;
+    /** Viewport methods */
+    fitBounds(bbox: BoundingBox, padding?: number): void;
+    flyTo(options: MapViewportOptions): void;
+    getCenter(): Coordinate;
+    setCenter(coord: Coordinate): void;
+    getZoom(): number;
+    setZoom(zoom: number): void;
+    getBounds(): BoundingBox;
+    /** Source & Layer syncing */
+    syncLayer(layer: OFSLayerData): void;
+    removeLayer(layerId: string): void;
+    setLayerVisibility(layerId: string, visible: boolean): void;
+    setLayerOpacity(layerId: string, opacity: number): void;
+    setLayerZIndex(layerId: string, zIndex: number): void;
+    /** Feature state (hover / selected) */
+    setFeatureState(layerId: string, featureId: string | number, state: Record<string, any>): void;
+    getFeatureState(layerId: string, featureId: string | number): Record<string, any>;
+    /** Event listeners */
+    onMapClick(handler: (e: MapClickEvent) => void): () => void;
+    onMapDblClick(handler: (e: MapClickEvent) => void): () => void;
+    onContextMenu(handler: (e: MapClickEvent) => void): () => void;
+    onMouseMove(handler: (e: MapClickEvent) => void): () => void;
+    onMouseDown(handler: (e: MapClickEvent) => void): () => void;
+    onMouseUp(handler: (e: MapClickEvent) => void): () => void;
+    setDoubleClickZoom(enabled: boolean): void;
+    /** Raw map engine access */
+    getRawMap<T = any>(): T;
+    /** Cleanup */
+    destroy(): void;
+}
+
+export declare const IMPORT_EXTENSIONS: string[];
+
+export declare function importCsv(file: InputFile, options?: ImportOptions): ImportResult;
+
+export declare function importDxf(file: InputFile, options?: ImportOptions): ImportResult;
+
+export declare interface ImportedLayer {
+    name: string;
+    kind: ImportGeometryKind;
+    /** Features in WGS84 lng/lat */
+    features: Feature<Geometry, Record<string, any>>[];
+    fields: FieldDefinition[];
+    /** CRS the source coordinates were in */
+    sourceCrs: string;
+    sourceFile?: string;
+}
+
+/** Parse files into layers (no data source changes) */
+export declare function importFiles(files: InputFile[], options?: ImportOptions): ImportResult;
+
+export declare function importGeoJSON(file: InputFile, options?: ImportOptions): ImportResult;
+
+export declare type ImportGeometryKind = 'point' | 'line' | 'polygon';
+
+export declare function importGeoPackage(file: InputFile, options?: ImportOptions & {
+    wal?: InputFile['data'];
+}): ImportResult;
+
+export declare interface ImportIssue {
+    severity: 'error' | 'warning';
+    code: string;
+    message: string;
+    /** Source file name */
+    file?: string;
+    /** Index of the feature / record in the source file */
+    featureIndex?: number;
+}
+
+export declare function importKml(file: InputFile, options?: ImportOptions): ImportResult;
+
+export declare function importKmlText(text: string, fileName: string, options?: ImportOptions): ImportResult;
+
+export declare function importKmz(file: InputFile, options?: ImportOptions): ImportResult;
+
+export declare interface ImportOptions {
+    /** Source CRS when the file has none (CSV, DXF, GeoJSON without crs, shapefile without .prj) */
+    sourceCrs?: string;
+    /** Text encoding for DBF / CSV when it cannot be detected ('utf-8', 'windows-874' / 'tis-620', 'windows-1252') */
+    encoding?: string;
+    /** Close polygon rings that are not closed (reported as warnings). Default false: such features are rejected. */
+    closeRings?: boolean;
+    /** Curves (DXF arcs, bulges, circles): maximum angle per generated segment in degrees. Default 5. */
+    arcSegmentDegrees?: number;
+    /** CSV: column names holding coordinates or WKT (auto-detected when omitted) */
+    csv?: {
+        x?: string;
+        y?: string;
+        wkt?: string;
+        delimiter?: string;
+    };
+    /** DXF: import closed polylines as polygons (default true) */
+    dxfClosedAsPolygons?: boolean;
+}
+
+export declare interface ImportResult {
+    layers: ImportedLayer[];
+    issues: ImportIssue[];
+}
+
+export declare function importShapefileParts(parts: ShapefileParts, options?: ImportOptions): ImportResult;
+
+/** Import one or more shapefiles from a .zip, or from loose .shp/.dbf/.prj/.cpg files */
+export declare function importShapefiles(files: InputFile[], options?: ImportOptions): ImportResult;
+
+export declare interface ImportToDataSourceResult {
+    layers: AddedLayer[];
+    issues: ImportIssue[];
+}
+
+/**
+ * Indian 1975 -> WGS 84 three-parameter shift used by the project (Thailand):
+ * WGS 84 -> Indian 1975 is ΔX = -204.4798, ΔY = -837.8940, ΔZ = -294.7765 m, so the proj4 +towgs84
+ * (source datum -> WGS 84) values are the same numbers with the opposite sign. EPSG:1812 (204.64, 834.74,
+ * 293.8) differs by about 0.5 m. Override with setDatumShift('indian_1975', ...) if another survey uses other values.
+ */
+export declare const INDIAN_1975_TOWGS84 = "204.4798,837.894,294.7765,0,0,0,0";
+
+/** Field type that fits every value (text wins over everything, number over date/boolean mixes) */
+export declare function inferFieldType(values: unknown[]): FieldType;
+
+/** A file given to the importer: name + content */
+export declare interface InputFile {
+    name: string;
+    data: ArrayBuffer | Uint8Array | string;
+}
+
+export declare interface InputFrame {
+    convention: AngleConvention;
+    /** Counter-clockwise rotation of the UCS X axis from true East, in degrees */
+    ucsRotationDeg: number;
+}
+
+/** Point strictly usable as a label / zoom target inside a polygon (falls back to the first vertex) */
+export declare function interiorPoint(geometry: Polygon | MultiPolygon): Coordinate;
+
+/** Properties starting with this prefix belong to the library, not to the user's data */
+export declare const INTERNAL_PROPERTY_PREFIX = "_ofs_";
+
+export declare class InvalidCoordinateError extends OFSError {
+    constructor(raw: string);
+}
+
+export declare class InvalidGeometryError extends OFSError {
+    constructor(message?: string);
+}
+
+export declare type IOFormat = 'geojson' | 'shapefile' | 'gpkg' | 'kml' | 'kmz' | 'csv' | 'dxf';
+
+export declare interface IOFSConsole {
+    print(text: string, kind?: 'system' | 'input' | 'output' | 'prompt' | 'error' | 'success'): void;
+    clear(): void;
+    requestInput(promptText: string): Promise<string>;
+    /**
+     * Ask for a point: typed lng,lat / @dx,dy / @distance<angle / distance, or a map click when the
+     * console is connected to a point provider. `basePoint` enables relative input and a preview line.
+     * Resolves null when the user presses Enter without input.
+     */
+    requestPoint(promptText: string, options?: {
+        basePoint?: Coordinate | null;
+    }): Promise<Coordinate | null>;
+    /**
+     * Ask for either a map-picked point or free text (e.g. "angle or [Reference]").
+     * Optional: when missing, commands fall back to requestInput (text only).
+     */
+    requestPointOrText?(promptText: string, options?: {
+        basePoint?: Coordinate | null;
+    }): Promise<{
+        point: Coordinate;
+    } | {
+        text: string;
+    }>;
+    cancel(): void;
+    isWaitingInput(): boolean;
+}
+
+export declare function isDateText(value: string): boolean;
+
+/** True when `source` is inline SVG markup rather than a URL */
+export declare function isInlineSvg(source: string): boolean;
+
+export declare function isInternalProperty(name: string): boolean;
+
+export declare function isTruthy(value: ExpressionValue): boolean;
+
+/**
+ * Validates longitude and latitude ranges.
+ */
+export declare function isValidLngLat(lng: number, lat: number): boolean;
+
+/** Property that carries a pre-computed label text (expression labels) into the map source */
+export declare const LABEL_PROPERTY = "_ofs_label";
+
+export declare function labelIsActive(label: LabelSettings | undefined): boolean;
+
+/** True when the labels need text computed in the library (expression) instead of a plain field */
+export declare function labelNeedsComputedText(label: LabelSettings | undefined): boolean;
+
+/**
+ * Labels drawn from a field or an attribute expression (QGIS "Labels" tab).
+ * Text is placed by the map engine, which hides labels that would overlap unless `allowOverlap` is set.
+ */
+export declare interface LabelSettings {
+    /** Draw the labels (default true when a field or expression is given) */
+    enabled?: boolean;
+    /** Field whose value is the label */
+    field?: string;
+    /**
+     * Attribute expression (`lib/attributes/expression.ts`), e.g. `concat(owner, ' ', rai_ngan_wa())`.
+     * The text is computed per feature before it reaches the map, so geometry values ($area, $length) work.
+     */
+    expression?: string;
+    /** Decimals for a numeric field (display only) */
+    decimals?: number;
+    /** Font stack of the basemap style, e.g. ['Noto Sans Regular']; omitted = the style's default font */
+    font?: string[];
+    /** Text size in pixels (default 12) */
+    size?: number;
+    color?: string;
+    haloColor?: string;
+    haloWidth?: number;
+    opacity?: number;
+    /** Offset in ems (text size), [right, down] */
+    offset?: [number, number];
+    anchor?: MarkerAnchor;
+    /** Point placement (default) or along the line */
+    placement?: 'point' | 'line';
+    /** Draw even when labels overlap (default false: the engine drops colliding labels) */
+    allowOverlap?: boolean;
+    /** Line break width in ems (default 10) */
+    maxWidth?: number;
+    /** Rotation in degrees, clockwise */
+    rotationDeg?: number;
+    transform?: 'none' | 'uppercase' | 'lowercase';
+    /** Zoom range in which labels are drawn */
+    minZoom?: number;
+    maxZoom?: number;
+    /** Features with a higher priority keep their label when labels collide */
+    priorityField?: string;
+}
+
+/** Expression labels: the text is computed here and sent as a feature property */
+declare interface LabelSource {
+    source: string;
+    compiled: CompiledExpression | null;
+}
+
+export declare interface LandAreaMeasure {
+    areaSqm: number;
+    perimeterMeters: number;
+    rai: number;
+    ngan: number;
+    squareWa: number;
+    /** "3-2-45.5" (rai-ngan-square wa) */
+    raiNganWa: string;
+}
+
+export declare type LayerGeometryType = 'point' | 'line' | 'polygon' | 'circle' | 'symbol';
+
+/** Legend group of layers; groups can be nested */
+export declare interface LayerGroup {
+    id: string;
+    name: string;
+    parentId: string | null;
+    visible: boolean;
+    expanded: boolean;
+}
+
+declare interface LayerLike {
+    fields?: FieldSchema[];
+    getFeatures(): Feature<Geometry, any>[];
+}
+
+export declare interface LayerMetadata {
+    id: string;
+    name: string;
+    type: LayerGeometryType;
+    zIndex?: number;
+    visible?: boolean;
+    opacity?: number;
+    pinned?: boolean;
+    tag?: string;
+    /** Layer group (see OFSDataSource.addLayerGroup) */
+    groupId?: string;
+    /** CRS of the file the layer was imported from (data is always stored as WGS84) */
+    sourceCrs?: string;
+    sourceFile?: string;
+    /** Attribute schema in source order (kept for export; edited through OFSAttributeTools) */
+    fields?: FieldSchema[];
+    [key: string]: unknown;
+}
+
+export declare class LayerNotFoundError extends OFSError {
+    constructor(layerId: string);
+}
+
+export declare interface LegendEvents {
+    'legend:updated': {
+        snapshot: LegendSnapshot;
+    };
+}
+
+export declare interface LegendGroupViewModel {
+    id: string;
+    name: string;
+    parentId: string | null;
+    visible: boolean;
+    rendered: boolean;
+    expanded: boolean;
+}
+
+export declare interface LegendLayerViewModel {
+    id: string;
+    name: string;
+    type: LayerGeometryType;
+    visible: boolean;
+    /** Visible and all parent groups visible */
+    rendered: boolean;
+    opacity: number;
+    zIndex: number;
+    pinned: boolean;
+    groupId: string | null;
+    featureCount: number;
+    thematicType: ThematicType;
+    fieldName?: string;
+    classificationMethod?: ClassificationMethod;
+    graduatedMode?: GraduatedMode;
+    paletteName?: string;
+    items: LegendSwatchItem[];
+}
+
+export declare interface LegendSnapshot {
+    /** All layers, top-most first */
+    layers: LegendLayerViewModel[];
+    /** Layers and groups as a tree, top-most first */
+    tree: LegendTreeNode[];
+    groups: LegendGroupViewModel[];
+    activeLayerId: string | null;
+    totalLayers: number;
+}
+
+export declare interface LegendSwatchItem {
+    label: string;
+    color: string;
+    /** Features currently in this class (same rule the map renders with) */
+    count?: number;
+    min?: number;
+    max?: number;
+    value?: string | number | boolean;
+    /** Class index for setClassVisible / updateClass; -1 = "all other values" */
+    index: number;
+    visible: boolean;
+    /** Complete symbol of the class, for drawing the swatch */
+    symbol: SymbolStyle;
+}
+
+export declare type LegendTreeNode = {
+    kind: 'group';
+    group: LegendGroupViewModel;
+    children: LegendTreeNode[];
+} | {
+    kind: 'layer';
+    layer: LegendLayerViewModel;
+};
+
+export declare class LegendWidget {
+    private legendTools;
+    private container;
+    private unsubscriber;
+    private options;
+    constructor(legendTools: OFSLegendTools, options?: LegendWidgetOptions);
+    mount(target: HTMLElement | string): void;
+    unmount(): void;
+    private render;
+    private renderNode;
+    private renderLayer;
+    private handleClick;
+    private handleChange;
+    private handleDoubleClick;
+    private handleInput;
+}
+
+export declare interface LegendWidgetOptions {
+    /** Called when the layer "symbology" button is clicked (e.g. open OFSSymbologyPanel) */
+    onEditSymbology?: (layerId: string) => void;
+    /** Shows an "Import" button in the header (e.g. open a file picker / ofs.consoleWidget.submit('import')) */
+    onImport?: () => void;
+    /** Shows an export button per layer */
+    onExportLayer?: (layerId: string) => void;
+}
+
+export declare const LENGTH_UNITS: Record<string, number>;
+
+/** Ground length of a line part in m */
+export declare function lineLength(line: Position[], projection?: PlanarProjection): number;
+
+/** Line parts of a LineString / MultiLineString */
+export declare function linesOf(geometry: Geometry): Position[][];
+
+export declare interface LineSymbol {
+    color: string;
+    width: number;
+    opacity: number;
+    /** Dash pattern in pixels, e.g. [6, 3] (layer-wide) */
+    dash?: number[];
+    cap?: 'butt' | 'round' | 'square';
+    join?: 'bevel' | 'round' | 'miter';
+    /** Perpendicular offset in pixels, positive = right of the line direction */
+    offset?: number;
+}
+
+/** All registered ramps, optionally of one type */
+export declare function listColorRamps(type?: ColorRampType): ColorRampDefinition[];
+
+export declare function listCrs(): {
+    code: string;
+    name: string;
+}[];
+
+declare type Listener = (report: TopologyReport | null, layerId: string) => void;
+
+export declare function listExpressionFunctions(): {
+    name: string;
+    help: string;
+}[];
+
+export declare function listExpressionVariables(): string[];
+
+export declare function listMarkerIcons(): string[];
+
+export declare function localName(name: string): string;
+
+export declare type LocationPredicate = 'intersects' | 'within' | 'contains' | 'disjoint' | 'touches' | 'crosses' | 'within-distance';
+
+/** True when every coordinate is a plausible lng/lat */
+export declare function looksGeographic(bounds: [number, number, number, number]): boolean;
+
+export declare class MapboxAdapter extends BaseGLAdapter {
+    readonly engineName: "mapbox";
+    init(container: HTMLElement | string, options?: Record<string, any>): Promise<void>;
+}
+
+export declare interface MapClickEvent {
+    coordinate: Coordinate;
+    point: {
+        x: number;
+        y: number;
+    };
+    features: Array<{
+        id?: string | number;
+        layerId: string;
+        properties: Record<string, any>;
+        geometry: any;
+    }>;
+    originalEvent: MouseEvent;
+}
+
+export declare class MapEngineNotInitializedError extends OFSError {
+    constructor(message?: string);
+}
+
+export declare interface MapExportOptions {
+    /** Output width in pixels (default: the map's current width) */
+    width?: number;
+    height?: number;
+    title?: string;
+    /** Draw the scale bar (default true) */
+    scaleBar?: boolean;
+    /** Draw the north arrow (default true) */
+    northArrow?: boolean;
+    /** Text in the bottom right (basemap attribution) */
+    attribution?: string;
+    /** File name without extension */
+    name?: string;
+    /** image/png (default) or image/jpeg */
+    mimeType?: 'image/png' | 'image/jpeg';
+}
+
+export declare interface MapImage {
+    dataUrl: string;
+    width: number;
+    height: number;
+    filename: string;
+    scaleBar?: ScaleBarPlan;
+}
+
+export declare class MapLibreAdapter extends BaseGLAdapter {
+    readonly engineName: "maplibre";
+    init(container: HTMLElement | string, options?: Record<string, any>): Promise<void>;
+}
+
+export declare interface MapViewportOptions {
+    center?: Coordinate;
+    zoom?: number;
+    pitch?: number;
+    bearing?: number;
+    duration?: number;
+}
+
+export declare const MARKER_ICON_BUFFER_CSS = 8;
+
+export declare const MARKER_ICON_PIXEL_RATIO = 2;
+
+/** Marker icon images: shape diameter and transparent buffer in CSS pixels, rendered at 2x */
+export declare const MARKER_ICON_SHAPE_CSS = 24;
+
+export declare type MarkerAnchor = 'center' | 'left' | 'right' | 'top' | 'bottom' | 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+
+export declare interface MarkerIconDefinition {
+    /** Image URL or inline SVG markup */
+    source: string;
+    /**
+     * Recolorable (SDF) icon: the icon's alpha shape is drawn with the symbol color and stroke.
+     * Use false for multi-color images, which are drawn as-is.
+     */
+    sdf: boolean;
+}
+
+export declare function markerImageId(shape: MarkerShape, icon?: string): string;
+
+/** Built-in marker shapes (rendered as SDF icons, except a plain 'circle' layer) */
+export declare type MarkerShape = 'circle' | 'square' | 'diamond' | 'triangle' | 'star' | 'pentagon' | 'hexagon' | 'cross' | 'x' | 'icon';
+
+/** Unit polygon of a shape, or null for 'circle' / 'icon' */
+export declare function markerShapePolygon(shape: MarkerShape): UnitPoint[] | null;
+
+/** SVG path data of a shape scaled to `radius` around (cx, cy) */
+export declare function markerSvgPath(shape: MarkerShape, cx: number, cy: number, radius: number): string;
+
+export declare interface MarkerSymbol {
+    shape: MarkerShape;
+    /** Registered icon name when shape is 'icon' (see registerMarkerIcon) */
+    icon?: string;
+    /** Marker diameter in pixels */
+    size: number;
+    color: string;
+    opacity: number;
+    strokeColor: string;
+    strokeWidth: number;
+    /** Clockwise rotation in degrees */
+    rotationDeg?: number;
+    anchor?: MarkerAnchor;
+    /** Screen offset [x, y] in pixels (layer-wide) */
+    offset?: [number, number];
+    /** Draw markers even when they collide (layer-wide, icon markers only) */
+    allowOverlap?: boolean;
+}
+
+/** Distance (m) and user angle from `from` to `to` */
+export declare function measure(from: Coordinate, to: Coordinate, frame?: InputFrame): {
+    distance: number;
+    angle: number;
+};
+
+/** Angle at `vertex` between the two other points (0–180°), plus the direction and length of both legs */
+export declare function measureAngle(first: Coordinate, vertex: Coordinate, second: Coordinate, frame?: InputFrame): AngleMeasure;
+
+/** Area and perimeter of a ring (the ring is closed for the measurement only; the input is not changed) */
+export declare function measureArea(ring: Coordinate[]): LandAreaMeasure;
+
+/** Distance of each segment and the total length of a path */
+export declare function measureDistance(coords: Coordinate[], frame?: InputFrame): DistanceMeasure;
+
+/** Measure an existing feature: polygons give area + perimeter, lines give length, points give nothing */
+export declare function measureFeature(feature: Feature<Geometry, any>, frame?: InputFrame): {
+    area?: LandAreaMeasure;
+    length?: DistanceMeasure;
+};
+
+/** Ground area and perimeter of a Polygon / MultiPolygon on a local TM plane */
+export declare function measurePolygon(geometry: Polygon | MultiPolygon, projection?: PlanarProjection): AreaMeasure;
+
+/** Merge a partial symbol into a complete one (returns a new object) */
+export declare function mergeSymbolStyle(base: SymbolStyle, input?: SymbolStyleInput): SymbolStyle;
+
+/** Meters per degree of longitude and latitude at a latitude (WGS84 ellipsoid) */
+export declare function metersPerDegree(lat: number): [number, number];
+
+/** Web Mercator ground resolution at a latitude and zoom (meters per CSS pixel) */
+export declare function metersPerPixel(latitude: number, zoom: number, tileSize?: number): number;
+
+/**
+ * Get midpoint between two coordinates.
+ */
+export declare function midpoint(c1: Coordinate, c2: Coordinate): Coordinate;
+
+/** Shortest distance in meters between two features (0 when they intersect) */
+export declare function minDistanceMeters(a: Feature<Geometry, any>, b: Feature<Geometry, any>): number;
+
+/** Jenks optimisation is O(k·n²); larger inputs are classified on an evenly spaced sample of sorted values */
+export declare const NATURAL_BREAKS_MAX_SAMPLE = 3000;
+
+export declare interface NetworkLine {
+    /** `branch` is a run through points, `trunk` connects runs (or points) back towards the source */
+    role: 'branch' | 'trunk';
+    coordinates: Coordinate[];
+    lengthMeters: number;
+}
+
+export declare type NetworkMode = 'tree' | 'rows';
+
+export declare interface NetworkOptions {
+    mode?: NetworkMode;
+    /** rows: how far off a line a point may sit and still belong to it (default 1/4 of the row spacing found) */
+    toleranceMeters?: number;
+    /** rows: direction of the runs in degrees counter-clockwise from east; found from the points when absent */
+    angleDegrees?: number;
+    /** Refuse rather than connect more points than this (the tree is O(n²)) — default 5,000 */
+    maxPoints?: number;
+}
+
+export declare interface NetworkResult {
+    lines: NetworkLine[];
+    totalLengthMeters: number;
+    branchLengthMeters: number;
+    trunkLengthMeters: number;
+    /** rows: how many runs the points fell into */
+    runCount: number;
+    mode: NetworkMode;
+    angleDegrees: number | null;
+}
+
+export declare class NetworkTooLargeError extends OFSError {
+    constructor(count: number, max: number);
+}
+
+/**
+ * Notify the user if the target feature belongs to a layer different from the active layer.
+ */
+export declare function notifyTargetLayer(consoleService: IOFSConsole, targetLayerId: string, activeLayerId: string | null): void;
+
+export declare interface NumericFieldStats {
+    min: number;
+    max: number;
+    mean: number;
+    sum: number;
+    count: number;
+}
+
+/** Numeric values of a field (finite numbers only) */
+export declare function numericFieldValues(layer: OFSLayerData, fieldName: string): number[];
+
+declare interface ObjectTrackingSettings {
+    enabled: boolean;
+    /** Hover time on a snap point before it is acquired (or released) */
+    acquireDelayMs: number;
+    /** Cursor distance to a tracking line that activates it */
+    tolerancePixels: number;
+    /** Oldest acquired points are dropped beyond this count */
+    maxPoints: number;
+}
+
+/** Coordinate at `distance` meters from `base` in world math direction `rad` */
+export declare function offsetByPolar(base: Coordinate, distance: number, rad: number): Coordinate;
+
+export declare class OFSAiBridge {
+    private engine;
+    private dataSource;
+    private instructions;
+    constructor(engine: OFSCommandEngine, dataSource: OFSDataSource);
+    /**
+     * Add the host application's own instructions to the system prompt — what this particular project
+     * is for, its rules of thumb, the layers it expects. The library stays domain-free; the knowledge
+     * of what is being designed lives in the application.
+     *
+     * Pass null to remove them.
+     */
+    setInstructions(instructions: string | null): void;
+    getInstructions(): string | null;
+    /**
+     * Get function declarations (JSON schema) for AI tools
+     */
+    getToolDeclarations(): AiToolDeclaration[];
+    /**
+     * Get system prompt describing the map context
+     */
+    getSystemContextPrompt(): string;
+    private snapshot;
+    /**
+     * Execute an AI tool call with arguments and return structured feedback
+     */
+    executeToolCall(toolName: string, args?: Record<string, any>): Promise<AiExecutionFeedback>;
+}
+
+export declare class OFSAttributeTable {
+    private readonly dataSource;
+    private readonly attributes;
+    private readonly options;
+    private container;
+    private unsubscribers;
+    private layerId;
+    private filter;
+    private onlySelected;
+    private sortBy;
+    private sortDescending;
+    private page;
+    private editing;
+    private message;
+    private dialog;
+    constructor(dataSource: OFSDataSource, attributes: OFSAttributeTools, options?: AttributeTableOptions);
+    mount(target: HTMLElement | string): void;
+    unmount(): void;
+    /** Show a layer's table */
+    open(layerId: string): void;
+    getLayerId(): string | null;
+    private dataLayers;
+    private currentLayerId;
+    private render;
+    private renderHeader;
+    private renderRow;
+    private renderDialog;
+    private value;
+    private checked;
+    private run;
+    private handleChange;
+    private handleKeyDown;
+    private handleDoubleClick;
+    private handleClick;
+}
+
+export declare class OFSAttributeTools {
+    private readonly dataSource;
+    constructor(dataSource: OFSDataSource);
+    private layerOrThrow;
+    /** Stored schema plus fields that only exist in the data */
+    getSchema(layerId: string): FieldSchema[];
+    /** Replace the stored schema (undoable together with the values written in the same transaction) */
+    setSchema(layerId: string, fields: FieldSchema[]): void;
+    /** Change one field's settings (alias, default, allowed values, limits, read-only …) */
+    updateField(layerId: string, name: string, patch: Partial<Omit<FieldSchema, 'name'>> & {
+        name?: string;
+    }): FieldSchema;
+    /**
+     * Add a field to the schema and write its value to every feature (default value, or an expression).
+     */
+    addField(layerId: string, field: FieldSchema, options?: {
+        expression?: string;
+    }): CalculateResult;
+    deleteField(layerId: string, name: string): number;
+    renameField(layerId: string, from: string, to: string): number;
+    /** Properties for a new feature: the schema's default values */
+    defaultProperties(layerId: string): Record<string, unknown>;
+    query(layerId: string, query?: TableQuery): TableResult;
+    /** Write one value (checked against the field schema) */
+    setValue(layerId: string, featureId: string | number, field: string, value: unknown): ExpressionValue;
+    /** Write several values as one undo step; nothing is written when any value is refused */
+    setValues(layerId: string, edits: {
+        featureId: string | number;
+        field: string;
+        value: unknown;
+    }[]): ExpressionValue[];
+    private compile;
+    /** Parse an expression against a layer's fields without running it (for input validation) */
+    validateExpression(layerId: string, expression: string): {
+        ok: true;
+        fields: string[];
+    } | {
+        ok: false;
+        error: string;
+    };
+    /** Try an expression on one feature (preview in the UI) */
+    previewExpression(layerId: string, expression: string, featureId?: string | number): ExpressionValue;
+    /**
+     * Field calculator: write the expression's value into a field for every feature (or only the selected ones).
+     * By default nothing is written when a feature's value does not fit the field.
+     */
+    calculateField(layerId: string, fieldName: string, expression: string, options?: CalculateOptions): CalculateResult;
+    private applySelection;
+    /** Select features whose expression is true */
+    selectByExpression(layerId: string, expression: string, mode?: SelectionMode_2): (string | number)[];
+    /**
+     * Select features by their spatial relation to another layer (or to the selected features of that layer).
+     */
+    selectByLocation(layerId: string, predicate: LocationPredicate, referenceLayerId: string, options?: {
+        referenceFeatureIds?: (string | number)[];
+        onlySelectedReference?: boolean;
+        distanceMeters?: number;
+        mode?: SelectionMode_2;
+    }): (string | number)[];
+    private matchesPredicate;
+    /** Bounding box of the current selection (for zooming) */
+    selectionBBox(layerId: string): BoundingBox | null;
+    statistics(layerId: string, fieldName: string, options?: {
+        onlySelected?: boolean;
+    }): FieldStatistics;
+    /** Field names that exist in the data but not in the schema */
+    undeclaredFields(layerId: string): string[];
+}
+
+export declare class OFSCommandEngine extends TypedEventEmitter<CommandEngineEvents> {
+    readonly registry: OFSCommandRegistry;
+    private consoleService;
+    private currentAbortController;
+    private currentContext;
+    constructor(consoleService: IOFSConsole);
+    getContext(): OFSWorkflowContext | null;
+    /**
+     * Run a pipeline of commands in sequence
+     * @param commands Array of command strings e.g. ["draw_polygon", "buffer 5m"]
+     * @param initialData Optional input payload passed into context
+     */
+    run(commands: string[], initialData?: any): Promise<OFSWorkflowContext>;
+    /**
+     * Run more commands inside the workflow that is already running (used by macros): the current
+     * workflow is neither cancelled nor replaced, and the commands share its context.
+     */
+    runNested(commands: string[], context: OFSWorkflowContext): Promise<OFSWorkflowContext>;
+    /** The command loop shared by `run` and `runNested` */
+    private executeCommands;
+    /**
+     * Cancel currently running workflow
+     */
+    cancel(): void;
+    /**
+     * Parse command line string e.g. "buffer 10 meters" -> { cmdName: "buffer", args: "10 meters" }
+     */
+    parseCommandString(raw: string): {
+        cmdName: string;
+        args: string;
+    };
+}
+
+export declare interface OFSCommandProcess {
+    name: string;
+    aliases: string[];
+    description: string;
+    usage?: string;
+    isInteractive?: boolean;
+    schema?: {
+        type: 'object';
+        properties: Record<string, any>;
+        required?: string[];
+    };
+    /**
+     * How the schema's parameters appear on the command line. With this, the engine parses and checks the
+     * arguments once and the command reads them from `context.intermediate.get('_args')`.
+     */
+    args?: CommandArgSpec;
+    execute(context: OFSWorkflowContext, consoleService: IOFSConsole): Promise<OFSWorkflowContext>;
+}
+
+export declare class OFSCommandRegistry {
+    private commands;
+    private aliasMap;
+    register(cmd: OFSCommandProcess): void;
+    get(nameOrAlias: string): OFSCommandProcess | undefined;
+    getAll(): OFSCommandProcess[];
+    has(nameOrAlias: string): boolean;
+    /** Every command name (aliases included when `withAliases`) */
+    getNames(withAliases?: boolean): string[];
+    /** Command names and aliases starting with a prefix, for autocomplete */
+    suggest(prefix: string): string[];
+}
+
+export declare class OFSDataSource extends TypedEventEmitter<OFSDataSourceEvents> {
+    private layers;
+    private groups;
+    private activeLayerId;
+    private selectionStore;
+    readonly transactions: TransactionManager;
+    private pendingChangedLayers;
+    constructor();
+    /**
+     * Emit an event. While a transaction is running, 'features:changed' is coalesced
+     * and emitted once per layer when the outermost transaction finishes.
+     */
+    emit<K extends keyof OFSDataSourceEvents>(event: K, data: OFSDataSourceEvents[K]): void;
+    /**
+     * Run several edits as one atomic, undoable operation.
+     * - All undo steps recorded inside `fn` become a single undo/redo step named `description`.
+     * - If `fn` throws, every recorded change is reverted and the error is rethrown.
+     * - Map refresh events ('features:changed') are emitted once per layer at the end.
+     */
+    runTransaction<T>(description: string, fn: () => T): T;
+    private withCoalescedEvents;
+    /**
+     * Add a new layer with optional initial GeoJSON features
+     */
+    addLayer(metadata: LayerMetadata, initialFeatures?: Feature<Geometry, any>[]): OFSLayerData;
+    /**
+     * Remove a layer by ID
+     */
+    removeLayer(layerId: string): boolean;
+    /**
+     * Get layer by ID
+     */
+    getLayer(layerId: string): OFSLayerData | undefined;
+    /**
+     * Check if layer exists
+     */
+    hasLayer(layerId: string): boolean;
+    /**
+     * Get all layers sorted by zIndex ascending (higher zIndex renders on top)
+     */
+    getAllLayers(): OFSLayerData[];
+    /**
+     * Set layer visibility
+     */
+    setLayerVisibility(layerId: string, visible: boolean): void;
+    /**
+     * Set layer opacity (0.0 to 1.0)
+     */
+    setLayerOpacity(layerId: string, opacity: number): void;
+    /**
+     * Set layer z-index
+     */
+    setLayerZIndex(layerId: string, zIndex: number): void;
+    /**
+     * Reorder layers by ID order
+     */
+    reorderLayers(orderedLayerIds: string[]): void;
+    /**
+     * Pin / unpin a layer (pinned layers cannot be removed)
+     */
+    setLayerPinned(layerId: string, pinned: boolean): void;
+    addLayerGroup(group: {
+        id: string;
+        name?: string;
+        parentId?: string | null;
+        visible?: boolean;
+        expanded?: boolean;
+    }): LayerGroup;
+    getLayerGroup(groupId: string): LayerGroup | undefined;
+    getLayerGroups(): LayerGroup[];
+    /**
+     * Remove a group. Its layers and sub-groups move to the group's parent (nothing is deleted).
+     */
+    removeLayerGroup(groupId: string): void;
+    updateLayerGroup(groupId: string, patch: {
+        name?: string;
+        visible?: boolean;
+        expanded?: boolean;
+        parentId?: string | null;
+    }): void;
+    setLayerGroupVisibility(groupId: string, visible: boolean): void;
+    /** Move a layer into a group (null = top level) */
+    moveLayerToGroup(layerId: string, groupId: string | null): void;
+    /** True when the layer is inside the group, directly or through sub-groups */
+    isLayerInGroup(layerId: string, groupId: string): boolean;
+    /** A layer is drawn when it and all of its parent groups are visible */
+    isLayerRendered(layerId: string): boolean;
+    setActiveLayer(layerId: string | null): void;
+    getActiveLayerId(): string | null;
+    getActiveLayer(): OFSLayerData | null;
+    selectFeature(layerId: string, featureId: string | number, multi?: boolean): void;
+    deselectFeature(layerId: string, featureId: string | number): void;
+    /**
+     * Toggle selection state of a feature (if selected -> deselect, if not selected -> select)
+     * Returns true if feature is now selected, false if deselected.
+     */
+    toggleFeatureSelection(layerId: string, featureId: string | number): boolean;
+    /**
+     * Select multiple features in a layer at once
+     */
+    selectFeatures(layerId: string, featureIds: (string | number)[], multi?: boolean): void;
+    /**
+     * Get total count of currently selected features across all layers
+     */
+    getSelectedCount(): number;
+    clearSelection(layerId?: string): void;
+    deselectAll(layerId?: string): void;
+    getSelectedFeatureIds(layerId: string): (string | number)[];
+    getSelectedFeatures(layerId: string): Feature<Geometry, any>[];
+    /**
+     * Get any selected feature across layers, prioritizing the active layer.
+     */
+    getAnySelectedFeature(): {
+        layerId: string;
+        featureId: string | number;
+    } | null;
+    /**
+     * Get any selected features across layers, prioritizing the active layer.
+     */
+    getAnySelectedFeatures(): {
+        layerId: string;
+        featureIds: (string | number)[];
+    } | null;
+    addFeature(layerId: string, feature: Feature<Geometry, any>, recordUndo?: boolean): Feature<Geometry, any>;
+    addFeatures(layerId: string, features: Feature<Geometry, any>[], recordUndo?: boolean): Feature<Geometry, any>[];
+    updateFeature(layerId: string, feature: Feature<Geometry, any>, recordUndo?: boolean): boolean;
+    /**
+     * Change only the properties of a feature (a property given as `undefined` is removed).
+     *
+     * Unlike `updateFeature`, nothing copies the geometry: undo keeps just the previous values of the
+     * properties that changed. Editing one attribute of 98,000 parcels costs a few MB this way instead of
+     * a full copy of the layer (about 240 MB), which is what the field calculator and the attribute table use.
+     */
+    updateFeatureProperties(layerId: string, featureId: string | number, patch: Record<string, unknown>, recordUndo?: boolean): boolean;
+    /**
+     * Change the properties of many features as one undo step.
+     *
+     * The step keeps one list of the previous values, not one entry per feature, so a field calculated over
+     * a whole large layer stays cheap to undo.
+     * @returns how many features changed
+     */
+    updateFeaturePropertiesBatch(layerId: string, edits: {
+        featureId: string | number;
+        patch: Record<string, unknown>;
+    }[], recordUndo?: boolean, description?: string): number;
+    /** The values a patch is about to replace, or null when nothing would change */
+    private propertiesBefore;
+    removeFeature(layerId: string, featureId: string | number, recordUndo?: boolean): boolean;
+    /**
+     * Return `preferredId` if unused in the layer, otherwise a suffixed variant; without a preferred
+     * ID a random unique ID is generated.
+     */
+    getAvailableFeatureId(layerId: string, preferredId?: string | number): string | number;
+    getFeature(layerId: string, featureId: string | number): Feature<Geometry, any> | undefined;
+    /**
+     * Create buffer around feature and add as new feature or replace
+     */
+    buffer(layerId: string, featureId: string | number, distance: number, units?: turf.Units, targetLayerId?: string): Feature<Polygon | MultiPolygon>;
+    /**
+     * Calculate polygon area in square meters or hectares
+     */
+    calculateArea(layerId: string, featureId: string | number, unit?: 'sqm' | 'hectares' | 'rai'): number;
+    /**
+     * Calculate line length in meters or kilometers
+     */
+    calculateLength(layerId: string, featureId: string | number, units?: turf.Units): number;
+    /**
+     * Union multiple polygons in a layer into a single feature.
+     * Vertices of different polygons closer than `snapToleranceMeters` (default 1 mm) are first
+     * snapped together so shared boundaries dissolve cleanly. No buffering or simplification is
+     * applied: if the polygons are genuinely disjoint the result is a MultiPolygon.
+     */
+    union(layerId: string, featureIds: (string | number)[], options?: {
+        snapToleranceMeters?: number;
+    }): Feature<Polygon | MultiPolygon>;
+    /**
+     * Split two overlapping polygons into non-overlapping pieces:
+     * (A \ B, A ∩ B, B \ A)
+     */
+    splitOverlapping(layerId: string, featureIdA: string | number, featureIdB: string | number): {
+        pieceA: Feature<Polygon>[];
+        overlap: Feature<Polygon>[];
+        pieceB: Feature<Polygon>[];
+    } | null;
+    /**
+     * Subtract (difference) one polygon from another
+     */
+    difference(layerId: string, baseFeatureId: string | number, cutFeatureId: string | number): Feature<Polygon | MultiPolygon> | null;
+    /**
+     * Get BoundingBox across a layer or the entire data source
+     */
+    getBoundingBox(layerId?: string): BoundingBox;
+    undo(): string | null;
+    redo(): string | null;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    private getLayerOrThrow;
+    private getFeatureOrThrow;
+}
+
+export declare interface OFSDataSourceEvents {
+    'layer:added': {
+        layer: OFSLayerData;
+    };
+    'layer:removed': {
+        layerId: string;
+    };
+    'layer:updated': {
+        layer: OFSLayerData;
+    };
+    'feature:added': {
+        layerId: string;
+        feature: Feature<Geometry, any>;
+    };
+    'feature:updated': {
+        layerId: string;
+        feature: Feature<Geometry, any>;
+    };
+    'feature:removed': {
+        layerId: string;
+        featureId: string | number;
+    };
+    'features:changed': {
+        layerId: string;
+    };
+    'selection:changed': {
+        layerId: string;
+        featureIds: (string | number)[];
+    };
+    'active-layer:changed': {
+        layerId: string | null;
+    };
+    'group:added': {
+        group: LayerGroup;
+    };
+    'group:removed': {
+        groupId: string;
+    };
+    'group:updated': {
+        group: LayerGroup;
+    };
+    'transaction:undo': {
+        description: string;
+    };
+    'transaction:redo': {
+        description: string;
+    };
+}
+
+/**
+ * Internal diagnostics - a single channel for errors the library recovers from.
+ *
+ * Map style operations (moving layers, setting paint properties, feature state) can fail in
+ * normal situations, e.g. before a style has loaded. The library keeps working in those cases,
+ * but the error is reported here instead of being swallowed silently.
+ */
+export declare type OFSDiagnosticHandler = (scope: string, error: unknown) => void;
+
+export declare class OFSDrawTools extends TypedEventEmitter<DrawEvents> {
+    private dataSource;
+    private mapAdapter;
+    readonly snapping: SnappingEngine;
+    readonly grips: OFSGripsEditor;
+    readonly selectionOverlay: OFSSelectionOverlay;
+    orthoEnabled: boolean;
+    polarTracking: PolarTrackingSettings;
+    /** Angle convention and UCS used for typed angles, relative coordinates, ortho and polar tracking */
+    inputFrame: InputFrame;
+    private lastCursorCoord;
+    private lastConstraint;
+    /** Object snap tracking (AutoCAD OTRACK, F11) */
+    objectTracking: ObjectTrackingSettings;
+    private trackingPoints;
+    private trackingHover;
+    /** Clock used for tracking acquisition (replaceable in tests) */
+    now: () => number;
+    private pointPick;
+    private currentMode;
+    private activeCoordinates;
+    private targetLayerId;
+    private tempSourceId;
+    private unsubClick;
+    private unsubDblClick;
+    private unsubContextMenu;
+    private unsubMove;
+    private unsubMouseDown;
+    private unsubMouseUp;
+    private isDrawing;
+    private guides;
+    private dragSelectStart;
+    private isDragSelecting;
+    private justFinishedDrag;
+    private handleKeyDown;
+    constructor(dataSource: OFSDataSource, mapAdapter: IMapAdapter);
+    setOrtho(enabled: boolean): void;
+    toggleOrtho(): boolean;
+    /**
+     * Enable/disable polar tracking and optionally change its angle increment (AutoCAD F10)
+     */
+    setPolarTracking(settings: Partial<PolarTrackingSettings>): void;
+    togglePolarTracking(): boolean;
+    /**
+     * Rotate the drawing axes (UCS). `rotationDeg` is the counter-clockwise angle of the X axis
+     * from true East, e.g. align with a field edge so ORTHO and @dx,dy follow the field.
+     */
+    setUcsRotation(rotationDeg: number): void;
+    /**
+     * Choose how typed angles are interpreted: 'bearing' (0° = North, clockwise) or 'cad' (0° = East, counter-clockwise)
+     */
+    setAngleConvention(convention: AngleConvention): void;
+    /** Map adapter used by these tools */
+    getMapAdapter(): IMapAdapter;
+    /** Last known cursor position after snapping / tracking */
+    getCursorCoordinate(): Coordinate | null;
+    private isDrawModeActive;
+    /** Point that relative input and tracking are currently measured from */
+    getReferencePoint(): Coordinate | null;
+    /**
+     * Resolve a raw cursor position: object snaps win over ORTHO / polar tracking (AutoCAD behavior).
+     */
+    private resolveCursor;
+    /** Ground meters per screen pixel at a coordinate (1 m when the map cannot project) */
+    private metersPerPixel;
+    /** Enable/disable object snap tracking or change its settings (AutoCAD F11) */
+    setObjectTracking(settings: Partial<ObjectTrackingSettings>): void;
+    /** Points currently acquired for object snap tracking */
+    getTrackingPoints(): Coordinate[];
+    clearTrackingPoints(): void;
+    /**
+     * Acquire (or release) a snap point after hovering on it for `acquireDelayMs`.
+     */
+    private updateTrackingAcquisition;
+    /** In-progress vertices that the cursor may snap to (polygon start, previous line vertices) */
+    private getInProgressSnapCoords;
+    /**
+     * Feed command-line text to the active drawing (AutoCAD dynamic input).
+     * Supports @dx,dy / @distance<angle / distance (toward cursor) / lng,lat,
+     * empty text (finish), "u" (undo last vertex) and "c" (close polygon / line).
+     * Returns handled=false when no drawing is active or the text is not drawing input.
+     */
+    submitInput(text: string): DrawInputResult;
+    /**
+     * Remove the most recently placed vertex of the drawing in progress (AutoCAD "U" inside LINE).
+     */
+    undoLastVertex(): boolean;
+    /**
+     * Let the next map click provide a point (used by commands asking "Specify base point").
+     * Clicks are snapped and tracked relative to `basePoint`, and do not change the selection.
+     * Returns a function that cancels the pick.
+     */
+    beginPointPick(options: PointPickOptions, onPick: (coord: Coordinate) => void): () => void;
+    isPickingPoint(): boolean;
+    setupTempDrawingLayer(): void;
+    /**
+     * Dashed ORTHO / POLAR tracking ray layer (and keep it out of the regular rubber-band line layer)
+     */
+    private ensureTrackingLayer;
+    /**
+     * Dashed rays for the active ORTHO / POLAR / tracking lines, plus markers for acquired tracking points.
+     */
+    private trackingFeatures;
+    /**
+     * Ensure temporary drawing and snap guide layers stay top-most above all data layers
+     */
+    bringTempLayersToFront(): void;
+    private bindMapEvents;
+    /**
+     * Get the required geometry type for a given draw mode
+     */
+    getRequiredGeometryType(mode: DrawMode): LayerGeometryType;
+    /**
+     * Resolve or auto-detect a compatible target layer for the given mode
+     */
+    resolveTargetLayerId(mode: DrawMode, preferredLayerId?: string): string;
+    /**
+     * Current target layer id
+     */
+    getTargetLayerId(): string | null;
+    /**
+     * Set the active draw mode
+     */
+    setMode(mode: DrawMode, targetLayerId?: string): void;
+    getMode(): DrawMode;
+    /**
+     * Whether drawing is currently in progress
+     */
+    getIsDrawing(): boolean;
+    /**
+     * Current active vertices
+     */
+    getActiveCoordinates(): Coordinate[];
+    /**
+     * Handle mouse down on map (drag selection start)
+     */
+    private handleMouseDown;
+    /**
+     * Handle mouse up on map (drag selection complete)
+     */
+    private handleMouseUp;
+    /**
+     * Handle map click
+     */
+    private handleMapClick;
+    /**
+     * Place a vertex of the drawing in progress (from a click or typed input).
+     */
+    private commitDrawPoint;
+    /**
+     * Handle double click on map (finishes LineString or Polygon)
+     */
+    private handleMapDblClick;
+    /**
+     * Handle right-click / context menu on map (finishes if valid, else cancels)
+     */
+    private handleContextMenu;
+    /**
+     * Handle mouse move (rubberband preview)
+     */
+    private handleMouseMove;
+    private emitMeasure;
+    /** Rubber-band preview from the pick base point to the cursor */
+    private updatePickPreview;
+    /**
+     * Complete current drawing or geometry editing session
+     */
+    finishDrawing(): Feature<Geometry, any> | null;
+    /**
+     * Reset internal coordinate state and temporary rubberband
+     */
+    private resetDrawingState;
+    /**
+     * Cancel drawing or geometry editing session
+     */
+    cancel(): void;
+    drawPointByCoords(coord: Coordinate, targetLayerId?: string, props?: Record<string, any>): Feature<Point>;
+    drawLineByCoords(coords: Coordinate[], targetLayerId?: string, props?: Record<string, any>): Feature<LineString>;
+    drawPolygonByCoords(coords: Coordinate[], targetLayerId?: string, props?: Record<string, any>): Feature<Polygon>;
+    splitPolygon(layerId: string, polygonFeatureId: string | number, cuttingLineFeatureId?: string | number): Feature<Polygon>[] | null;
+    /**
+     * Split two overlapping polygons into non-overlapping pieces:
+     * (A \ B, A ∩ B, B \ A)
+     */
+    splitOverlappingPolygons(layerId: string, featureIdA: string | number, featureIdB: string | number): {
+        pieceA: Feature<Polygon>[];
+        overlap: Feature<Polygon>[];
+        pieceB: Feature<Polygon>[];
+    } | null;
+    /**
+     * Split a LineString by a point coordinate or cutter line (AutoCAD BREAK / SPLIT)
+     */
+    splitLine(layerId: string, lineFeatureId: string | number, splitter: Feature<Point | LineString> | Coordinate | string | number): Feature<LineString>[] | null;
+    /**
+     * Connect / Join two lines, strictly preserving the direction of the first line
+     */
+    joinLines(layerId: string, lineId1: string | number, lineId2: string | number, toleranceMeters?: number): Feature<LineString> | null;
+    offsetFeature(layerId: string, featureId: string | number, distanceMeters: number, copy?: boolean): Feature<LineString | Polygon | MultiPolygon> | null;
+    rotateFeature(layerId: string, featureId: string | number, angleDegrees: number, pivot?: Coordinate): Feature<Geometry> | null;
+    scaleFeature(layerId: string, featureId: string | number, factor: number, origin?: Coordinate): Feature<Geometry> | null;
+    explodeFeature(layerId: string, featureId: string | number): Feature<LineString>[] | null;
+    filletFeature(layerId: string, featureId: string | number, vertexIndex: number, radiusMeters?: number): Feature<Polygon | LineString> | null;
+    /**
+     * Start interactive Grips editing on a feature
+     */
+    startEdit(layerId: string, featureId: string | number): boolean;
+    /**
+     * Stop interactive Grips editing
+     */
+    stopEdit(): void;
+    /**
+     * Check if geometry editing is currently active
+     */
+    isEditing(): boolean;
+    /**
+     * Get the active feature currently being edited
+     */
+    getActiveEditingFeature(): Feature<Geometry, any> | null;
+    /**
+     * Get the layer ID of the feature currently being edited
+     */
+    getActiveEditingLayerId(): string | null;
+    /**
+     * Get the feature ID of the feature currently being edited
+     */
+    getActiveEditingFeatureId(): string | number | null;
+    /**
+     * Replace or update the entire geometry of a feature
+     */
+    updateGeometry(layerId: string, featureId: string | number, geometry: Geometry): boolean;
+    /**
+     * Move / Translate a feature by distance and bearing (AutoCAD MOVE)
+     */
+    moveFeature(layerId: string, featureId: string | number, distanceMeters: number, bearingDegrees: number): Feature<Geometry> | null;
+    /**
+     * Move / Translate a feature by delta coordinates (dx, dy)
+     */
+    moveFeatureByOffset(layerId: string, featureId: string | number, dxLng: number, dyLat: number): Feature<Geometry> | null;
+    /**
+     * Copy a feature to an offset position (AutoCAD COPY)
+     */
+    copyFeature(layerId: string, featureId: string | number, dxLng: number, dyLat: number): Feature<Geometry> | null;
+    /**
+     * Copy a feature by a distance in meters along a bearing (AutoCAD COPY with polar offset)
+     */
+    copyFeatureByDistance(layerId: string, featureId: string | number, distanceMeters: number, bearingDegrees: number): Feature<Geometry> | null;
+    /**
+     * Apply a geometry transform to several features as one undoable step.
+     * With `copy`, transformed copies are added and the originals stay unchanged.
+     * Returns the resulting features (updated originals or new copies).
+     */
+    transformFeatures(targets: {
+        layerId: string;
+        featureId: string | number;
+    }[], description: string, transform: (feature: Feature<Geometry, any>) => Feature<Geometry, any>, copy?: boolean): Feature<Geometry, any>[];
+    /**
+     * Find the LineString nearest to a map point within `tolerancePixels` (or 2 m without a map projection).
+     */
+    findLineAt(coord: Coordinate, tolerancePixels?: number): {
+        layerId: string;
+        feature: Feature<LineString, any>;
+        distance: number;
+    } | null;
+    /**
+     * Find the line or polygon under a map point. Lines and polygon edges within `tolerancePixels`
+     * win; otherwise a polygon containing the point is returned.
+     */
+    findFeatureAt(coord: Coordinate, options?: {
+        tolerancePixels?: number;
+        types?: ('LineString' | 'Polygon')[];
+    }): {
+        layerId: string;
+        feature: Feature<LineString | Polygon, any>;
+        distance: number;
+    } | null;
+    /**
+     * AutoCAD BREAK: remove the part of the picked line between two points (same point = split there).
+     */
+    breakLineAt(pick1: Coordinate, pick2: Coordinate): {
+        layerId: string;
+        featureId: string | number;
+        pieces: Feature<LineString>[];
+    } | null;
+    /**
+     * AutoCAD LENGTHEN: change the end of the picked line nearest `pick`.
+     * mode 'delta' adds meters (negative shortens), 'total' sets the total length, 'percent' scales the length.
+     * @throws Error with a user-facing message when the result is invalid
+     */
+    lengthenLineAt(pick: Coordinate, mode: 'delta' | 'total' | 'percent', value: number): Feature<LineString> | null;
+    /**
+     * AutoCAD OFFSET by picking: create a parallel copy of the picked line / polygon on the side of `sidePoint`.
+     * With distance 'through', the copy passes through `sidePoint`.
+     * @throws Error with a user-facing message when the offset is not possible
+     */
+    offsetAt(pick: Coordinate, sidePoint: Coordinate, distance: number | 'through'): {
+        layerId: string;
+        source: Feature<Geometry>;
+        result: Feature<Geometry>;
+    };
+    private replaceLineWithPieces;
+    private safeRawMap;
+    /** Segments of all visible features except `exclude` (used as cutting edges / boundaries) */
+    private boundarySegments;
+    /**
+     * AutoCAD TRIM (quick mode): remove the part of the line under `pick` between the nearest
+     * intersections with any other visible feature. Returns the remaining pieces, or null when no
+     * line is under the pick point or nothing intersects it.
+     */
+    trimLineAt(pick: Coordinate): {
+        layerId: string;
+        featureId: string | number;
+        pieces: Feature<LineString>[];
+    } | null;
+    /**
+     * AutoCAD EXTEND: extend the end of the line nearest `pick` to the nearest visible boundary.
+     */
+    extendLineAt(pick: Coordinate): {
+        layerId: string;
+        feature: Feature<LineString>;
+    } | null;
+    /**
+     * AutoCAD FILLET between two picked lines (radius 0 = sharp corner). Both lines are trimmed or
+     * extended; for radius > 0 an arc line is added to the first line's layer.
+     * @throws Error with a user-facing message when the fillet is not possible
+     */
+    filletLinesAt(pick1: Coordinate, pick2: Coordinate, radiusMeters: number): {
+        lines: Feature<LineString>[];
+        arc: Feature<LineString> | null;
+    };
+    /**
+     * AutoCAD STRETCH: move vertices inside the window (two opposite corners) by base -> second point.
+     * Applies to the given targets, or to every visible feature crossing the window when omitted.
+     * Returns the changed features and the number of moved vertices.
+     */
+    stretch(corner1: Coordinate, corner2: Coordinate, from: Coordinate, to: Coordinate, targets?: {
+        layerId: string;
+        featureId: string | number;
+    }[]): {
+        features: Feature<Geometry, any>[];
+        movedVertices: number;
+    };
+    /**
+     * Delete a feature from a layer
+     */
+    deleteFeature(layerId: string, featureId: string | number): boolean;
+    /**
+     * Update a specific vertex in a feature's geometry
+     */
+    updateVertex(layerId: string, featureId: string | number, index: number, coordinate: Coordinate, ringIndex?: number): boolean;
+    /**
+     * Insert a vertex into a feature's geometry
+     */
+    insertVertex(layerId: string, featureId: string | number, coordinate: Coordinate, index?: number, ringIndex?: number): boolean;
+    /**
+     * Delete a vertex from a feature's geometry
+     */
+    deleteVertex(layerId: string, featureId: string | number, vertexIndex: number, ringIndex?: number): boolean;
+    /**
+     * Simplify geometry using Douglas-Peucker algorithm
+     */
+    simplifyFeature(layerId: string, featureId: string | number, tolerance?: number): Feature<Geometry> | null;
+    /**
+     * Smooth a LineString feature with Bezier curve
+     */
+    smoothFeature(layerId: string, featureId: string | number, resolution?: number): Feature<Geometry> | null;
+    /**
+     * Reverse coordinate direction of a LineString feature
+     */
+    reverseLine(layerId: string, featureId: string | number): Feature<Geometry> | null;
+    /**
+     * Subtract a cutting feature from a target feature
+     */
+    differenceFeature(layerId: string, targetId: string | number, cutterId: string | number): Feature<Polygon | MultiPolygon> | null;
+    /**
+     * Calculate intersection between two polygons
+     */
+    intersectFeatures(layerId: string, idA: string | number, idB: string | number): Feature<Polygon | MultiPolygon> | null;
+    /**
+     * Pointer shape for what is happening now: answering a point prompt always wins (it can be asked for
+     * in any mode), then the active drawing mode, and nothing at all when no tool is running.
+     */
+    private applyCursor;
+    /** Current guide settings (a copy: change them through `setGuides`) */
+    getGuides(): DrawGuideSettings;
+    /**
+     * Turn drawing guides on or off. Only the keys given change, and the preview redraws at once so a
+     * toggle is visible without moving the mouse.
+     */
+    setGuides(settings: Partial<DrawGuideSettings>): DrawGuideSettings;
+    /** Dashed lines across the whole viewport through `anchor` */
+    private crosshairFeatures;
+    private formatLength;
+    /**
+     * Measurements written on the drawing: one label per segment at its midpoint, and the area of a
+     * polygon at its centre. Overlapping labels are dropped by the map's own text collision handling,
+     * so a dense outline thins out instead of turning into a smear.
+     */
+    /** Screen-space helper: the map, when it can convert between pixels and coordinates */
+    private projector;
+    /**
+     * A drawn dimension for one segment: two extension lines out from the ends and a dimension line
+     * between them, offset to the side, carrying the length. No arrowheads.
+     *
+     * The offset is measured in pixels, so the dimension keeps the same distance from the segment at
+     * every zoom. Without a projection (headless, or an adapter that cannot project) it falls back to
+     * a plain label at the midpoint.
+     */
+    private dimensionFeatures;
+    /**
+     * Arc and degrees at one corner. The turn from one leg to the other is normalised to (-180°, 180°],
+     * so the angle shown is always the one of 180 degrees or less and the arc is drawn on that side.
+     */
+    private angleFeatures;
+    private measurementFeatures;
+    private updateTempFeatures;
+    /**
+     * Render real-time preview of drag box marquee selection
+     */
+    private updateDragBoxPreview;
+    /**
+     * Query all features within or intersecting the given geometry across visible layers
+     */
+    queryFeaturesInGeometry(geom: Feature<Polygon>): Array<{
+        layerId: string;
+        feature: Feature<Geometry, any>;
+    }>;
+    /**
+     * Execute selection for draw-selection modes (box or polygon)
+     */
+    executeDrawSelection(mode: 'select-box' | 'select-polygon', selectionPolygon: Feature<Polygon>, multi?: boolean): void;
+    /**
+     * Visual flash highlight for features to confirm CAD operation execution
+     */
+    flashFeatures(features: Feature<Geometry, any> | Feature<Geometry, any>[], durationMs?: number): void;
+    private clearTempFeatures;
+    destroy(): void;
+}
+
+export declare class OFSDynamicInputWidget {
+    private drawTools;
+    private consoleWidget;
+    private container;
+    private root;
+    private promptEl;
+    private labelEl;
+    private inputEl;
+    private unsubscribers;
+    private keyHandler;
+    private state;
+    private lastCoordinate;
+    /** Pixel offset of the HUD from the cursor */
+    offset: {
+        x: number;
+        y: number;
+    };
+    constructor(drawTools: OFSDrawTools, consoleWidget: OFSWebConsoleWidget);
+    /**
+     * Attach the HUD to the map container (the element that holds the map canvas).
+     */
+    mount(target: HTMLElement | string): void;
+    unmount(): void;
+    private isActive;
+    private bindEvents;
+    private hideInput;
+    private render;
+}
+
+/**
+ * OFSObject Core Errors
+ */
+export declare class OFSError extends Error {
+    constructor(message: string);
+}
+
+export declare interface OFSFeatureMetadata {
+    createdAt?: number;
+    updatedAt?: number;
+    sourceLayer?: string;
+    [key: string]: unknown;
+}
+
+export declare class OFSFileIO {
+    private dataSource;
+    constructor(dataSource: OFSDataSource);
+    /** Parse and add files as new layers */
+    import(files: InputFile[], options?: ImportOptions): ImportToDataSourceResult;
+    /** Browser File objects (from <input type="file"> or drag & drop) */
+    importFileList(fileList: FileList | File[], options?: ImportOptions): Promise<ImportToDataSourceResult>;
+    /** Export one or more layers. Shapefile / KML / GeoJSON / CSV merge the layers; DXF keeps them as CAD layers. */
+    export(layerIds: string[], format: ExportFormat, options?: ExportOptions): {
+        file: ExportedFile;
+        issues: ImportIssue[];
+    };
+    /** Save an exported file in the browser */
+    static download(file: ExportedFile): void;
+}
+
+export declare class OFSGripsEditor extends TypedEventEmitter<GripsEditorEvents> {
+    private dataSource;
+    private mapAdapter;
+    private snapping;
+    private currentSnapResult;
+    private sourceId;
+    private activeFeatureId;
+    private activeLayerId;
+    private activeGrip;
+    private isDragging;
+    private dragHasMoved;
+    private isEnabled;
+    private activationTimestamp;
+    private initialFeatureSnapshot;
+    private unsubClick;
+    private unsubMouseDown;
+    private unsubMouseUp;
+    private unsubMove;
+    private unsubContextMenu;
+    private handleKeyDown;
+    constructor(dataSource: OFSDataSource, mapAdapter: IMapAdapter, snapping?: SnappingEngine);
+    setSnappingEngine(snapping: SnappingEngine | null): void;
+    getSnappingEngine(): SnappingEngine | null;
+    /**
+     * Start editing a feature's geometry with grips
+     */
+    editFeature(layerId: string, featureId: string | number): void;
+    /**
+     * Stop editing and clear grips
+     */
+    clear(): void;
+    getActiveFeature(): Feature<Geometry, any> | null;
+    getActiveLayerId(): string | null;
+    getActiveFeatureId(): string | number | null;
+    getIsEditing(): boolean;
+    hasHandleAt(coord: Coordinate, tolerancePx?: number): boolean;
+    /**
+     * Generate grip handles for the active feature
+     */
+    getHandles(): GripHandle[];
+    private setupLayers;
+    private renderGrips;
+    private clearSource;
+    private bindEvents;
+    private findNearestHandle;
+    private handleMouseDown;
+    private handleMouseUp;
+    private handleClick;
+    private handleContextMenu;
+    private handleMove;
+    private applyCoordinateChange;
+    private insertVertexAtMidpoint;
+    /**
+     * Delete selected vertex
+     */
+    deleteVertex(gripIndex: number, ringIndex?: number, partIndex?: number): boolean;
+    destroy(): void;
+}
+
+export declare class OFSLayerData {
+    readonly id: string;
+    name: string;
+    type: LayerGeometryType;
+    zIndex: number;
+    visible: boolean;
+    opacity: number;
+    pinned: boolean;
+    tag?: string;
+    groupId?: string;
+    sourceCrs?: string;
+    sourceFile?: string;
+    fields?: LayerMetadata['fields'];
+    private featuresMap;
+    private spatialIndex;
+    private indexItems;
+    private cachedFieldStats;
+    constructor(metadata: LayerMetadata, initialFeatures?: Feature<Geometry, any>[]);
+    /**
+     * Get all features as array
+     */
+    getFeatures(): Feature<Geometry, any>[];
+    /**
+     * Get feature count
+     */
+    get count(): number;
+    /**
+     * Resolve the stored map key for an ID. Accepts the exact ID or its numeric/string twin
+     * (e.g. 5 and "5"), which map engines and CLI input may produce. Never falls back to
+     * array position or attribute values, so a lookup can only ever return the intended feature.
+     */
+    private resolveKey;
+    /**
+     * Get single feature by ID
+     */
+    getFeature(id: string | number): Feature<Geometry, any> | undefined;
+    /**
+     * Check whether a feature ID (or its numeric/string twin) exists in this layer
+     */
+    hasFeature(id: string | number): boolean;
+    /**
+     * Return `preferredId` if it is free, otherwise the first free `${preferredId}_2`, `_3`, ...
+     * Without a preferred ID a random unique ID is generated.
+     */
+    getAvailableId(preferredId?: string | number): string | number;
+    /**
+     * Add a single feature (generates unique ID if missing).
+     * @throws DuplicateFeatureIdError if a feature with the same ID already exists
+     */
+    addFeature(feature: Feature<Geometry, any>): Feature<Geometry, any>;
+    /**
+     * Add multiple features
+     */
+    addFeatures(features: Feature<Geometry, any>[]): Feature<Geometry, any>[];
+    /**
+     * Update an existing feature
+     */
+    updateFeature(feature: Feature<Geometry, any>): boolean;
+    /**
+     * Change only the properties of a feature. The geometry object is kept as it is - no copy, no
+     * re-indexing - which is what makes editing an attribute of every feature in a large layer affordable.
+     * A property given as `undefined` is removed.
+     * @returns the stored feature, or null when there is no such feature
+     */
+    updateProperties(id: string | number, patch: Record<string, unknown>): Feature<Geometry, any> | null;
+    /**
+     * Remove a feature by ID
+     */
+    removeFeature(id: string | number): boolean;
+    /**
+     * Replace all features.
+     * Features sharing an ID are kept by giving later duplicates a suffixed ID (with a warning).
+     */
+    setFeatures(features: Feature<Geometry, any>[]): void;
+    /**
+     * Clear all features
+     */
+    clear(): void;
+    /**
+     * Export as GeoJSON FeatureCollection
+     */
+    toGeoJSON(): FeatureCollection<Geometry, any>;
+    /**
+     * Compute bounding box [minLng, minLat, maxLng, maxLat] from the spatial index (O(1))
+     */
+    getBoundingBox(): BoundingBox;
+    /**
+     * Features whose bounding boxes intersect the given bbox. This is a fast candidate filter;
+     * callers needing exact geometry tests should refine the result.
+     */
+    queryBBox(bbox: BoundingBox): Feature<Geometry, any>[];
+    /**
+     * Features whose bounding boxes lie within `radiusDegrees` of a coordinate (candidate filter).
+     */
+    queryNear(coord: Coordinate, radiusDegrees: number): Feature<Geometry, any>[];
+    private indexFeature;
+    private unindexFeature;
+    /**
+     * Get all property/attribute names across all features
+     */
+    getPropertyFields(): {
+        name: string;
+        type: 'number' | 'string' | 'boolean';
+    }[];
+    /**
+     * Get statistics for a numeric field (cached)
+     */
+    getNumericFieldStats(fieldName: string): NumericFieldStats | null;
+    /**
+     * Get statistics for a categorical field (cached)
+     */
+    getCategoricalFieldStats(fieldName: string): CategoricalFieldStats | null;
+    private invalidateCache;
+}
+
+export declare class OFSLegendTools extends TypedEventEmitter<LegendEvents> {
+    private dataSource;
+    private thematicEngine;
+    private unsubscribers;
+    private groupCounter;
+    constructor(dataSource: OFSDataSource, thematicEngine?: OFSThematicEngine);
+    private bindDataSourceEvents;
+    /**
+     * Get the current complete Legend Snapshot
+     */
+    getSnapshot(): LegendSnapshot;
+    private isGroupRendered;
+    private buildTree;
+    /**
+     * Notify subscribers of a state change
+     */
+    notifyUpdate(): void;
+    toggleLayerVisibility(layerId: string): void;
+    setLayerOpacity(layerId: string, opacity: number): void;
+    setActiveLayer(layerId: string): void;
+    toggleLayerPinned(layerId: string): void;
+    /** Move a layer one place up among its siblings in the legend tree (above a sibling group as a whole) */
+    moveLayerUp(layerId: string): void;
+    moveLayerDown(layerId: string): void;
+    moveGroupUp(groupId: string): void;
+    moveGroupDown(groupId: string): void;
+    private nodeLayers;
+    private findSiblings;
+    /** direction -1 = up (towards the top of the legend), 1 = down */
+    private moveNode;
+    addGroup(name: string, parentId?: string | null, id?: string): string;
+    removeGroup(groupId: string): void;
+    renameGroup(groupId: string, name: string): void;
+    toggleGroupVisibility(groupId: string): void;
+    toggleGroupExpanded(groupId: string): void;
+    /** Put a layer into a group (null = top level); it is placed on top of that group's layers */
+    moveLayerToGroup(layerId: string, groupId: string | null): void;
+    setThematicSimple(layerId: string, color: string): void;
+    setThematicCategorical(layerId: string, fieldName: string, palette?: PaletteName | string, options?: CategoricalThemeOptions): void;
+    setThematicGraduated(layerId: string, fieldName: string, method?: ClassificationMethod, classes?: number, palette?: PaletteName | string, options?: GraduatedThemeOptions): void;
+    /** Recompute classes from current data, keeping hidden classes and overrides */
+    reclassify(layerId: string): void;
+    updateBaseSymbol(layerId: string, patch: SymbolStyleInput): void;
+    /** Labels from a field or an attribute expression (null removes them) */
+    setLabel(layerId: string, settings: LabelSettings | null): void;
+    getLabel(layerId: string): LabelSettings | undefined;
+    /** Show / hide one class (index -1 = "all other values") */
+    setClassVisible(layerId: string, classIndex: number, visible: boolean): void;
+    toggleClassVisible(layerId: string, classIndex: number): void;
+    setAllClassesVisible(layerId: string, visible: boolean): void;
+    updateClass(layerId: string, classIndex: number, patch: ClassPatch): void;
+    getThematicEngine(): OFSThematicEngine;
+    getDataSource(): OFSDataSource;
+    destroy(): void;
+}
+
+export declare interface OFSMacro {
+    name: string;
+    commands: string[];
+    createdAt: number;
+    description?: string;
+}
+
+export declare class OFSMacroStore {
+    private readonly engine;
+    private macros;
+    private recording;
+    private unsubscribe;
+    constructor(engine: OFSCommandEngine);
+    private load;
+    private persist;
+    isRecording(): boolean;
+    recordingName(): string | null;
+    recordedCount(): number;
+    /** Start recording into `name` (an existing macro with that name is replaced when recording stops) */
+    startRecording(name: string): void;
+    /** Stop recording and keep the macro (empty recordings are discarded) */
+    stopRecording(): OFSMacro | null;
+    cancelRecording(): void;
+    list(): OFSMacro[];
+    get(name: string): OFSMacro | undefined;
+    save(macro: OFSMacro): OFSMacro;
+    remove(name: string): boolean;
+    export(): OFSMacro[];
+    import(macros: OFSMacro[], replace?: boolean): number;
+}
+
+/**
+ * OFSObject - Unified GIS Orchestrator
+ */
+export declare class OFSObject {
+    readonly dataSource: OFSDataSource;
+    readonly thematicEngine: OFSThematicEngine;
+    readonly mapAdapter: IMapAdapter;
+    readonly drawTools: OFSDrawTools;
+    readonly legendTools: OFSLegendTools;
+    /** The built-in console widget, or null when the host passed its own `config.console` */
+    readonly consoleWidget: OFSWebConsoleWidget | null;
+    /** Where commands print and ask for input: the built-in widget unless one was passed in */
+    readonly console: IOFSConsole;
+    readonly commandEngine: OFSCommandEngine;
+    readonly aiBridge: OFSAiBridge;
+    /** File import / export (GeoJSON, Shapefile, KML/KMZ, CSV, DXF) */
+    readonly io: OFSFileIO;
+    /** Topology checks (invalid geometry, overlaps, gaps, slivers, near-miss vertices) and fixes */
+    readonly topology: OFSTopologyTools;
+    /** Attribute schema, table, field calculator, select by attribute / location */
+    readonly attributes: OFSAttributeTools;
+    /** Recorded command macros (kept in localStorage in the browser) */
+    readonly macros: OFSMacroStore;
+    private dynamicInput;
+    /** Map handed over by the host application (config.map), attached on init() */
+    private readonly hostMap;
+    constructor(config?: OFSObjectConfig);
+    /**
+     * Initialize map adapter and bind data source.
+     *
+     * With `config.map` the host's map is attached instead and no container is needed; passing no
+     * container and no map binds the data source to an adapter the caller has already started.
+     */
+    init(container?: HTMLElement | string, options?: Record<string, any>): Promise<void>;
+    /**
+     * Show the AutoCAD-style dynamic input HUD next to the cursor (distance, angle, snap, prompt).
+     * While enabled, typing during drawing or point prompts goes to the HUD instead of the console.
+     * @param container Map container element; defaults to the map engine's container
+     */
+    enableDynamicInput(container?: HTMLElement | string): OFSDynamicInputWidget;
+    /** Remove the dynamic input HUD and send typing back to the command line */
+    disableDynamicInput(): void;
+    isDynamicInputEnabled(): boolean;
+    private registerDefaultCommands;
+    /**
+     * Clean up all resources
+     */
+    destroy(): void;
+}
+
+export declare interface OFSObjectConfig {
+    mapAdapter?: IMapAdapter;
+    container?: HTMLElement | string;
+    mapOptions?: Record<string, any>;
+    /**
+     * A MapLibre / Mapbox map the host application created and keeps owning (Angular, React, Vue).
+     * `init()` then attaches to it instead of creating one, and `destroy()` leaves it running.
+     * With a Mapbox map, pass `mapAdapter: new MapboxAdapter()` as well.
+     */
+    map?: unknown;
+    /**
+     * Replace the built-in command console with the host application's own (Angular, React, Vue).
+     * Commands and `aiBridge` then print and ask for input through it, and `consoleWidget` is null.
+     *
+     * Most applications do not need this: the built-in widget also works without `mount()` — drive it
+     * with `consoleWidget.submit(text)` and render the `console:line` / `console:prompt` events.
+     */
+    console?: IOFSConsole;
+}
+
+declare class OFSSelectionOverlay {
+    private dataSource;
+    private mapAdapter;
+    private selectionSourceId;
+    private hoverSourceId;
+    private flashSourceId;
+    private unsubSelection;
+    private currentHoveredFeatureId;
+    private flashTimer;
+    constructor(dataSource: OFSDataSource, mapAdapter: IMapAdapter);
+    /**
+     * Setup GeoJSON sources and MapLibre/Mapbox styling layers for selection and hover feedback
+     */
+    setupLayers(): void;
+    /**
+     * Keep selection and hover overlay layers top-most
+     */
+    bringToFront(): void;
+    /**
+     * Synchronize selection highlights from data source
+     */
+    syncSelectionOverlay(): void;
+    /**
+     * Preview selection highlights in real-time (e.g. while dragging marquee box)
+     */
+    previewSelection(features: Feature<Geometry, any>[]): void;
+    /**
+     * Set currently hovered feature highlight
+     */
+    setHoverFeature(feature: Feature<Geometry, any> | null): void;
+    /**
+     * Flash animation effect on features to confirm CAD operation success
+     */
+    flashFeatures(features: Feature<Geometry, any> | Feature<Geometry, any>[], durationMs?: number): void;
+    /**
+     * Cleanup
+     */
+    destroy(): void;
+}
+
+export declare class OFSSymbologyPanel {
+    private legendTools;
+    private container;
+    private layerId;
+    private unsubscribers;
+    private options;
+    /** Renderer settings chosen in the form but not yet applied with "Classify" */
+    private draft;
+    constructor(legendTools: OFSLegendTools, options?: SymbologyPanelOptions);
+    mount(target: HTMLElement | string): void;
+    unmount(): void;
+    /** Edit a layer's symbology */
+    open(layerId: string): void;
+    getLayerId(): string | null;
+    private get layer();
+    private get theme();
+    private render;
+    /** Labels tab: field or expression, size, colour, halo and zoom range */
+    private renderLabels;
+    private renderClassification;
+    private renderClassTable;
+    private dashSelect;
+    private renderSymbolEditor;
+    private classify;
+    private handleClick;
+    private handleChange;
+}
+
+export declare class OFSThematicEngine extends TypedEventEmitter<ThematicEvents> {
+    private themes;
+    constructor();
+    /**
+     * Get current theme definition for a layer
+     */
+    getTheme(layerId: string): ThematicDefinition | undefined;
+    /**
+     * Set explicit theme definition for a layer
+     */
+    setTheme(theme: ThematicDefinition): void;
+    removeTheme(layerId: string): void;
+    /** All themes as JSON-safe copies (for saving a project) */
+    exportThemes(): ThematicDefinition[];
+    /** Restore themes saved with exportThemes */
+    importThemes(themes: ThematicDefinition[]): void;
+    private carriedSymbol;
+    /**
+     * Create a simple uniform color theme
+     */
+    createSimpleTheme(layerId: string, style?: SimpleStyle, defaultColor?: string): ThematicDefinition;
+    /**
+     * Create a categorical / unique values theme based on an attribute field
+     */
+    createCategoricalTheme(layer: OFSLayerData, fieldName: string, palette?: PaletteName | string, defaultColor?: string, options?: CategoricalThemeOptions): ThematicDefinition;
+    /**
+     * Create a graduated / choropleth theme based on a numeric attribute field
+     */
+    createGraduatedTheme(layer: OFSLayerData, fieldName: string, method?: ClassificationMethod, numClasses?: number, palette?: PaletteName | string, defaultColor?: string, options?: GraduatedThemeOptions): ThematicDefinition;
+    /**
+     * Graduated theme with manual class upper bounds (the first class starts at `lower`, or the data minimum)
+     */
+    setManualBreaks(layer: OFSLayerData, uppers: number[], lower?: number): ThematicDefinition;
+    /**
+     * Recompute classes from the current data with the theme's own settings. Hidden classes and class
+     * symbol overrides are kept where the same category value / class position still exists.
+     */
+    reclassify(layer: OFSLayerData): ThematicDefinition | undefined;
+    private createCategoricalThemeData;
+    /**
+     * Merge changes into the base symbol (creates a simple theme when the layer has none)
+     */
+    updateBaseSymbol(layerId: string, patch: SymbolStyleInput): ThematicDefinition;
+    /**
+     * Set or change the labels of a layer (pass null to remove them). Creates a simple theme when the
+     * layer has none, so labels can be turned on without styling the layer first.
+     */
+    setLabel(layerId: string, settings: LabelSettings | null): ThematicDefinition;
+    getLabel(layerId: string): LabelSettings | undefined;
+    /**
+     * Show or hide one class (index -1 = "all other values")
+     */
+    setClassVisible(layerId: string, classIndex: number, visible: boolean): void;
+    setAllClassesVisible(layerId: string, visible: boolean): void;
+    /**
+     * Edit one class. Changing a graduated boundary also moves the touching boundary of the neighbour
+     * class so classes stay contiguous (as in QGIS), and regenerates labels unless one is given.
+     */
+    updateClass(layerId: string, classIndex: number, patch: ClassPatch): void;
+    private classList;
+    private requireTheme;
+    private defaultTheme;
+    /**
+     * Theme of a layer, creating the default simple theme silently (no event) when it has none
+     */
+    getEffectiveTheme(layerId: string): ThematicDefinition;
+    /**
+     * Compile layer's theme into GL style
+     */
+    compile(layer: OFSLayerData): CompiledLayerStyle;
+}
+
+export declare class OFSTopologyPanel {
+    private readonly dataSource;
+    private readonly topology;
+    private readonly panelOptions;
+    private container;
+    private unsubscribers;
+    private layerId;
+    private options;
+    private disabledChecks;
+    private busy;
+    /** Set while a check runs, so it can be stopped from the panel */
+    private running;
+    private progress;
+    private message;
+    private stale;
+    constructor(dataSource: OFSDataSource, topology: OFSTopologyTools, panelOptions?: TopologyPanelOptions);
+    mount(target: HTMLElement | string): void;
+    unmount(): void;
+    /** Select the layer shown in the panel */
+    open(layerId: string): void;
+    private dataLayers;
+    private currentLayerId;
+    private currentReport;
+    private render;
+    private renderReport;
+    private handleChange;
+    private handleClick;
+    private runCheck;
+    /** Fix one issue (number) or every fixable issue of one code (string) */
+    private runFix;
+    private ask;
+}
+
+export declare class OFSTopologyTools {
+    private readonly dataSource;
+    private readonly thematicEngine?;
+    private readonly reports;
+    private readonly listeners;
+    private issueLayersFor;
+    constructor(dataSource: OFSDataSource, thematicEngine?: OFSThematicEngine | undefined);
+    /** Called with the new report after every check / fix (null when a report is cleared) */
+    onChange(listener: Listener): () => void;
+    private emit;
+    /** Check a layer. Options are remembered and reused when the layer is re-checked after a fix. */
+    check(layerId: string, options?: TopologyOptions): TopologyReport;
+    /**
+     * The same check, but it lets the page breathe: `onProgress` follows the work and an aborted `signal`
+     * stops it. On a layer of 98,000 parcels the overlap and gap checks each take about a minute.
+     */
+    checkAsync(layerId: string, options?: TopologyOptions, control?: {
+        onProgress?: (progress: TopologyProgress) => void;
+        signal?: AbortSignal;
+    }): Promise<TopologyReport>;
+    private checkTarget;
+    private storeReport;
+    /** Re-run the last check of a layer with the same options */
+    recheck(layerId: string): TopologyReport;
+    /** Last report of a layer, or the most recent report of any layer */
+    getReport(layerId?: string): TopologyReport | undefined;
+    getIssue(issueId: number, layerId?: string): TopologyIssue | undefined;
+    clear(layerId?: string): void;
+    /** Bounding box to zoom to an issue (padded so points and tiny areas are visible) */
+    issueBBox(issue: TopologyIssue, paddingMeters?: number): BoundingBox;
+    /** Show the issues of a layer's last report as two layers (areas + locations) in a "Topology errors" group */
+    showIssues(layerId?: string): void;
+    hideIssues(): void;
+    isShowingIssues(): boolean;
+    /** Apply the automatic fix of one issue (one undo step), then re-check the layer */
+    fixIssue(issueId: number, options?: TopologyFixOptions, layerId?: string): TopologyFixResult;
+    /**
+     * Fix several issues in one undo step. Fixes use the current geometry, so later issues see earlier fixes;
+     * issues an earlier fix already resolved, and gaps whose neighbours changed, are `skipped` (re-check and run
+     * again). An issue whose fix is refused is reported in `failed`.
+     */
+    fixIssues(issueIds: number[], options?: TopologyFixOptions, layerId?: string): TopologyBatchResult;
+    private storedFor;
+    private resolveIssue;
+    /** Features must be as they were at check time, or as an earlier fix of the same batch left them */
+    private assertCurrent;
+    private applyFix;
+}
+
+export declare class OFSWebConsoleWidget extends TypedEventEmitter<ConsoleEventMap> implements IOFSConsole {
+    private container;
+    private lines;
+    private history;
+    private historyIndex;
+    private engine;
+    private pointProvider;
+    private inputInterceptor;
+    private typeToFocusHandler;
+    private typeToFocusCondition;
+    private waitingInput;
+    private currentPromptText;
+    private pendingResolve;
+    private pendingReject;
+    private outputEl;
+    private promptLabelEl;
+    private inputEl;
+    constructor();
+    /** The transcript so far, for a host UI that mounts after commands have already run */
+    getLines(): readonly ConsoleLine[];
+    setEngine(engine: OFSCommandEngine): void;
+    /** Allow point prompts to be answered by clicking the map */
+    setPointProvider(provider: ConsolePointProvider | null): void;
+    /** Route command-line text to another handler first (e.g. coordinate input while drawing) */
+    setInputInterceptor(interceptor: ConsoleInputInterceptor | null): void;
+    /**
+     * While `shouldCapture()` is true, typing anywhere on the page (outside other inputs) goes to the
+     * command line, like AutoCAD dynamic input.
+     */
+    enableTypeToFocus(shouldCapture: () => boolean): void;
+    private attachTypeToFocus;
+    disableTypeToFocus(): void;
+    private detachTypeToFocus;
+    mount(target: HTMLElement | string): void;
+    unmount(): void;
+    focus(): void;
+    setInput(text: string): void;
+    print(text: string, kind?: ConsoleLineKind): void;
+    clear(): void;
+    requestInput(promptText: string): Promise<string>;
+    requestPointOrText(promptText: string, options?: {
+        basePoint?: Coordinate | null;
+    }): Promise<{
+        point: Coordinate;
+    } | {
+        text: string;
+    }>;
+    requestPoint(promptText: string, options?: {
+        basePoint?: Coordinate | null;
+    }): Promise<Coordinate | null>;
+    cancel(): void;
+    /** Prompt text of the pending request, or null when no command is waiting for input */
+    getPromptText(): string | null;
+    isWaitingInput(): boolean;
+    /**
+     * Fulfill current pending request with string
+     */
+    fulfill(text: string): boolean;
+    private cancelPending;
+    private clearPending;
+    /**
+     * Submit command-line text exactly as if typed and Enter was pressed:
+     * answers a waiting prompt, else goes to the input interceptor (drawing input), else runs a command.
+     * Use from buttons or other input surfaces (e.g. the dynamic input HUD).
+     */
+    submit(text: string): void;
+    /** Cancel the running command (same as Escape in the command line) */
+    cancelCommand(): void;
+    private setupListeners;
+    /**
+     * Tab completion: command names on the first word, then the command's options (from its schema).
+     * A single match is filled in; several matches fill in their common prefix and are listed.
+     */
+    private handleTabAutocomplete;
+    /** Fill in a single match, or the common prefix of several, and list them */
+    private completeInto;
+    private renderLines;
+    private escapeHtml;
+}
+
+export declare interface OFSWorkflowContext {
+    jobId: string;
+    status: WorkflowStatus;
+    commands: string[];
+    currentIndex: number;
+    currentCommandName: string | null;
+    currentPrompt: string | null;
+    initialData: any;
+    payload: any;
+    intermediate: Map<string, any>;
+    history: CommandHistoryItem[];
+    abortSignal?: AbortSignal;
+}
+
+/** Notified when an icon is registered or replaced (map adapters refresh their images) */
+export declare function onMarkerIconRegistered(listener: (name: string) => void): () => void;
+
+declare type OptionMap = Map<string, OptionValue>;
+
+/** camelCase → kebab-case, the spelling used for command line options */
+export declare function optionName(property: string): string;
+
+/** Every option spelling a command accepts: its schema properties, its aliases and its switches */
+export declare function optionSpellings(command: OFSCommandProcess): string[];
+
+/** Style options as they appear on the command line; the values keep the type the schema gives them */
+declare type OptionValue = string | number | boolean | number[] | true;
+
+export declare class OrthoEngine {
+    /**
+     * Calculate orthogonal coordinate from anchor point to current cursor
+     */
+    static calculateOrtho(anchor: Coordinate, cursor: Coordinate, frame?: InputFrame): OrthoResult;
+}
+
+export declare interface OrthoResult {
+    coordinate: Coordinate;
+    distanceMeters: number;
+    bearingDegrees: number;
+    axis: 'horizontal' | 'vertical';
+}
+
+export declare interface OSnapModes {
+    /** Endpoint / vertex */
+    vertex: boolean;
+    /** Crossing point of two segments (different features or the same feature) */
+    intersection: boolean;
+    midpoint: boolean;
+    /** Center of circle features (drawn with the circle tool) */
+    center: boolean;
+    /** Foot of the perpendicular from the previous point onto a segment */
+    perpendicular: boolean;
+    /** Nearest point on an edge */
+    edge: boolean;
+}
+
+declare type Palette = PaletteName | string | string[];
+
+export declare type PaletteName = keyof typeof PALETTES;
+
+/** Legacy short palettes (kept for existing callers) */
+export declare const PALETTES: {
+    readonly viridis: readonly ["#440154", "#3b528b", "#21918c", "#5ec962", "#fde725"];
+    readonly magma: readonly ["#000004", "#51127c", "#b73779", "#fb8861", "#fcfdbf"];
+    readonly blues: readonly ["#eff3ff", "#bdd7e7", "#6baed6", "#3182bd", "#08519c"];
+    readonly greens: readonly ["#edf8e9", "#bae4b3", "#74c476", "#31a354", "#006d2c"];
+    readonly oranges: readonly ["#feedde", "#fdbe85", "#fd8d3c", "#e6550d", "#a63603"];
+    readonly purples: readonly ["#f2f0f7", "#cbc9e2", "#9e9ac8", "#756bb1", "#54278f"];
+    readonly ylgnbu: readonly ["#ffffd9", "#c7e9b4", "#41b6c4", "#225ea8", "#081d58"];
+    readonly ylorrd: readonly ["#ffffb2", "#fecc5c", "#fd8d3c", "#f03b20", "#bd0026"];
+    readonly spectral: readonly ["#d7191c", "#fdae61", "#ffffbf", "#abdda4", "#2b83ba"];
+    readonly rdylgn: readonly ["#d73027", "#fc8d59", "#fee08b", "#d9ef8b", "#91cf60", "#1a9850"];
+    readonly rdbu: readonly ["#ca0020", "#f4a582", "#f7f7f7", "#92c5de", "#0571b0"];
+    readonly category10: readonly ["#1f77b4", "#ff7f0e", "#2ca02c", "#d62728", "#9467bd", "#8c564b", "#e377c2", "#7f7f7f", "#bcbd22", "#17becf"];
+    readonly set1: readonly ["#e41a1c", "#377eb8", "#4daf4a", "#984ea3", "#ff7f00", "#ffff33", "#a65628", "#f781bf"];
+    readonly set2: readonly ["#66c2a5", "#fc8d62", "#8da0cb", "#e78ac3", "#a6d854", "#ffd92f", "#e5c494", "#b3b3b3"];
+    readonly pastel: readonly ["#fbb4ae", "#b3cde3", "#ccebc5", "#decbe4", "#fed9a6", "#ffffcc", "#e5d8bd", "#fddaec"];
+};
+
+/**
+ * Parse the raw argument text (or a JSON object) of a command into typed arguments.
+ * @throws ArgumentError when a value does not fit the schema
+ */
+export declare function parseCommandArgs(command: OFSCommandProcess, raw: string, options?: {
+    enforceRequired?: boolean;
+}): Record<string, unknown>;
+
+/**
+ * Parses JSON coordinate array string e.g. "[[100.5, 13.7], [100.6, 13.8]]"
+ */
+export declare function parseCoordinateArray(raw: string): Coordinate[] | null;
+
+/**
+ * Parse AutoCAD-style coordinate input.
+ * - `@dx,dy`     relative offset in meters along the UCS axes (X = UCS east, Y = UCS north)
+ * - `@dist<angle` relative polar: distance in meters at an angle in the frame's convention
+ * - `dist`       direct distance entry: distance in meters toward the cursor
+ * - `lng,lat` / `[lng,lat]` absolute geographic coordinate (longitude first, as in GeoJSON)
+ * Returns null when the text is not coordinate syntax (so it can be treated as a command).
+ */
+export declare function parseCoordinateInput(text: string, context?: CoordinateInputContext): CoordinateInputResult | null;
+
+/** Column definitions of a CREATE TABLE statement */
+export declare function parseCreateTable(sql: string): {
+    columns: SqliteColumn[];
+    withoutRowid: boolean;
+};
+
+export declare function parseCsv(text: string, delimiter?: string): string[][];
+
+/** GeoPackage binary geometry: header (magic, flags, srs id, envelope) + WKB */
+export declare function parseGpkgGeometry(blob: Uint8Array): Geometry | null;
+
+/**
+ * Parse a coordinate text as [lng, lat] — longitude first, the order GeoJSON uses.
+ * This is the only order the library reads: "13.7563, 100.5018" is not accepted as lat,lng, because
+ * guessing the order would silently move points whenever both numbers are below 90.
+ * Use `coordinateProblem()` for the message when this returns null.
+ */
+export declare function parseLngLat(raw: string): Coordinate | null;
+
+/** Parse a number, or null when the text is not a finite number */
+export declare function parseNumber(text: string): number | null;
+
+export declare function parseWkb(bytes: Uint8Array, offset?: number): {
+    geometry: Geometry;
+    end: number;
+};
+
+export declare function parseWkt(text: string): Geometry | null;
+
+export declare function parseXml(source: string): XmlElement;
+
+/** Boundary paths: polygon rings or line parts */
+export declare function pathsOf(geometry: Geometry): Position[][];
+
+export declare type PlanarPoint = [number, number];
+
+export declare class PlanarProjection {
+    /** proj4 definition of the planar CRS */
+    readonly definition: string;
+    private readonly converter;
+    private constructor();
+    /** UTM zone number (1-60) for a longitude */
+    static utmZoneFor(lng: number): number;
+    /**
+     * WGS84 / UTM plane (grid coordinates, scale factor 0.9996). Use for survey coordinates
+     * (e.g. EPSG:32647 / 32648 in Thailand), not for ground distances.
+     */
+    static utm(zone: number, south?: boolean): PlanarProjection;
+    /** Local ground-true plane centered near the given coordinate */
+    static forCoordinate(coord: Coordinate | number[]): PlanarProjection;
+    /** Local ground-true plane centered on a bounding box */
+    static forBBox(bbox: BoundingBox): PlanarProjection;
+    /** Local ground-true plane centered on the combined extent of one or more geometries */
+    static forGeometries(geometries: Geometry[]): PlanarProjection;
+    toPlanar(coord: Coordinate | number[]): PlanarPoint;
+    toGeographic(point: PlanarPoint | number[]): Coordinate;
+    projectGeometry<G extends Geometry>(geometry: G): G;
+    unprojectGeometry<G extends Geometry>(geometry: G): G;
+    /** Planar distance in meters between two lng/lat coordinates */
+    distance(a: Coordinate, b: Coordinate): number;
+}
+
+export declare function planHatchTile(pattern: HatchPattern, pixelRatio?: number): HatchTilePlan;
+
+/** Longest 1 / 2 / 5 × 10ⁿ distance that fits in `maxWidthPx` */
+export declare function planScaleBar(metersPerPx: number, maxWidthPx: number): ScaleBarPlan;
+
+/** Distance in meters between two nearby lng/lat points */
+export declare function pointDistance(a: Position, b: Position): number;
+
+export declare interface PointPickOptions {
+    /** Base point for relative input, tracking and the rubber-band preview */
+    basePoint?: Coordinate | null;
+}
+
+/** Distance in meters from a point to a lng/lat segment, with the closest point */
+export declare function pointSegmentDistance(p: Position, a: Position, b: Position, scale?: [number, number]): SegmentHit;
+
+export declare interface PolarTrackingSettings {
+    enabled: boolean;
+    /** Angle increment to track, e.g. 15, 30, 45, 90 */
+    incrementDeg: number;
+    /** Cursor must be within this many degrees of a tracking angle to lock on */
+    toleranceDeg: number;
+}
+
+/** Polygons of a Polygon / MultiPolygon as ring lists */
+export declare function polygonsOf(geometry: Geometry): Position[][][];
+
+export declare function printImportResult(consoleService: IOFSConsole, result: ImportToDataSourceResult): void;
+
+/** Print an import / export report: summary lines, then issues grouped by code */
+export declare function printIssues(consoleService: IOFSConsole, issues: ImportIssue[], limit?: number): void;
+
+export declare class PromptBuilder {
+    /**
+     * Summarize current map state for LLM prompt context.
+     * @param extraInstructions Instructions from the host application, appended after the library's own
+     */
+    static buildMapContext(dataSource: OFSDataSource, extraInstructions?: string): string;
+}
+
+declare interface RasterImage {
+    width: number;
+    height: number;
+    data: Uint8ClampedArray;
+    pixelRatio: number;
+    sdf: boolean;
+}
+
+export declare function rasterizeHatch(request: Extract<SymbolImageRequest, {
+    kind: 'hatch';
+}>, pixelRatio?: number): RasterImage | null;
+
+export declare function rasterizeIcon(name: string): Promise<RasterImage | null>;
+
+export declare function rasterizeMarker(request: Extract<SymbolImageRequest, {
+    kind: 'marker';
+}>): RasterImage | null;
+
+/**
+ * One coordinate from an argument, in the library's only order: [lng, lat].
+ * A value that is not a coordinate is refused with the right order spelled out — never turned around
+ * silently, because "13.7, 100.5" and "100.5, 13.7" are both plausible and one of them is a wrong place.
+ */
+export declare function readCoordinate(value: unknown): Coordinate;
+
+export declare function readDbf(buffer: Uint8Array, options?: {
+    encoding?: string;
+    cpg?: string;
+    file?: string;
+}, issues?: ImportIssue[]): DbfTable;
+
+export declare function readShp(buffer: Uint8Array, issues?: ImportIssue[], file?: string): {
+    shapeType: number;
+    records: ShpRecord[];
+};
+
+/** Register (or replace) a custom named ramp */
+export declare function registerColorRamp(definition: ColorRampDefinition): void;
+
+/** Register or replace a CRS (e.g. a project-specific datum shift) */
+export declare function registerCrs(code: string, definition: string, name?: string, aliases?: string[]): void;
+
+/** Register a custom marker icon usable as `{ shape: 'icon', icon: name }` */
+export declare function registerMarkerIcon(name: string, source: string, options?: {
+    sdf?: boolean;
+}): void;
+
+/** Remove consecutive vertices closer than `toleranceMeters` (keeps the first of each run and ring closure) */
+export declare function removeDuplicateVertices<G extends Geometry>(geometry: G, toleranceMeters: number): {
+    geometry: G;
+    removed: number;
+};
+
+/** Remove the area of `other` from `target` (target gives up the overlap) */
+export declare function removeOverlap(target: Polygon | MultiPolygon, other: Polygon | MultiPolygon): Polygon | MultiPolygon;
+
+/**
+ * SVG markup of a symbol swatch.
+ * @param size Swatch width and height in pixels
+ */
+export declare function renderSymbolSwatchSvg(symbol: SymbolStyle, geomType: LayerGeometryType, size?: number): string;
+
+/** Report an error that was caught and recovered from */
+export declare function reportInternalError(scope: string, error: unknown): void;
+
+/**
+ * Resolves all selected features across all layers in the dataset,
+ * prioritizing active layer features first, followed by other layers,
+ * and falling back to any currently active feature in the grips editor.
+ */
+export declare function resolveAllSelectedFeatures(dataSource: OFSDataSource, drawTools?: OFSDrawTools): SelectedFeatureRef[];
+
+/** Complete base symbol of a theme (defaults <- legacy simpleStyle <- baseSymbol) */
+export declare function resolveBaseSymbol(theme: ThematicDefinition): SymbolStyle;
+
+/**
+ * Resolve a CRS from an EPSG code ("EPSG:32647", "32647"), a URN, a registered name or a proj4 string.
+ */
+export declare function resolveCrs(input: string | number): ResolvedCrs;
+
+export declare interface ResolvedClass {
+    /** Class index, or -1 for "all other values" */
+    index: number;
+    label: string;
+    visible: boolean;
+    symbol: SymbolStyle;
+    min?: number;
+    max?: number;
+    value?: string | number | boolean;
+    count?: number;
+}
+
+export declare interface ResolvedCrs {
+    /** Canonical code, e.g. "EPSG:32647", or "CUSTOM" */
+    code: string;
+    name: string;
+    /** proj4 definition used for conversion */
+    definition: string;
+    isGeographic: boolean;
+    /** Warnings produced while resolving (e.g. default datum shift applied) */
+    warnings: string[];
+}
+
+export declare interface ResolvedMultiTargets {
+    layerId: string;
+    featureIds: (string | number)[];
+}
+
+export declare interface ResolvedTarget {
+    layerId: string;
+    featureId: string | number;
+}
+
+export declare type ResolvedTopologyOptions = Required<Omit<TopologyOptions, 'gapMaxAreaSqm' | 'minAreaSqm'>> & Pick<TopologyOptions, 'gapMaxAreaSqm' | 'minAreaSqm'>;
+
+/**
+ * Resolve the CRS of a .prj file (WKT). Known names map to registered CRSs; other WKT is converted by
+ * proj4. A non-WGS84 datum without TOWGS84 gets the registered shift for that datum, with a warning, or
+ * is rejected when no shift is known (coordinates would otherwise be off by hundreds of meters).
+ */
+export declare function resolvePrj(wkt: string): ResolvedCrs;
+
+/**
+ * Resolves the primary target feature for CAD / Spatial operations.
+ * Priority order:
+ * 1. Feature currently active in Grips Editor (drawTools.isEditing())
+ * 2. Feature selected in dataSource's activeLayerId
+ * 3. Feature selected in ANY layer across dataSource (activeLayerId remains unchanged)
+ */
+export declare function resolveTargetFeature(dataSource: OFSDataSource, drawTools?: OFSDrawTools): ResolvedTarget | null;
+
+/**
+ * Resolves multiple target features (e.g. for union, difference, intersect).
+ */
+export declare function resolveTargetFeatures(dataSource: OFSDataSource, drawTools?: OFSDrawTools): ResolvedMultiTargets | null;
+
+/**
+ * All classes of a theme with complete symbols, in legend order, plus the "other values" entry
+ * (index -1) when the theme draws unmatched features.
+ */
+export declare function resolveThemeClasses(theme: ThematicDefinition, geomType: LayerGeometryType): ResolvedClass[];
+
+export declare function resolveTopologyOptions(options?: TopologyOptions): ResolvedTopologyOptions;
+
+/**
+ * All selected features (across layers) as transform targets.
+ */
+export declare function resolveTransformTargets(dataSource: OFSDataSource, drawTools?: OFSDrawTools): {
+    layerId: string;
+    featureId: string | number;
+    feature: Feature<Geometry>;
+}[];
+
+/**
+ * Re-insert original vertices that an overlay dropped because they were collinear (e.g. T-junctions with a
+ * neighbour). Only vertices within `COLLINEAR_RESTORE_METERS` of a result edge are inserted, so the shape is unchanged.
+ */
+export declare function restoreCollinearVertices<G extends Polygon | MultiPolygon>(geometry: G, originals: Geometry[]): {
+    geometry: G;
+    restored: number;
+};
+
+/** Planar area of one ring in m² (absolute) */
+export declare function ringArea(ring: Position[], projection: PlanarProjection): number;
+
+/**
+ * A ring has no area when every vertex lies within `toleranceMeters` of the line through its two farthest-apart
+ * vertices (all on one line or at one point). The signed area is not used: a figure-eight ring has zero net area.
+ */
+export declare function ringIsCollapsed(ring: Position[], projection: PlanarProjection, toleranceMeters: number): boolean;
+
+/** Group shapefile rings into GeoJSON polygons */
+export declare function ringsToPolygons(rings: Position[][], index: number, issues: ImportIssue[], file?: string): Geometry | null;
+
+/**
+ * Run the checks step by step. Features are not modified.
+ *
+ * The work is handed back between chunks so a caller can show progress and stop: on a layer of 98,000
+ * parcels the overlap and gap checks take about a minute each, which must not freeze the page.
+ */
+export declare function runTopologyChecks(features: AnyFeature[], layer: {
+    id: string;
+    name?: string;
+}, options?: TopologyOptions): Generator<TopologyProgress, TopologyReport, void>;
+
+export declare interface ScaleBarPlan {
+    /** Ground distance the bar represents, in meters */
+    meters: number;
+    /** Bar length in pixels */
+    pixels: number;
+    /** "500 m" / "2 km" */
+    label: string;
+}
+
+export declare interface ScaleBarStyle {
+    color?: string;
+    background?: string;
+    fontSize?: number;
+    height?: number;
+}
+
+declare type Schema = NonNullable<OFSCommandProcess['schema']>;
+
+/** Property names of a schema, including none when the command has no schema */
+export declare function schemaProperties(schema: Schema | undefined): string[];
+
+export declare interface SegmentHit {
+    distance: number;
+    /** Parameter along the segment, 0..1 */
+    t: number;
+    /** Closest point, on the lng/lat segment */
+    point: Coordinate;
+}
+
+export declare interface SegmentMeasure {
+    from: Coordinate;
+    to: Coordinate;
+    meters: number;
+    /** Direction in the given convention (bearing: 0° = north, clockwise) */
+    angleDeg: number;
+}
+
+export declare interface SelectedFeatureRef {
+    layerId: string;
+    feature: Feature<Geometry>;
+}
+
+declare type SelectionMode_2 = 'new' | 'add' | 'remove' | 'intersect';
+export { SelectionMode_2 as SelectionMode }
+
+/** Override the default shift used for a datum (proj4 datum code, e.g. "indian_1975") */
+export declare function setDatumShift(datumCode: string, towgs84: string): void;
+
+/**
+ * Replace the diagnostic handler (e.g. to forward to an app logger or to fail tests).
+ * Pass null to restore the default console handler.
+ */
+export declare function setDiagnosticHandler(handler: OFSDiagnosticHandler | null): void;
+
+export declare interface ShapefileParts {
+    name: string;
+    shp: Uint8Array;
+    dbf?: Uint8Array;
+    prj?: string;
+    cpg?: string;
+}
+
+/** Length in meters of the part of `path` that runs along `boundary` (both segment ends within tolerance) */
+export declare function sharedBoundaryLength(path: Position[], boundary: Geometry, toleranceMeters: number): number;
+
+declare interface ShpRecord {
+    geometry: Geometry | null;
+    /** Shape type number for reporting */
+    type: number;
+}
+
+/** @deprecated Use `baseSymbol`. Kept for existing callers; mapped onto the base symbol. */
+export declare interface SimpleStyle {
+    fillColor?: string;
+    fillOpacity?: number;
+    strokeColor?: string;
+    strokeWidth?: number;
+    strokeOpacity?: number;
+    circleRadius?: number;
+    circleColor?: string;
+}
+
+/** Nearest integer direction (a, b) to a line angle (degrees CCW from horizontal) */
+export declare function snapHatchDirection(angleDeg: number, maxTileCssPx: number, spacing: number): {
+    a: number;
+    b: number;
+};
+
+export declare class SnappingEngine {
+    private dataSource;
+    private mapAdapter;
+    enabled: boolean;
+    tolerancePixels: number;
+    modes: OSnapModes;
+    constructor(dataSource: OFSDataSource, mapAdapter: IMapAdapter);
+    /**
+     * Set which OSnap modes are active
+     */
+    setModes(modes: Partial<OSnapModes>): void;
+    /**
+     * Toggle a specific snap mode
+     */
+    toggleMode(mode: keyof OSnapModes): boolean;
+    /**
+     * Find snap point for mouse coordinate
+     * @param cursorCoord Current cursor coordinate
+     * @param additionalCoords Optional extra coordinates to snap to (e.g. start vertex of in-progress polygon)
+     * @param options.excludeFeatureId Feature to ignore (e.g. the feature being edited)
+     * @param options.fromPoint Previous point, enables perpendicular snapping
+     */
+    getSnap(cursorCoord: Coordinate, additionalCoords?: Coordinate[], options?: {
+        excludeFeatureId?: string | number | null;
+        fromPoint?: Coordinate | null;
+    }): SnapResult | null;
+    /**
+     * Proper crossing point of two segments (shared endpoints are vertices, not intersections)
+     */
+    private static segmentIntersection;
+    /**
+     * Foot of the perpendicular from `from` onto segment a-b, measured with true angles
+     * (longitude scaled by cos(latitude)). Null if the foot falls outside the segment.
+     */
+    private static perpendicularFoot;
+    /**
+     * Geographic bbox covering the snap tolerance circle around the cursor.
+     * Uses all four screen corners so rotated / pitched maps are covered.
+     * Returns null if the map cannot unproject (then every feature is checked).
+     */
+    private getSearchBBox;
+}
+
+export declare interface SnapResult {
+    coordinate: Coordinate;
+    type: SnapType;
+    distanceMeters: number;
+    /** The segment the point was found on (perpendicular and edge snaps), for drawing the guide */
+    segment?: {
+        a: Coordinate;
+        b: Coordinate;
+    };
+}
+
+/**
+ * Snap a geometry onto a reference boundary (JTS GeometrySnapper approach):
+ * 1. vertices within `toleranceMeters` move to the nearest reference vertex, else onto the nearest reference edge;
+ * 2. reference vertices within tolerance of a segment are inserted into it, so the two boundaries follow the
+ *    same vertices where they run together.
+ * Vertices farther than the tolerance keep their exact coordinates.
+ */
+export declare function snapToReference<G extends Polygon | MultiPolygon | LineString | MultiLineString>(geometry: G, reference: Geometry, toleranceMeters: number, options?: {
+    insertVertices?: boolean;
+    endpointsOnly?: boolean;
+}): SnapToReferenceResult<G>;
+
+export declare interface SnapToReferenceResult<G extends Geometry> {
+    geometry: G;
+    movedVertices: number;
+    insertedVertices: number;
+    maxMoveMeters: number;
+}
+
+export declare type SnapType = 'vertex' | 'intersection' | 'midpoint' | 'center' | 'perpendicular' | 'edge';
+
+export declare class SpatialIndexHelper {
+    /**
+     * Features that intersect the query bbox
+     */
+    static queryBBox(source: FeatureSource, bbox: BoundingBox): Feature<Geometry, any>[];
+    /**
+     * Features that intersect an arbitrary polygon (R-tree prefilter, exact refinement)
+     */
+    static queryGeometry(source: FeatureSource, geometry: Feature<Polygon | MultiPolygon>): Feature<Geometry, any>[];
+    /**
+     * Find features that contain a given coordinate point
+     */
+    static queryPoint(source: FeatureSource, pointCoord: Coordinate): Feature<Geometry, any>[];
+    /**
+     * Find nearest feature to a point
+     */
+    static findNearest(source: FeatureSource, pointCoord: Coordinate): {
+        feature: Feature<Geometry, any>;
+        distanceMeters: number;
+    } | null;
+    /**
+     * turf.booleanIntersects throws on some degenerate geometries; treat those as a bbox hit so a
+     * malformed feature is still selectable (and therefore fixable) instead of disappearing.
+     */
+    private static intersectsSafely;
+}
+
+export declare interface SqliteColumn {
+    name: string;
+    declaredType: string;
+    /** INTEGER PRIMARY KEY column: its value is the rowid */
+    isRowidAlias: boolean;
+}
+
+export declare class SqliteReader {
+    private readonly pages;
+    readonly pageSize: number;
+    private readonly usable;
+    private readonly walPages;
+    readonly header: {
+        applicationId: number;
+        userVersion: number;
+        walMode: boolean;
+        textEncoding: number;
+    };
+    readonly warnings: string[];
+    constructor(file: Uint8Array, wal?: Uint8Array);
+    /** Apply frames of committed transactions from a -wal file */
+    private loadWal;
+    private page;
+    /** Visit every row of a table B-tree in rowid order */
+    scanTable(rootPage: number): Generator<{
+        rowid: number | bigint;
+        values: SqlValue[];
+    }>;
+    private payload;
+    tables(): SqliteTable[];
+    /** All rows of a table as objects (rowid alias columns filled in) */
+    rows(table: SqliteTable): Generator<Record<string, SqlValue>>;
+}
+
+export declare interface SqliteTable {
+    name: string;
+    rootPage: number;
+    sql: string;
+    columns: SqliteColumn[];
+}
+
+export declare class SqliteWriter {
+    readonly pageSize = 4096;
+    private pages;
+    private allocate;
+    private get usable();
+    /** Cell bytes for a table leaf, spilling to overflow pages when needed */
+    private tableLeafCell;
+    private indexLeafCell;
+    private localSize;
+    private cellWithOverflow;
+    private writePage;
+    private capacity;
+    /** Build a table B-tree into `rootPage` (already allocated) */
+    private buildTable;
+    private buildIndex;
+    /**
+     * Build a complete database file. `header` sets the application id and user version.
+     */
+    build(tables: WriterTable[], header: {
+        applicationId: number;
+        userVersion: number;
+    }): Uint8Array;
+}
+
+/**
+ * Minimal SQLite database file reader and writer (no SQL engine, no WASM).
+ *
+ * Reader: the file header, table B-trees (interior + leaf pages, overflow pages), record decoding, the
+ * schema table, rowid-alias columns, and committed frames of a -wal file. Index B-trees are not needed
+ * for full table scans and are skipped. WITHOUT ROWID tables are not supported.
+ *
+ * Writer: a new database with rowid tables and single-page indexes (enough for GeoPackage metadata
+ * constraints), in the documented file format (https://www.sqlite.org/fileformat2.html). Files are checked
+ * in the tests with SQLite itself (PRAGMA integrity_check) and GDAL.
+ */
+export declare type SqlValue = null | number | bigint | string | Uint8Array;
+
+export declare const SQM_PER_NGAN = 400;
+
+export declare const SQM_PER_RAI = 1600;
+
+export declare const SQM_PER_SQUARE_WA = 4;
+
+export declare interface StyleCompileOptions {
+    /** Data layer id used for GL layer ids (defaults to theme.layerId) */
+    layerId?: string;
+    /** Layer opacity multiplied into every opacity property */
+    opacity?: number;
+}
+
+export declare class StyleCompiler {
+    /**
+     * Compiles a ThematicDefinition into Mapbox/MapLibre GL layers
+     */
+    static compile(theme: ThematicDefinition, geomType: LayerGeometryType, options?: StyleCompileOptions): CompiledLayerStyle;
+}
+
+/** Closest candidate within a small edit distance, for "did you mean" messages */
+export declare function suggestName(input: string, candidates: string[]): string | null;
+
+/** The same numbers the other way round, when those would be a valid coordinate */
+export declare function swappedLngLat(raw: string): Coordinate | null;
+
+export declare class SymbolImageManager {
+    private readonly getMap;
+    /** Image ids used by each data layer */
+    private usage;
+    /** Every image request seen, for re-creation on 'styleimagemissing' */
+    private requests;
+    private loadingIcons;
+    private boundMap;
+    private missingHandler;
+    constructor(getMap: () => any);
+    private bind;
+    /** Make sure the images of a layer exist, and drop images no layer uses any more */
+    ensure(layerId: string, requests: SymbolImageRequest[]): void;
+    release(layerId: string): void;
+    /** Re-create an icon image after its registration changed */
+    refreshIcon(name: string): void;
+    private isUsed;
+    private removeUnused;
+    private put;
+    private addImage;
+    destroy(): void;
+}
+
+export declare type SymbolImageRequest = {
+    id: string;
+    kind: 'hatch';
+    pattern: HatchPattern;
+} | {
+    id: string;
+    kind: 'marker';
+    shape: MarkerShape;
+} | {
+    id: string;
+    kind: 'icon';
+    icon: string;
+};
+
+export declare interface SymbologyPanelOptions {
+    /** Called when the close button is pressed */
+    onClose?: () => void;
+}
+
+/** The single geometry-specific part of a symbol */
+export declare function symbolPart(style: SymbolStyle, geomType: LayerGeometryType): FillSymbol | LineSymbol | MarkerSymbol;
+
+/** Build a base-symbol patch from symbol options (unknown options are rejected) */
+export declare function symbolPatchFromOptions(options: OptionMap, current: FillSymbol): SymbolStyleInput;
+
+export declare interface SymbolStyle {
+    fill: FillSymbol;
+    line: LineSymbol;
+    marker: MarkerSymbol;
+}
+
+/** Deep-partial symbol used for editing and for base symbol input */
+export declare interface SymbolStyleInput {
+    fill?: Partial<FillSymbol>;
+    line?: Partial<LineSymbol>;
+    marker?: Partial<MarkerSymbol>;
+}
+
+export declare interface TableQuery {
+    /** Expression filter, e.g. `area > 1600 AND crop = 'ข้าว'` */
+    filter?: string;
+    onlySelected?: boolean;
+    sortBy?: string;
+    sortDescending?: boolean;
+    offset?: number;
+    limit?: number;
+}
+
+export declare interface TableResult {
+    layerId: string;
+    fields: FieldSchema[];
+    rows: AttributeRow[];
+    /** Features in the layer */
+    total: number;
+    /** Features left after filter / selection */
+    filtered: number;
+}
+
+/** Text content including descendants */
+export declare function textContent(el: XmlElement | undefined): string;
+
+export declare interface ThematicDefinition {
+    type: ThematicType;
+    layerId: string;
+    fieldName?: string;
+    classificationMethod?: ClassificationMethod;
+    classCount?: number;
+    paletteName?: string;
+    /** Color for features that match no class ("all other values") */
+    defaultColor: string;
+    breaks?: ClassBreak[];
+    categories?: CategoryItem[];
+    /** Base symbol; missing parts use the defaults for the layer geometry */
+    baseSymbol?: SymbolStyleInput;
+    /** @deprecated Use baseSymbol */
+    simpleStyle?: SimpleStyle;
+    /** Graduated: vary color (default) or size (line width / marker diameter) */
+    graduatedMode?: GraduatedMode;
+    /** Graduated size mode: [smallest, largest] size in pixels */
+    sizeRange?: [number, number];
+    /** Draw features that match no class with defaultColor (default true) */
+    showOther?: boolean;
+    /** Label of the "other values" legend row */
+    otherLabel?: string;
+    highlightColor?: string;
+    enableSelectionHighlight?: boolean;
+    /** Labels drawn for this layer */
+    label?: LabelSettings;
+}
+
+export declare interface ThematicEvents {
+    'theme:changed': {
+        layerId: string;
+        theme: ThematicDefinition;
+    };
+}
+
+/**
+ * Thematic Symbology Types
+ *
+ * A theme is plain JSON (serializable, AI-editable) modelled on QGIS renderers:
+ * - 'simple'      = Single Symbol
+ * - 'categorical' = Categorized (unique values)
+ * - 'graduated'   = Graduated (class breaks), by color or by size
+ *
+ * Every theme has a base symbol (fill / line / marker). Classes may override the data-driven parts of
+ * it (color, opacity, stroke, size, pattern, icon, rotation) and can be hidden individually.
+ * Units: sizes, widths, offsets and spacings are screen pixels; opacity is 0-1. Angles follow QGIS:
+ * hatch line angle counter-clockwise from horizontal (45 = "/"), marker rotation clockwise.
+ */
+export declare type ThematicType = 'simple' | 'categorical' | 'graduated';
+
+/** Split on whitespace, keeping "quoted text" together */
+export declare function tokenizeArgs(raw: string): string[];
+
+export declare const TOPOLOGY_AREA_LAYER_ID = "topology-errors-area";
+
+export declare const TOPOLOGY_GROUP_ID = "topology-errors";
+
+export declare const TOPOLOGY_POINT_LAYER_ID = "topology-errors-point";
+
+export declare interface TopologyBatchResult {
+    results: TopologyFixResult[];
+    /** Issues not fixed because an earlier fix in the batch already resolved them or changed a gap's neighbours */
+    skipped: {
+        issueId: number;
+        reason: string;
+    }[];
+    failed: {
+        issueId: number;
+        message: string;
+    }[];
+}
+
+/** Thrown by `checkTopologyAsync` when the caller aborts the check */
+export declare class TopologyCancelled extends OFSError {
+    constructor();
+}
+
+export declare type TopologyCheck = 
+/** OGC validity (self-intersection, holes outside shells, …), zero area / length, duplicate vertices */
+'validity'
+/** Polygons of the layer overlapping each other (area above tolerance) */
+| 'overlap'
+/** Enclosed empty areas between polygons (holes of the layer union bounded by 2+ features) */
+| 'gap'
+/** Polygons thinner than `sliverWidthMeters` or smaller than `minAreaSqm` */
+| 'sliver'
+/** Vertices close to another feature's boundary without touching it; line ends that stop short (undershoot) */
+| 'near-vertex'
+/** Point features at the same location */
+| 'duplicate-point';
+
+export declare type TopologyFixKind = 'remove-duplicate-vertices' | 'snap-vertices' | 'remove-overlap' | 'fill-gap' | 'snap-line-end';
+
+export declare interface TopologyFixOptions {
+    /** remove-overlap: feature that gives up the overlapping area (id), or 'smaller' / 'larger' */
+    removeFrom?: string | number | 'smaller' | 'larger';
+    /** fill-gap: feature that receives the gap (id), or 'longest-boundary' (default) / 'largest' */
+    mergeInto?: string | number | 'longest-boundary' | 'largest';
+    /** snap-vertices: feature whose vertices move (default: the first feature of the issue) */
+    moveFeatureId?: string | number;
+}
+
+export declare interface TopologyFixResult {
+    issueId: number;
+    code: TopologyIssueCode;
+    changedFeatureIds: (string | number)[];
+    message: string;
+    movedVertices?: number;
+    maxMoveMeters?: number;
+}
+
+export declare interface TopologyIssue {
+    /** Sequential number within the report (1-based) */
+    id: number;
+    check: TopologyCheck;
+    code: TopologyIssueCode;
+    severity: 'error' | 'warning';
+    layerId: string;
+    /** Features involved (first = the feature the issue is about, e.g. whose vertices are near) */
+    featureIds: (string | number)[];
+    message: string;
+    /** A representative location to zoom to (inside the problem area when it is an area) */
+    location: Coordinate;
+    /** Problem area / points: overlap or gap polygon, vertex or crossing points */
+    geometry?: Geometry;
+    areaSqm?: number;
+    /** Mean width of an area (2 × area / perimeter) */
+    widthMeters?: number;
+    distanceMeters?: number;
+    /** Number of vertices involved (near-vertex, duplicate-vertex) */
+    vertexCount?: number;
+    /** Automatic fix available (always applied on request only) */
+    fix?: TopologyFixKind;
+}
+
+export declare type TopologyIssueCode = 'self-intersection' | 'ring-self-intersection' | 'hole-outside-shell' | 'nested-holes' | 'disconnected-interior' | 'nested-shells' | 'duplicate-rings' | 'too-few-points' | 'invalid-coordinate' | 'ring-not-closed' | 'invalid-geometry' | 'zero-area' | 'zero-length' | 'duplicate-vertex' | 'line-self-intersection' | 'overlap' | 'duplicate-geometry' | 'gap' | 'sliver' | 'small-area' | 'near-vertex' | 'undershoot' | 'duplicate-point';
+
+export declare interface TopologyOptions {
+    /** Checks to run (default: all that apply to the layer geometry type) */
+    checks?: TopologyCheck[];
+    /**
+     * Points closer than this are the same point; vertices this close to a boundary touch it.
+     * Default 0.001 m (1 mm, the same as `union`).
+     */
+    vertexToleranceMeters?: number;
+    /** Overlaps and gaps with a smaller area are not reported (counted in `ignored`). Default 0.01 m² */
+    areaToleranceSqm?: number;
+    /** Gaps larger than this are treated as intentional open space (counted in `ignored`). Default: no limit */
+    gapMaxAreaSqm?: number;
+    /** Polygons whose mean width (2A/P) is below this are slivers. Default 0.2 m */
+    sliverWidthMeters?: number;
+    /** Polygons smaller than this are reported as `small-area`. Default: off */
+    minAreaSqm?: number;
+    /** Vertices / line ends within this distance of another feature (but not touching) are reported. Default 0.1 m */
+    nearToleranceMeters?: number;
+    /**
+     * How many polygons the gap check unions at once. The area is split into grid cells of about this many
+     * features, because one union of everything is far slower (2,000 parcels ≈ 0.7 s, 98,000 ≈ 10 minutes)
+     * and a failure would cost the whole check instead of one cell. Default 2000.
+     */
+    unionCellSize?: number;
+}
+
+export declare interface TopologyPanelOptions {
+    /** Called when an issue row is clicked: zoom the map and highlight the features */
+    onZoom?: (issue: TopologyIssue, report: TopologyReport) => void;
+    /** Called when the close button is pressed */
+    onClose?: () => void;
+    /** Ask the user to confirm a batch fix (default: window.confirm) */
+    confirmFix?: (issueCount: number, report: TopologyReport) => boolean;
+}
+
+/** Where a running check has got to, so a caller can show progress */
+export declare interface TopologyProgress {
+    stage: TopologyCheck;
+    done: number;
+    total: number;
+}
+
+export declare interface TopologyReport {
+    layerId: string;
+    layerName: string;
+    checkedAt: number;
+    durationMs: number;
+    options: ResolvedTopologyOptions;
+    featureCount: number;
+    issues: TopologyIssue[];
+    /** Issue count per code */
+    summary: Partial<Record<TopologyIssueCode, number>>;
+    /** Findings below / above the reporting thresholds, so nothing disappears silently */
+    ignored: {
+        overlapsBelowTolerance: number;
+        gapsBelowTolerance: number;
+        gapsAboveMaxArea: number;
+        /** Holes of the union bounded by a single feature (its own interior ring) */
+        ownHoles: number;
+    };
+    /** Features excluded from overlay checks (overlap / gap) because their geometry is invalid */
+    skippedFeatureIds: (string | number)[];
+    /** Checks that could not complete */
+    failures: {
+        check: TopologyCheck;
+        message: string;
+    }[];
+}
+
+/** Rai / ngan / square wa of an area in m² */
+export declare function toThaiUnits(areaSqm: number): {
+    rai: number;
+    ngan: number;
+    squareWa: number;
+    raiNganWa: string;
+};
+
+export declare function toWkt(g: Geometry, precision?: number): string;
+
+export declare class TransactionManager {
+    private undoStack;
+    private redoStack;
+    private maxHistory;
+    private groupStack;
+    constructor(maxHistory?: number);
+    record(step: TransactionStep): void;
+    /**
+     * Start grouping recorded steps into a single undoable step.
+     * Groups may be nested; nested groups merge into the outermost one.
+     */
+    beginGroup(description: string): void;
+    /**
+     * Close the current group and record it as one compound step (if it recorded anything).
+     */
+    commitGroup(): void;
+    /**
+     * Close the current group, reverting every step it recorded. Nothing is added to history.
+     */
+    rollbackGroup(): void;
+    isGrouping(): boolean;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    undo(): string | null;
+    redo(): string | null;
+    clear(): void;
+    getUndoDescriptions(): string[];
+    getRedoDescriptions(): string[];
+}
+
+/**
+ * Undo / Redo Transaction Stack for OFSDataSource
+ */
+export declare interface TransactionStep {
+    description: string;
+    undo: () => void;
+    redo: () => void;
+}
+
+/** Arguments the engine parsed from the command's `args` spec (empty when the command has none) */
+export declare function typedArgs(ctx: {
+    intermediate: Map<string, any>;
+}): Record<string, any>;
+
+/** Coordinates given as a typed `coordinates` argument, e.g. [[lng, lat], …] (null when none were given) */
+export declare function typedCoordinates(ctx: {
+    intermediate: Map<string, any>;
+}): Coordinate[] | null;
+
+export declare class TypedEventEmitter<EventMap extends Record<string, any>> {
+    private listeners;
+    /**
+     * Subscribe to an event. Returns an unsubscribe function.
+     */
+    on<K extends keyof EventMap>(event: K, handler: EventHandler<EventMap[K]>): () => void;
+    /**
+     * Subscribe to an event once.
+     */
+    once<K extends keyof EventMap>(event: K, handler: EventHandler<EventMap[K]>): () => void;
+    /**
+     * Remove an event listener.
+     */
+    off<K extends keyof EventMap>(event: K, handler: EventHandler<EventMap[K]>): void;
+    /**
+     * Emit an event with data.
+     */
+    emit<K extends keyof EventMap>(event: K, data: EventMap[K]): void;
+    /**
+     * Remove all listeners for an event or all events.
+     */
+    removeAllListeners(event?: keyof EventMap): void;
+    /**
+     * Return number of active listeners for an event.
+     */
+    listenerCount(event: keyof EventMap): number;
+}
+
+declare type UnitPoint = [number, number];
+
+/** Convert a user angle (in the frame's convention, relative to the UCS) to a world math angle (radians, CCW from East) */
+export declare function userAngleToWorldRad(angleDeg: number, frame: InputFrame): number;
+
+/**
+ * Signed user rotation (degrees) to a world math rotation (radians, CCW positive).
+ * Bearing convention treats positive rotation as clockwise, CAD as counter-clockwise.
+ */
+export declare function userRotationToWorldRad(rotationDeg: number, frame: InputFrame): number;
+
+/** UTM zone CRS (WGS 84) that contains a longitude, northern hemisphere codes for lat >= 0 */
+export declare function utmCrsFor(lng: number, lat: number): ResolvedCrs;
+
+/** Check an argument object against a schema; returns the coerced values or the problems found */
+export declare function validateArgs(schema: Schema | undefined, args: Record<string, unknown>, options?: {
+    enforceRequired?: boolean;
+}): {
+    ok: true;
+    value: Record<string, unknown>;
+} | {
+    ok: false;
+    issues: string[];
+};
+
+/** Field names that a new field must not collide with */
+export declare function validateFieldName(name: string, existing: FieldSchema[]): string | null;
+
+/**
+ * Validate one feature. Returns the (possibly ring-closed) geometry, or null when it must be rejected.
+ */
+export declare function validateGeometry(geometry: Geometry | null | undefined, index: number, issues: ImportIssue[], ctx?: ValidationContext): Geometry | null;
+
+export declare interface ValidationContext {
+    file?: string;
+    closeRings?: boolean;
+    /** Check lng/lat ranges (only after conversion to WGS84) */
+    geographic?: boolean;
+}
+
+export declare type WorkflowStatus = 'idle' | 'running' | 'waiting_input' | 'completed' | 'failed' | 'cancelled';
+
+/** Convert a world math angle (radians, CCW from East) to a user angle in the frame's convention [0, 360) */
+export declare function worldRadToUserAngle(rad: number, frame: InputFrame): number;
+
+export declare function writeDbf(records: Record<string, any>[], fields: FieldDefinition[], encoding?: string, issues?: ImportIssue[]): DbfWriteResult;
+
+export declare function writeGpkgGeometry(geometry: Geometry, srsId: number): Uint8Array;
+
+export declare interface WriterTable {
+    name: string;
+    sql: string;
+    /** Rows as column value arrays in declared column order; the rowid alias column must be null */
+    rows: {
+        rowid: number;
+        values: SqlValue[];
+    }[];
+    /** Automatic indexes for PRIMARY KEY / UNIQUE constraints, in declaration order: column positions */
+    autoIndexes?: number[][];
+}
+
+export declare function writeShapefile(features: Feature<Geometry, Record<string, any>>[], kind: 'point' | 'line' | 'polygon', fields: FieldDefinition[], options?: ExportOptions, issues?: ImportIssue[]): {
+    shp: Uint8Array;
+    shx: Uint8Array;
+    dbf: Uint8Array;
+    prj: string;
+    cpg: string;
+};
+
+export declare function writeWkb(geometry: Geometry): Uint8Array;
+
+/**
+ * Minimal XML reader/writer for KML (no DOM required, so it also runs in Node and workers).
+ * Supports elements, attributes, text, CDATA, comments, processing instructions and the standard +
+ * numeric character entities. Namespace prefixes are kept in names; use localName() to ignore them.
+ */
+export declare interface XmlElement {
+    name: string;
+    attributes: Record<string, string>;
+    children: XmlElement[];
+    text: string;
+}
+
+export { }