@ngis/plugin-sdk 0.4.0

package/dist/src/domain/map/constants.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Shared, cross-module constants for the map domain layer. Extracted
+ * mechanically from `SceneMapCanvas.tsx` (session C1) — values only, no
+ * behavior change.
+ */
+/** MVT source-layer name every scene tile source/layer is built against. */
+export declare const SCENE_TILE_SOURCE_LAYER = "layer";
+/** Transparent MapLibre layer used as the insertion boundary above raster basemaps. */
+export declare const BASEMAP_SCENE_ANCHOR_LAYER_ID = "ngis-basemap:scene-anchor";
+/** Id prefix for the draw-query hit-test highlight overlay layers. */
+export declare const HIGHLIGHT_LAYER_PREFIX = "scene-query-highlight-layer";
+/** Id prefix for the transient attribute-table highlight overlay. */
+export declare const ATTRIBUTE_HIGHLIGHT_LAYER_PREFIX = "scene-attribute-highlight-layer";
+/**
+ * Layer-stacking contract (see `docs/componentization_stage/README.md`
+ * "interlock map" #6): scene-layer insertion position prefers the first
+ * existing style layer whose id starts with one of these prefixes, then falls
+ * back to `BASEMAP_SCENE_ANCHOR_LAYER_ID` for symbol-free raster basemaps
+ * (`getSceneLayerBeforeId` / `moveSceneLayerToRenderSlot` in
+ * `rendered-layers.ts`). Scene layers therefore render above every basemap
+ * layer and underneath draw, measure, and highlight overlays.
+ *
+ * This was previously an implicit convention (each subsystem picked its own
+ * `prefixId`/layer-id scheme and this list had to be kept in sync by hand).
+ * It is now an explicit, exported, commented contract. Future owners of each
+ * prefix (componentization stage, sessions C3–C5):
+ *
+ *  - `HIGHLIGHT_LAYER_PREFIX` ("scene-query-highlight-layer") — draw-query hit
+ *    highlight overlay, owned by **HighlightController** (session C5).
+ *  - `ATTRIBUTE_HIGHLIGHT_LAYER_PREFIX` (`"scene-attribute-highlight-layer"`)
+ *    — transient attribute-table highlight, owned by `HighlightController`.
+ *  - `"scene-draw"` — Terra Draw's draw-control adapter `prefixId`
+ *    (`addSceneDrawControl`), owned by **DrawController** (session C4).
+ *  - `"scene-measure"` — Terra Draw's measure-control adapter `prefixId`
+ *    (`addSceneMeasureControl`), owned by **MeasureController** (session C4).
+ *
+ * `SceneLayersController` (session C3) is the consumer that must keep scene
+ * layers stacked beneath all three overlay families using this list.
+ */
+export declare const SCENE_OVERLAY_LAYER_PREFIXES: readonly ["scene-query-highlight-layer", "scene-attribute-highlight-layer", "scene-draw", "scene-measure"];

package/dist/src/domain/map/layer-builders.d.ts

@@ -0,0 +1,32 @@
+/**
+ * MapLibre layer/source builders + custom raster-color layer glue. Extracted
+ * mechanically from `SceneMapCanvas.tsx` (session C1) — no behavior change,
+ * except `buildCustomRasterColorLayer` which now takes its tile
+ * `getRequestInit` factory as a parameter (dependency injection) instead of
+ * calling the auth-wrapped `getSceneTileRequestInit` directly — see
+ * `src/lib/map-tile-auth.ts` for why (`domain/` must not import auth).
+ */
+import type { LayerSpecification, SourceSpecification } from "maplibre-gl";
+import type { NgisSceneLayer, SceneResourceDto } from "../../api/scenes";
+import { RasterColorLayer } from "../../lib/raster-color-layer/RasterColorLayer";
+import type { ColorStop, RasterColorMode } from "../../lib/raster-color-layer/colorRamp";
+import type { TileRequestInitFactory } from "../../lib/raster-color-layer/TileGrid";
+import type { SceneLayerStyle } from "./types";
+export declare function parseSceneLayerStyle(styleJson?: string | null): SceneLayerStyle;
+export declare function getLayerRenderMode(kind: "vector" | "raster", style: SceneLayerStyle): "maplibre" | "custom-raster-color";
+export declare function getLayerKind(layer: NgisSceneLayer): "raster" | "vector";
+export declare function getSourceForLayer(kind: "vector" | "raster", resource: SceneResourceDto, style?: SceneLayerStyle): SourceSpecification;
+export declare function buildMapLayer(sceneLayer: NgisSceneLayer, resource: SceneResourceDto, sourceId: string, layerId: string): LayerSpecification;
+export declare function getSceneMapLayerId(sceneLayerId: string): string;
+export declare function getSceneSourceId(sceneLayerId: string): string;
+export declare function getLayerSourceKey(layer: NgisSceneLayer, resource: SceneResourceDto, style: SceneLayerStyle): string;
+export declare function getStyleRecord(value: unknown): import("../algorithms/maplibre-style").MapLibreStyleRecord;
+export declare function getVisibleZoomRange(style: SceneLayerStyle): [number, number];
+export declare function getRasterOpacity(style: SceneLayerStyle): number;
+export declare function getRasterColorStyle(style: SceneLayerStyle): {
+    ramp: ColorStop[];
+    colorMode: RasterColorMode;
+    classBreaks?: number[];
+    valueRange: [number, number];
+};
+export declare function buildCustomRasterColorLayer(layerId: string, resource: SceneResourceDto, style: SceneLayerStyle, getRequestInit: TileRequestInitFactory): RasterColorLayer;

