ofs-object 0.1.1 → 0.1.3

package/README.md

@@ -47,6 +47,38 @@ npm install mapbox-gl
 
 > MapLibre v6 เป็น ES module ล้วน (ไม่มี CommonJS) ถ้าจะใช้ `require()` ใน Node ต้องใช้ MapLibre v5 หรือใช้ Mapbox แทน — ผ่าน bundler (Angular, Vite, webpack) ใช้ได้ตามปกติ
 
+#### ⚠️ ต้องส่ง Map Engine เข้ามาเอง
+
+**ไลบรารีนี้ไม่ `import` map engine ตัวไหนเลย** — เพราะถ้า import ตัวใดตัวหนึ่งไว้ มันจะกลายเป็น
+dependency บังคับของทุกคน คนที่ใช้ Mapbox และไม่ได้ลง `maplibre-gl` จะ build ไม่ผ่านด้วย
+`Can't resolve 'maplibre-gl'` ตั้งแต่ยังไม่ได้รันโค้ด
+
+ดังนั้นตอนให้ `init()` สร้างแผนที่ ต้องส่ง library เข้ามาด้วย:
+
+```typescript
+// MapLibre v6 ไม่มี default export → ใช้ namespace import
+import * as maplibregl from 'maplibre-gl';
+
+const ofs = new OFSObject({ mapOptions: { maplibregl } });
+await ofs.init('map', { center: [100.5, 13.7], zoom: 12 });
+```
+
+```typescript
+// Mapbox
+import mapboxgl from 'mapbox-gl';
+
+const ofs = new OFSObject({
+  mapAdapter: new MapboxAdapter(),
+  mapOptions: { mapboxgl, accessToken: 'pk....' },
+});
+await ofs.init('map');
+```
+
+หรือโหลดจาก `<script>` tag ก็ได้ ไลบรารีจะอ่านจาก `window.maplibregl` / `window.mapboxgl` ให้เอง
+
+> **ถ้าแอปสร้าง Map เอง** (แนะนำสำหรับ Angular/React/Vue — ดูหัวข้อด้านล่าง) แล้วส่งเข้ามาทาง
+> `new OFSObject({ map })` **ไม่ต้องส่ง engine เลย** เพราะไลบรารีไม่ต้องสร้างแผนที่
+
 ### Stylesheet
 
 Widget ที่ไลบรารี mount ให้ (Command Console, Legend, แผง Symbology, ตาราง Attribute, แผง Topology) ต้องการไฟล์ CSS หนึ่งไฟล์:
@@ -95,12 +127,15 @@ npm install git+ssh://git@github.com/<user>/OnFarmObject.git#main
 
 ```typescript
 import { OFSObject, MapLibreAdapter, LegendWidget } from 'ofs-object';
+import * as maplibregl from 'maplibre-gl';
 import 'maplibre-gl/dist/maplibre-gl.css';
 
 async function initMap() {
   // 1. สร้าง Instance หลักของ OFSObject (ใช้ MapLibre เป็นค่าเริ่มต้น)
+  //    ต้องส่ง maplibregl เข้ามา เพราะไลบรารีไม่ import map engine เอง
   const ofs = new OFSObject({
     mapAdapter: new MapLibreAdapter(),
+    mapOptions: { maplibregl },
   });
 
   // 2. กำหนดแผนที่ลงบน HTML Container Element id="map"
@@ -259,8 +294,9 @@ initMap();
 
 <script type="module">
   import { OFSObject } from 'ofs-object';
+  import * as maplibregl from 'maplibre-gl';
 
-  const ofs = new OFSObject();
+  const ofs = new OFSObject({ mapOptions: { maplibregl } });
   await ofs.init('map');
   ofs.consoleWidget.mount('console-mount');
 </script>
@@ -273,6 +309,7 @@ initMap();
 ```tsx
 import React, { useEffect, useRef } from 'react';
 import { OFSObject, LegendWidget } from 'ofs-object';