package/dist/src/domain/map/rendered-layers.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Rendered scene-layer lifecycle: add/remove/paint-diff-update and
+ * layer-stacking slot placement. Extracted mechanically from
+ * `SceneMapCanvas.tsx` (session C1) — no behavior change to the functions
+ * below.
+ *
+ * Session C3 note: this module used to also export a `syncSceneLayers`
+ * whole-scene reconciler (C1's mechanical extraction of the shell's inline
+ * function of the same name). C1's own doc flagged it as provisional —
+ * "C3's `SceneLayersController` still supersedes it" — and C3 does exactly
+ * that: `src/systems/renderer/LayerRendererRegistry.ts#reconcileSceneLayers`
+ * is its registry-driven replacement (same control flow, ported
+ * deliberately), consumed by `src/components/scenes/map/
+ * SceneLayersController.tsx`. `syncSceneLayers` was removed here (along with
+ * the imports it alone used) rather than left in place, because it depended
+ * on `DeckSceneRenderer.sync`'s old `DeckSceneLayerInput[]`-based signature,
+ * which C3 also changed (`DeckSceneRenderer` now takes built deck.gl
+ * `Layer[]` directly — see that file's doc comment) — keeping both call
+ * shapes alive at once would have meant two parallel, divergence-prone ways
+ * to build a deck.gl layer. The functions below (still consumed by other
+ * scene controllers, e.g. C6's `<MapLayer>` primitive) are untouched.
+ */
+import type { LayerSpecification, Map as MapLibreMap } from "maplibre-gl";
+import type { RenderedSceneLayer, SceneLayerStyle } from "./types";
+export declare function removeRenderedSceneLayer(map: MapLibreMap, rendered: RenderedSceneLayer): void;
+export declare function removeRenderedSceneLayers(map: MapLibreMap, renderedLayers: RenderedSceneLayer[]): void;
+export declare function applyCustomRasterColorLayerStyleUpdate(map: MapLibreMap, rendered: RenderedSceneLayer, style: SceneLayerStyle): boolean;
+export declare function applySceneLayerStyleUpdate(map: MapLibreMap, rendered: RenderedSceneLayer, mapLayer: LayerSpecification): boolean;
+export declare function getSceneLayerBeforeId(map: MapLibreMap): string | undefined;
+export declare function moveSceneLayerToRenderSlot(map: MapLibreMap, layerId: string): void;

package/dist/src/domain/map/style-ready.d.ts

@@ -0,0 +1,24 @@
+/**
+ * MapLibre style-readiness helpers. Extracted mechanically from
+ * `SceneMapCanvas.tsx` (session C1) — no behavior change.
+ *
+ * `waitForMapStyleReady` deliberately uses the stronger `isStyleLoaded()`
+ * gate polled via `style.load` + `styledata` + `idle` (not a weaker
+ * `load`+`styledata` AND) — see README L1 section, "Readiness semantics".
+ */
+import type { Map as MapLibreMap } from "maplibre-gl";
+export declare function getMapStyleLayers(map: MapLibreMap): import("maplibre-gl").LayerSpecification[];
+export declare function isMapStyleReady(map: MapLibreMap): boolean | void;
+export declare function waitForMapStyleReady(map: MapLibreMap, onReady: () => void): () => void;
+/**
+ * Wait for a style transition that starts after this function is called.
+ *
+ * Unlike `waitForMapStyleReady`, this never treats the currently loaded style
+ * as the requested style. `map.setStyle(url)` uses an asynchronous diff by
+ * default, so the old style can keep reporting `isStyleLoaded() === true`
+ * until the new style JSON arrives. Callers must register this waiter before
+ * `setStyle()`; the callback only becomes eligible after the next
+ * `style.load` event and the resulting style is fully ready.
+ */
+export declare function waitForNextMapStyleReady(map: MapLibreMap, onReady: () => void): () => void;
+export declare function getFirstSymbolLayerId(map: MapLibreMap): string | undefined;

package/dist/src/domain/map/tile-url.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Pure tile URL/target/params builders + tile-error classification. Extracted
+ * mechanically from `SceneMapCanvas.tsx` (session C1) — no behavior change.
+ *
+ * Purity constraint (README L0): the original `getSceneTileRequestInit`
+ * called `getAccessToken()` — auth may not enter `domain/`. That authorized
+ * `RequestInit` wrapper now lives in `src/lib/map-tile-auth.ts`; only the pure
+ * URL/params builders remain here.
+ */
+import type { ErrorEvent } from "maplibre-gl";
+import type { SceneResourceDto } from "../../api/scenes";
+import type { SceneLayerStyle, SceneTileTarget } from "./types";
+export declare function getTileParams(style: SceneLayerStyle, options?: {
+    encoding?: string;
+}): string | null;
+export declare function getSceneTileTarget(resource: SceneResourceDto): SceneTileTarget;
+export declare function getSceneTileUrl(kind: "vector" | "raster", resource: SceneResourceDto, style?: SceneLayerStyle, options?: {
+    encoding?: string;
+}): string;
+export declare function isSceneTileError(event: ErrorEvent): boolean;

package/dist/src/domain/map/types.d.ts

@@ -0,0 +1,128 @@
+/**
+ * Pure data types for the map domain layer. Extracted mechanically from
+ * `SceneMapCanvas.tsx` (session C1) — no behavior change. Types re-exported
+ * from `SceneMapCanvas.tsx` are part of the frozen compat contract (see
+ * `docs/componentization_stage/README.md`); consumer import paths must not
+ * change.
+ */
+import type { LayerSpecification } from "maplibre-gl";
+import type { RasterColorLayer } from "../../lib/raster-color-layer/RasterColorLayer";
+import type { GisMeasureKind } from "../../types/gis";
+/** Measurement flavour, re-exported so rail consumers import it from one place. */
+export type SceneMeasureKind = GisMeasureKind;
+/** Map camera state — used to restore (`initialView`) and persist (`onViewChange`). */
+export interface SceneMapView {
+    center: [number, number];
+    zoom: number;
+    pitch?: number;
+    bearing?: number;
+}
+export type SceneMapCoordinate = number | SceneMapCoordinate[] | number[];
+export interface SceneMapGeometry {
+    type: string;
+    coordinates?: SceneMapCoordinate;
+    geometries?: SceneMapGeometry[];
+}
+export type SceneMapFeatureProperties = Record<string, unknown>;
+export interface SceneMapFeature {
+    type: "Feature";
+    id?: string | number;
+    geometry: SceneMapGeometry;
+    properties: SceneMapFeatureProperties;
+}
+export interface SceneMapFeatureCollection {
+    type: "FeatureCollection";
+    features: SceneMapFeature[];
+}
+export type SceneMapDrawFeatureCollection = SceneMapFeatureCollection;
+export interface SceneMapQueryableLayer {
+    sceneLayerId: string;
+    mapLayerId: string;
+    sourceId: string;
+    resourceId: string;
+    effectiveFileId: string;
+    layerName: string;
+    layerType: "fill" | "line" | "circle";
+}
+export interface SceneMapQueriedFeature {
+    id?: string | number;
+    sceneLayerId: string;
+    resourceId: string;
+    effectiveFileId: string;
+    layerName: string;
+    properties: SceneMapFeatureProperties;
+    geometry: SceneMapGeometry;
+}
+export interface SceneMapDrawQueryResult {
+    drawFeatures: SceneMapDrawFeatureCollection;
+    features: SceneMapQueriedFeature[];
+    featureCollection: SceneMapFeatureCollection;
+}
+/** A rendered raster layer at an identify click. Numeric samples require a
+ * dedicated raster-sampling service; MapLibre image tiles carry no raw cells. */
+export interface SceneMapIdentifyRasterLayer {
+    sceneLayerId: string;
+    resourceId: string;
+    effectiveFileId: string;
+    layerName: string;
+}
+/** Result of a one-point map identify operation. */
+export interface SceneMapIdentifyResult {
+    coordinate: [number, number];
+    features: SceneMapQueriedFeature[];
+    rasterLayers: SceneMapIdentifyRasterLayer[];
+}
+/**
+ * Live state of the (Terra Draw–backed) measurement overlay. Emitted on every
+ * change so the rail's contextual strip can show a running total; the on-map
+ * labels with units are rendered by `MaplibreMeasureControl` itself. `features`
+ * are the raw measure geometries (guidance vertices filtered out) — the caller
+ * derives length/area from them, keeping the geodesic math in one place.
+ */
+export interface SceneMeasureState {
+    kind: SceneMeasureKind;
+    features: SceneMapFeatureCollection;
+    finished: boolean;
+}
+export interface SceneMapHighlightFeature {
+    layer: SceneMapQueryableLayer;
+    properties: SceneMapFeatureProperties;
+}
+export type HighlightFilterExpression = unknown[];
+/** Attribute-table highlight for one scene layer. */
+export interface SceneLayerHighlight {
+    /** Scene layer id whose rendered source should be highlighted. */
+    layerId: string;
+    /** Row ids (== tile `uuid`) to mark as selected. */
+    featureIds: string[];
+    /** Highlight every feature in the layer, apart from explicit exclusions. */
+    allFeatures?: boolean;
+    /** Only meaningful with `allFeatures`; rows unchecked after select-all. */
+    excludedFeatureIds?: string[];
+}
+export type SceneLayerStyle = Record<string, unknown>;
+export type SceneLayerRenderMode = "maplibre" | "custom-raster-color" | "custom-flow-field";
+export type RenderedSceneLayer = {
+    sceneLayerId: string;
+    layerId: string;
+    sourceId: string;
+    sourceKey: string;
+    renderMode: SceneLayerRenderMode;
+    layerType: LayerSpecification["type"] | "custom";
+    paintKeys: string[];
+    layoutKeys: string[];
+    customLayer?: RasterColorLayer;
+    customInstance?: {
+        update?(input: SceneLayerStyle): boolean;
+        setVisible?(visible: boolean): void;
+        destroy?(): void;
+    };
+};
+export type ResourceBounds = [number, number, number, number];
+export type SceneTileTarget = {
+    mode: "live" | "snapshot";
+    id: string;
+};
+export type QueryableRenderedSceneLayer = RenderedSceneLayer & {
+    layerType: "fill" | "line" | "circle";
+};

package/dist/src/domain/models/deck-layer-style.d.ts

@@ -0,0 +1,211 @@
+import type { SceneLayerGeometryFamily, SceneLayerTypeId } from "./scene-layer-type";
+export type DeckLayerStyleKind = DeckLayerStyle["type"];
+export type DeckSceneLayerTypeId = Extract<SceneLayerTypeId, `DECK_${string}`>;
+export type DeckEditorSectionKind = "layer" | "elevation" | "color" | "outline" | "material" | "width" | "weight" | "heatmap" | "hexagon" | "geometry";
+export interface DeckLayerCapabilityDefinition {
+    sceneLayerType: DeckSceneLayerTypeId;
+    styleType: DeckLayerStyleKind;
+    geometryFamily: Exclude<SceneLayerGeometryFamily, "raster">;
+    aggregation: boolean;
+    requiresNumericField: boolean;
+    defaultColorRampId: "ylorrd" | "blues";
+    editorSections: readonly DeckEditorSectionKind[];
+}
+/**
+ * Framework-free source of truth for the Deck protocols implemented by NGIS.
+ * Renderer and editor registries derive their keys/order from this catalog.
+ */
+export declare const DECK_LAYER_CAPABILITY_DEFINITIONS: readonly [{
+    readonly sceneLayerType: "DECK_MVT_EXTRUDED_POLYGON";
+    readonly styleType: "deck-mvt-extruded-polygon";
+    readonly geometryFamily: "polygon";
+    readonly aggregation: false;
+    readonly requiresNumericField: true;
+    readonly defaultColorRampId: "ylorrd";
+    readonly editorSections: readonly ["layer", "elevation", "color", "outline", "material"];
+}, {
+    readonly sceneLayerType: "DECK_COLUMN";
+    readonly styleType: "deck-column";
+    readonly geometryFamily: "point";
+    readonly aggregation: false;
+    readonly requiresNumericField: true;
+    readonly defaultColorRampId: "ylorrd";
+    readonly editorSections: readonly ["layer", "elevation", "color", "geometry", "material"];
+}, {
+    readonly sceneLayerType: "DECK_HEATMAP";
+    readonly styleType: "deck-heatmap";
+    readonly geometryFamily: "point";
+    readonly aggregation: true;
+    readonly requiresNumericField: false;
+    readonly defaultColorRampId: "ylorrd";
+    readonly editorSections: readonly ["layer", "weight", "color", "heatmap"];
+}, {
+    readonly sceneLayerType: "DECK_HEXAGON";
+    readonly styleType: "deck-hexagon";
+    readonly geometryFamily: "point";
+    readonly aggregation: true;
+    readonly requiresNumericField: false;
+    readonly defaultColorRampId: "ylorrd";
+    readonly editorSections: readonly ["layer", "weight", "color", "hexagon", "material"];
+}, {
+    readonly sceneLayerType: "DECK_MVT_LINE";
+    readonly styleType: "deck-mvt-line";
+    readonly geometryFamily: "line";
+    readonly aggregation: false;
+    readonly requiresNumericField: false;
+    readonly defaultColorRampId: "blues";
+    readonly editorSections: readonly ["layer", "color", "width", "geometry"];
+}];
+export type ImplementedDeckSceneLayerTypeId = (typeof DECK_LAYER_CAPABILITY_DEFINITIONS)[number]["sceneLayerType"];
+export type DeckClassificationMethod = "equal-interval" | "quantile" | "natural-breaks";
+export type DeckCategoryValue = string | number | boolean;
+export type DeckColorMapping = {
+    mode: "constant";
+    value: string;
+} | {
+    mode: "categorical";
+    field: string;
+    categories: Array<{
+        value: DeckCategoryValue;
+        color: string;
+    }>;
+    defaultColor: string;
+} | {
+    mode: "graduated";
+    field: string;
+    breaks: number[];
+    colors: string[];
+} | {
+    mode: "continuous";
+    field: string;
+    stops: Array<{
+        input: number;
+        color: string;
+    }>;
+};
+export interface DeckStrokeStyle {
+    value: number;
+    units: "pixels" | "meters";
+    scale: number;
+    minPixels: number;
+    maxPixels: number;
+}
+export interface DeckMaterialStyle {
+    ambient: number;
+    diffuse: number;
+    shininess: number;
+    specularColor: string;
+}
+export type DeckElevationDirection = "ascending" | "descending";
+export interface DeckElevationStyle {
+    field: string;
+    scale: number;
+    direction: DeckElevationDirection;
+    domain: [number, number] | null;
+}
+export interface DeckMvtExtrudedPolygonStyle {
+    version: 1;
+    type: "deck-mvt-extruded-polygon";
+    filled: boolean;
+    stroked: boolean;
+    wireframe: boolean;
+    elevation: DeckElevationStyle;
+    color: DeckColorMapping;
+    opacity: number;
+    outlineColor: string | null;
+    outlineWidth: DeckStrokeStyle;
+    material: DeckMaterialStyle | null;
+}
+export type DeckLineWidthStyle = {
+    mode: "constant";
+    value: number;
+    units: "pixels" | "meters";
+    scale: number;
+    minPixels: number;
+    maxPixels: number;
+    billboard: boolean;
+} | {
+    mode: "graduated";
+    field: string;
+    defaultValue: number;
+    stops: Array<{
+        input: number;
+        output: number;
+    }>;
+    units: "pixels" | "meters";
+    scale: number;
+    minPixels: number;
+    maxPixels: number;
+    billboard: boolean;
+};
+export interface DeckMvtLineStyle {
+    version: 1;
+    type: "deck-mvt-line";
+    color: DeckColorMapping;
+    width: DeckLineWidthStyle;
+    opacity: number;
+    capRounded: boolean;
+    jointRounded: boolean;
+    miterLimit: number;
+}
+export interface DeckColumnStyle {
+    version: 1;
+    type: "deck-column";
+    radius: {
+        value: number;
+        units: "meters" | "pixels";
+    };
+    diskResolution: number;
+    angle: number;
+    coverage: number;
+    wireframe: boolean;
+    flatShading: boolean;
+    elevation: DeckElevationStyle;
+    color: DeckColorMapping;
+    opacity: number;
+    material: DeckMaterialStyle | null;
+}
+export type DeckAggregationWeight = {
+    mode: "constant";
+    value: number;
+} | {
+    mode: "field";
+    field: string;
+    scale: number;
+};
+export type DeckHeatmapWeight = DeckAggregationWeight;
+export type DeckAggregationOperation = "SUM" | "MEAN" | "MIN" | "MAX" | "COUNT";
+export interface DeckHeatmapStyle {
+    version: 1;
+    type: "deck-heatmap";
+    weight: DeckHeatmapWeight;
+    aggregation: "SUM" | "MEAN";
+    radiusPixels: number;
+    intensity: number;
+    threshold: number;
+    colorRange: string[];
+    colorDomain: [number, number] | null;
+    weightsTextureSize: number;
+    debounceTimeout: number;
+    opacity: number;
+}
+export interface DeckHexagonStyle {
+    version: 1;
+    type: "deck-hexagon";
+    weight: DeckAggregationWeight;
+    colorAggregation: DeckAggregationOperation;
+    elevationAggregation: DeckAggregationOperation;
+    radius: number;
+    coverage: number;
+    extruded: boolean;
+    elevationScale: number;
+    colorRange: string[];
+    colorDomain: [number, number] | null;
+    colorScaleType: "linear" | "quantize" | "quantile" | "ordinal";
+    lowerPercentile: number;
+    upperPercentile: number;
+    material: DeckMaterialStyle | null;
+    opacity: number;
+}
+export type DeckLayerStyle = DeckMvtExtrudedPolygonStyle | DeckColumnStyle | DeckHeatmapStyle | DeckHexagonStyle | DeckMvtLineStyle;
+export type DeckColorMappedLayerStyle = DeckMvtExtrudedPolygonStyle | DeckColumnStyle | DeckMvtLineStyle;

package/dist/src/domain/models/scene-layer-type.d.ts

@@ -0,0 +1,23 @@
+export declare const SCENE_LAYER_TYPE_IDS: readonly ["MAPLIBRE_FILL", "MAPLIBRE_LINE", "MAPLIBRE_CIRCLE", "MAPLIBRE_RASTER", "CUSTOM_FLOW_FIELD", "DECK_MVT_POLYGON", "DECK_MVT_EXTRUDED_POLYGON", "DECK_COLUMN", "DECK_HEATMAP", "DECK_HEXAGON", "DECK_MVT_LINE", "DECK_MVT_POINT", "SYMBOL_POINT", "SYMBOL_LINE", "SYMBOL_POLYGON"];
+export type SceneLayerTypeId = (typeof SCENE_LAYER_TYPE_IDS)[number];
+export type LegacySceneLayerTypeId = "VECTOR" | "RASTER";
+export type SceneLayerRendererKind = "maplibre" | "deck" | "custom";
+export type SceneLayerResourceKind = "vector" | "raster";
+export type SceneLayerGeometryFamily = "point" | "line" | "polygon" | "raster";
+export type SceneLayerStyleKind = "maplibre-fill" | "maplibre-line" | "maplibre-circle" | "maplibre-raster" | "custom-flow-field" | "deck-mvt-polygon" | "deck-mvt-extruded-polygon" | "deck-column" | "deck-heatmap" | "deck-hexagon" | "deck-mvt-line" | "deck-mvt-point" | "symbol";
+export interface SceneLayerTypeDefinition {
+    id: SceneLayerTypeId;
+    label: string;
+    renderer: SceneLayerRendererKind;
+    resourceTypes: readonly SceneLayerResourceKind[];
+    geometryFamilies: readonly SceneLayerGeometryFamily[];
+    styleKind: SceneLayerStyleKind;
+    creationEnabled: boolean;
+    requiresNumericField?: boolean;
+}
+export interface CreateSceneLayerSelection {
+    layerType: SceneLayerTypeId;
+    styleJson: string;
+    name?: string;
+}
+export declare const SCENE_LAYER_TYPE_DEFINITIONS: readonly SceneLayerTypeDefinition[];