+import * as maplibregl from 'maplibre-gl';
 import 'maplibre-gl/dist/maplibre-gl.css';
 
 export const MapView: React.FC = () => {
@@ -283,7 +320,7 @@ export const MapView: React.FC = () => {
   useEffect(() => {
     if (!mapContainerRef.current) return;
 
-    const ofs = new OFSObject();
+    const ofs = new OFSObject({ mapOptions: { maplibregl } });
     ofsRef.current = ofs;
 
     ofs.init(mapContainerRef.current, {
@@ -339,7 +376,7 @@ export class MapViewComponent implements OnInit, OnDestroy {
   private ofs!: OFSObject;
 
   async ngOnInit() {
-    this.ofs = new OFSObject();
+    this.ofs = new OFSObject({ mapOptions: { maplibregl } });
     await this.ofs.init(this.mapContainer.nativeElement, {
       center: [100.5, 13.7],
       zoom: 13,
@@ -455,6 +492,7 @@ const ofs = new OFSObject({ map, console: myAngularConsole });
 <script setup lang="ts">
 import { onMounted, onUnmounted, ref } from 'vue';
 import { OFSObject, LegendWidget } from 'ofs-object';
+import * as maplibregl from 'maplibre-gl';
 import 'maplibre-gl/dist/maplibre-gl.css';
 
 const mapContainer = ref<HTMLDivElement | null>(null);
@@ -464,7 +502,7 @@ let ofs: OFSObject | null = null;
 onMounted(async () => {
   if (!mapContainer.value) return;
 
-  ofs = new OFSObject();
+  ofs = new OFSObject({ mapOptions: { maplibregl } });
   await ofs.init(mapContainer.value, {
     center: [100.5, 13.7],
     zoom: 12,

package/dist/index.d.ts

@@ -272,6 +272,15 @@ export declare abstract class BaseGLAdapter implements IMapAdapter {
     protected whenStyleLoaded(map: any): Promise<void>;
     bindDataSource(dataSource: OFSDataSource, thematicEngine?: OFSThematicEngine): void;
     protected syncAllLayers(): void;
+    /**
+     * Put a raster or vector tile layer on the map, or bring an existing one up to date.
+     *
+     * Tile layers are registered in the same `glLayers` table as feature layers, so removal, stacking
+     * and the clean hand-back in `removeOwnLayers` treat both kinds alike without knowing which is
+     * which. What they do not share is the data path: there is no GeoJSON to send, so nothing here
+     * touches sources after the first creation except to rebuild when the styling changes.
+     */
+    syncTileLayer(layer: OFSTileLayer): void;
     syncLayer(layer: OFSLayerData): void;
     /** Reordering several layers emits one update per layer; restack once */
     private scheduleLayerOrder;
@@ -1478,6 +1487,12 @@ export declare function findIntersectingFeature(dataSource: OFSDataSource, targe
     feature: Feature<Geometry, any>;
 } | null;
 
+/**
+ * The engine to build a map with, or null when the caller has not supplied one.
+ * `options` wins over the global: passing a library explicitly should always be what gets used.
+ */
+export declare function findMapEngine(global: MapEngineGlobal, options?: Record<string, any>): any | null;
+
 export declare function forEachPosition(geometry: Geometry, fn: (c: Position) => void): void;
 
 /** Degrees as "45°30'20"" (bearing) or "45.5056°" */
@@ -2040,7 +2055,11 @@ export declare interface LegendGroupViewModel {
 export declare interface LegendLayerViewModel {
     id: string;
     name: string;
-    type: LayerGeometryType;
+    /**
+     * Geometry for a feature layer, or the tile kind for one served from a tile server. Tile layers
+     * carry no features and no symbology, so `items` is empty and `featureCount` is zero for them.
+     */
+    type: LayerGeometryType | 'raster' | 'vector';
     visible: boolean;
     /** Visible and all parent groups visible */
     rendered: boolean;
@@ -2156,6 +2175,33 @@ export declare function listExpressionVariables(): string[];
 
 export declare function listMarkerIcons(): string[];
 
+/**
+ * Read a project back onto the map.
+ *
+ * Layers go in before groups are wired up and before the themes are applied, so that a theme never
+ * arrives for a layer that is not there yet.
+ */
+export declare function loadProject(dataSource: OFSDataSource, thematicEngine: OFSThematicEngine, project: OFSProjectFile, options?: LoadProjectOptions): LoadProjectResult;
+
+export declare interface LoadProjectOptions {
+    /**
+     * Clear what is already loaded first (default). Turning this off merges the project in, which
+     * replaces any layer whose id it also defines.
+     */
+    replace?: boolean;
+}
+
+export declare interface LoadProjectResult {
+    layers: string[];
+    tileLayers: string[];
+    groups: number;
+    features: number;
+    themes: number;
+    view?: ProjectView;
+    /** Layers the file described but carried no data for */
+    emptyLayers: string[];
+}
+
 export declare function localName(name: string): string;
 
 export declare type LocationPredicate = 'intersects' | 'within' | 'contains' | 'disjoint' | 'touches' | 'crosses' | 'within-distance';
@@ -2171,6 +2217,12 @@ export declare function makeCurve(vertices: Coordinate[], bulges: number[], sagT
 
 export declare class MapboxAdapter extends BaseGLAdapter {
     readonly engineName: "mapbox";
+    /**
+     * Build a map in `container`.
+     *
+     * `mapbox-gl` is not imported by this package - see `resolve-engine.ts` - so pass the library in
+     * as `options.mapboxgl`, or load it from a script tag.
+     */
     init(container: HTMLElement | string, options?: Record<string, any>): Promise<void>;
 }
 
@@ -2189,6 +2241,22 @@ export declare interface MapClickEvent {
     originalEvent: MouseEvent;
 }
 
+/**
+ * Finding the map engine an adapter should build its map with.
+ *
+ * Neither `maplibre-gl` nor `mapbox-gl` is imported anywhere in this package, and that is
+ * deliberate. Both are optional peer dependencies, but a static `import` of one is a hard
+ * dependency for every consumer regardless of what they actually use: the import sits in the
+ * bundle, the bundler has to resolve it, and an application built on Mapbox that never installed
+ * `maplibre-gl` fails at build time with "Can't resolve 'maplibre-gl'" before a line of code runs.
+ * It failed even for applications that create their own map and hand it over with `attach()`, where
+ * the engine is never needed at all.
+ *
+ * So the engine is handed to the adapter rather than imported: through `options`, or from the global
+ * a CDN script tag leaves on `window`.
+ */
+export declare type MapEngineGlobal = 'maplibregl' | 'mapboxgl';
+
 export declare class MapEngineNotInitializedError extends OFSError {
     constructor(message?: string);
 }
@@ -2220,6 +2288,13 @@ export declare interface MapImage {
 
 export declare class MapLibreAdapter extends BaseGLAdapter {
     readonly engineName: "maplibre";
+    /**
+     * Build a map in `container`.
+     *
+     * `maplibre-gl` is not imported by this package - see `resolve-engine.ts` for why - so pass the
+     * library in as `options.maplibregl`, or load it from a script tag. An application that creates
+     * its own map does not come through here at all; it calls `attach()`.
+     */
     init(container: HTMLElement | string, options?: Record<string, any>): Promise<void>;
 }
 
@@ -2608,6 +2683,14 @@ export declare interface OfsCurveMeta {
 
 export declare class OFSDataSource extends TypedEventEmitter<OFSDataSourceEvents> {
     private layers;
+    /**
+     * Tile layers are kept apart from feature layers on purpose. Everything that reads
+     * `getAllLayers()` - snapping, topology, export, the attribute table, the AI context - wants
+     * features, and a tile layer has none to give. Mixing them into that list would mean auditing
+     * every one of those callers for a case that can only ever be "skip this". `getDisplayLayers()`
+     * brings the two back together for the things that do treat them alike: the legend and the stack.
+     */
+    private tileLayers;
     private groups;
     private activeLayerId;
     private selectionStore;
@@ -2648,7 +2731,36 @@ export declare class OFSDataSource extends TypedEventEmitter<OFSDataSourceEvents
      */
     getAllLayers(): OFSLayerData[];
     /**
-     * Set layer visibility
+     * Add a raster or vector tile layer.
+     *
+     * ```ts
+     * ds.addTileLayer({ id: 'ortho', name: 'Aerial', kind: 'raster',
+     *   tiles: ['https://tiles.example/{z}/{x}/{y}.png'], tileSize: 256, zIndex: -1 });
+     * ```
+     *
+     * A vector tile set also needs `styles`, naming which layer inside the tile to draw and how; a
+     * vector tile carries no styling of its own, so there is nothing to fall back on.
+     */
+    addTileLayer(metadata: TileLayerMetadata): OFSTileLayer;
+    getTileLayer(layerId: string): OFSTileLayer | undefined;
+    /** Tile layers, lowest in the stack first */
+    getTileLayers(): OFSTileLayer[];
+    removeTileLayer(layerId: string): boolean;
+    /** Replace the drawing instructions of a vector tile layer */
+    setTileLayerStyles(layerId: string, styles: OFSTileLayer['styles']): void;
+    /**
+     * Every layer that appears on the map, tile and feature alike, lowest first.
+     *
+     * This is what the legend lists and what decides the drawing order, so a raster basemap at
+     * zIndex -1 sits under the parcels without either side knowing about the other.
+     */
+    getDisplayLayers(): (OFSLayerData | OFSTileLayer)[];
+    /** A layer of either kind, for the settings the two have in common */
+    private findAnyLayer;
+    /** Tell the right listeners that a layer changed, whichever kind it is */
+    private emitLayerChanged;
+    /**
+     * Set layer visibility. Works on tile layers too, so one legend toggle drives both kinds.
      */
     setLayerVisibility(layerId: string, visible: boolean): void;
     /**
@@ -2691,7 +2803,7 @@ export declare class OFSDataSource extends TypedEventEmitter<OFSDataSourceEvents
     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 */
+    /** A layer of either kind is drawn when it and all of its parent groups are visible */
     isLayerRendered(layerId: string): boolean;
     setActiveLayer(layerId: string | null): void;
     getActiveLayerId(): string | null;
@@ -2816,6 +2928,15 @@ export declare interface OFSDataSourceEvents {
     'layer:updated': {
         layer: OFSLayerData;
     };
+    'tile-layer:added': {
+        layer: OFSTileLayer;
+    };
+    'tile-layer:removed': {
+        layerId: string;
+    };
+    'tile-layer:updated': {
+        layer: OFSTileLayer;
+    };
     'feature:added': {
         layerId: string;
         feature: Feature<Geometry, any>;
@@ -3465,7 +3586,25 @@ export declare interface OFSFeatureMetadata {
 
 export declare class OFSFileIO {
     private dataSource;
-    constructor(dataSource: OFSDataSource);
+    private thematicEngine?;
+    /**
+     * `thematicEngine` is only needed for projects, which carry the styling of each layer. File
+     * import and export never touch it, so it stays optional and `saveProject` says so if it is
+     * missing rather than silently writing a project with no symbology in it.
+     */
+    constructor(dataSource: OFSDataSource, thematicEngine?: OFSThematicEngine | undefined);
+    /** Attach the styling engine after construction, when the two are built in that order */
+    useThematicEngine(engine: OFSThematicEngine): void;
+    private requireThemes;
+    /**
+     * Write the whole map out as a project: the layers and their data, the tile layers, the groups,
+     * the styling and the drawing order. See `project.ts`.
+     */
+    saveProject(options?: SaveProjectOptions): OFSProjectFile;
+    /** Read a project back onto the map, from an object or from the text of a `.ofsproj` file */
+    loadProject(project: OFSProjectFile | string, options?: LoadProjectOptions): LoadProjectResult;
+    /** A project as a file ready to be downloaded or written to disk */
+    exportProject(name?: string, options?: SaveProjectOptions): ExportedFile;
     /** Parse and add files as new layers */
     import(files: InputFile[], options?: ImportOptions): ImportToDataSourceResult;
     /** Browser File objects (from <input type="file"> or drag & drop) */
@@ -3795,6 +3934,8 @@ export declare class OFSObject {
     private dynamicInput;
     /** Map handed over by the host application (config.map), attached on init() */
     private readonly hostMap;
+    /** Defaults for the map init() builds; the engine itself is usually passed here */
+    private readonly mapOptions;
     constructor(config?: OFSObjectConfig);
     /**
      * Initialize map adapter and bind data source.
@@ -3816,12 +3957,29 @@ export declare class OFSObject {
     /**
      * Clean up all resources
      */
+    /**
+     * Save the whole map as a project: layers and their data, tile layers, groups, styling, drawing
+     * order, and where the map is looking. `ofs.io.saveProject()` does the same without the view.
+     */
+    saveProject(options?: SaveProjectOptions): OFSProjectFile;
+    /** Reopen a saved project, and move the map back to where it was looking */
+    loadProject(project: OFSProjectFile | string, options?: LoadProjectOptions): LoadProjectResult;
+    /** Where the map is looking, or undefined before there is a map to ask */
+    private currentView;
     destroy(): void;
 }
 
 export declare interface OFSObjectConfig {
     mapAdapter?: IMapAdapter;
     container?: HTMLElement | string;
+    /**
+     * Options for the map `init()` builds, merged under the ones passed to `init()` itself.
+     *
+     * This is where the map engine goes. Neither `maplibre-gl` nor `mapbox-gl` is imported by this
+     * package, so that an application using one need not install the other, which means the library
+     * has to be handed in: `{ mapOptions: { maplibregl } }` after `import maplibregl from
+     * 'maplibre-gl'`. A map the host creates itself needs none of this - pass it as `map` below.
+     */
     mapOptions?: Record<string, any>;
     /**
      * A MapLibre / Mapbox map the host application created and keeps owning (Angular, React, Vue).
@@ -3839,6 +3997,23 @@ export declare interface OFSObjectConfig {
     console?: IOFSConsole;
 }
 
+export declare interface OFSProjectFile {
+    format: typeof PROJECT_FORMAT;
+    version: number;
+    savedAt: string;
+    /** False when the file describes the layers and their styling but carries no feature data */
+    includesFeatures: boolean;
+    activeLayerId: string | null;
+    groups: LayerGroup[];
+    layers: ProjectLayer[];
+    /** Tile layers are always small - a URL and some numbers - so they are always written in full */
+    tileLayers: TileLayerMetadata[];
+    themes: ThematicDefinition[];
+    view?: ProjectView;
+    /** Anything the host application wants to keep with the map */
+    extra?: Record<string, unknown>;
+}
+
 declare class OFSSelectionOverlay {
     private dataSource;
     private mapAdapter;
@@ -3979,6 +4154,38 @@ export declare class OFSThematicEngine extends TypedEventEmitter<ThematicEvents>
     compile(layer: OFSLayerData): CompiledLayerStyle;
 }
 
+export declare class OFSTileLayer {
+    readonly id: string;
+    readonly kind: TileLayerKind;
+    name: string;
+    zIndex: number;
+    visible: boolean;
+    opacity: number;
+    pinned: boolean;
+    tag?: string;
+    groupId?: string;
+    readonly tiles: string[];
+    readonly url?: string;
+    readonly tileSize: number;
+    readonly scheme: 'xyz' | 'tms';
+    readonly minzoom?: number;
+    readonly maxzoom?: number;
+    readonly bounds?: BoundingBox;
+    readonly attribution?: string;
+    styles: VectorTileStyle[];
+    readonly metadata: TileLayerMetadata;
+    constructor(metadata: TileLayerMetadata);
+    /** The source definition a GL map engine expects. Undefined keys are dropped, not sent as null. */
+    toSourceSpec(): Record<string, any>;
+    /**
+     * The GL layers to draw this tile set with, bottom first.
+     *
+     * Opacity is folded into the paint properties rather than applied to the layer as a whole,
+     * because GL styles have no layer-wide opacity: each type names its own.
+     */
+    toLayerSpecs(): Record<string, any>[];
+}
+
 export declare class OFSTopologyPanel {
     private readonly dataSource;
     private readonly topology;
@@ -4265,6 +4472,9 @@ 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;
 
+/** Parse a project from the text of a `.ofsproj` file */
+export declare function parseProject(text: string): OFSProjectFile;
+
 export declare function parseWkb(bytes: Uint8Array, offset?: number): {
     geometry: Geometry;
     end: number;
@@ -4346,9 +4556,27 @@ export declare function printImportResult(consoleService: IOFSConsole, result: I
 /** 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 const PROJECT_FORMAT = "ofs-project";
+
+export declare const PROJECT_VERSION = 1;
+
 /** Plane to do the arc maths on, centred on the curve so distances come out in ground meters */
 export declare function projectionForVertices(vertices: Coordinate[]): PlanarProjection;
 
+export declare interface ProjectLayer {
+    metadata: LayerMetadata;
+    /** Left out when the project was saved without feature data */
+    features?: Feature<Geometry, any>[];
+}
+
+/** Where the map was looking when the project was saved */
+export declare interface ProjectView {
+    center: Coordinate;
+    zoom: number;
+    bearing?: number;
+    pitch?: number;
+}
+
 export declare class PromptBuilder {
     /**
      * Summarize current map state for LLM prompt context.
@@ -4425,6 +4653,9 @@ export declare function renderSymbolSwatchSvg(symbol: SymbolStyle, geomType: Lay
 /** Report an error that was caught and recovered from */
 export declare function reportInternalError(scope: string, error: unknown): void;
 
+/** The engine to build a map with, or an error saying how to supply one */
+export declare function requireMapEngine(global: MapEngineGlobal, options?: Record<string, any>): any;
+
 /**
  * Resolves all selected features across all layers in the dataset,
  * prioritizing active layer features first, followed by other layers,
@@ -4548,6 +4779,21 @@ export declare function runTopologyChecks(features: AnyFeature[], layer: {
     name?: string;
 }, options?: TopologyOptions): Generator<TopologyProgress, TopologyReport, void>;
 
+/** Write the current map out as a project */
+export declare function saveProject(dataSource: OFSDataSource, thematicEngine: OFSThematicEngine, options?: SaveProjectOptions): OFSProjectFile;
+
+export declare interface SaveProjectOptions {
+    /**
+     * Write the features into the file (default). Turning this off keeps the layers, their styling
+     * and their order but leaves the data out, for a project meant to be reconnected to a database
+     * or to files that live elsewhere - and for a project of 98,000 parcels, which is 60 MB of
+     * GeoJSON nobody wants in version control.
+     */
+    features?: boolean;
+    view?: ProjectView;
+    extra?: Record<string, unknown>;
+}
+
 export declare interface ScaleBarPlan {
     /** Ground distance the bar represents, in meters */
     meters: number;
@@ -5023,6 +5269,40 @@ export declare interface ThematicEvents {
  */
 export declare type ThematicType = 'simple' | 'categorical' | 'graduated';
 
+export declare type TileLayerKind = 'raster' | 'vector';
+
+export declare interface TileLayerMetadata {
+    id: string;
+    name: string;
+    kind: TileLayerKind;
+    /**
+     * Tile URL templates with `{z}`, `{x}` and `{y}` placeholders. Several entries are read as
+     * mirrors of the same tile set, which is how a server spreads load across subdomains.
+     */
+    tiles?: string[];
+    /** A TileJSON document describing the tile set, as an alternative to `tiles` */
+    url?: string;
+    /** Raster tile edge in pixels; 512 for the retina tiles many providers serve */
+    tileSize?: number;
+    /** `tms` counts rows from the bottom, the opposite of the usual `xyz` */
+    scheme?: 'xyz' | 'tms';
+    minzoom?: number;
+    maxzoom?: number;
+    /** Area the tile set covers; outside it the map does not ask for tiles */
+    bounds?: BoundingBox;
+    /** Credit line the provider requires; map engines show it in the corner */
+    attribution?: string;
+    /** Required for `vector`, meaningless for `raster` */
+    styles?: VectorTileStyle[];
+    zIndex?: number;
+    visible?: boolean;
+    opacity?: number;
+    pinned?: boolean;
+    tag?: string;
+    groupId?: string;
+    [key: string]: unknown;
+}
+
 /** Split on whitespace, keeping "quoted text" together */
 export declare function tokenizeArgs(raw: string): string[];
 
@@ -5299,6 +5579,14 @@ export declare function validateFieldName(name: string, existing: FieldSchema[])
  */
 export declare function validateGeometry(geometry: Geometry | null | undefined, index: number, issues: ImportIssue[], ctx?: ValidationContext): Geometry | null;
 
+/**
+ * Check that a value really is a project this build can open, and say what is wrong when it is not.
+ *
+ * A file from a newer release is refused rather than half-read: reading the parts that happen to
+ * look familiar and quietly dropping the rest produces a map that looks plausible and is wrong.
+ */
+export declare function validateProject(value: unknown): OFSProjectFile;
+
 export declare interface ValidationContext {
     file?: string;
     closeRings?: boolean;
@@ -5306,6 +5594,27 @@ export declare interface ValidationContext {
     geographic?: boolean;
 }
 
+/**
+ * How one named layer inside a vector tile should be drawn.
+ *
+ * Vector tiles carry several layers ("roads", "buildings", "parcels") and no instructions for
+ * drawing any of them, so the caller says which to draw and how. Nothing is guessed: a tile set
+ * whose styling is left out renders nothing, which is a silent blank map, so it is refused instead.
+ */
+export declare interface VectorTileStyle {
+    /** Name of the layer inside the tile, as the tile server publishes it */
+    sourceLayer: string;
+    type: 'fill' | 'line' | 'circle' | 'symbol';
+    /** GL paint properties, passed through as given */
+    paint?: Record<string, any>;
+    layout?: Record<string, any>;
+    filter?: any[];
+    minzoom?: number;
+    maxzoom?: number;
+    /** Suffix for the GL layer id; needed when one source layer is drawn more than once */
+    id?: string;
+}
+
 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) */