@angular-helpers/openlayers 0.3.0 → 0.5.0

package/types/angular-helpers-openlayers-layers.d.ts

@@ -1,19 +1,89 @@
 import * as _angular_core from '@angular/core';
-import { Feature, Style, Layer, Extent, OlFeature } from '@angular-helpers/openlayers/core';
+import { Layer, Extent, Feature, Style, OlFeature } from '@angular-helpers/openlayers/core';
+import { FlatStyleLike } from 'ol/style/flat';
+import { Style as Style$1 } from 'ol/layer/WebGLTile';
 import BaseLayer from 'ol/layer/Base';
 
+interface LayerConfig extends Layer {
+    type: 'vector' | 'tile' | 'image' | 'heatmap';
+    extent?: Extent;
+    minResolution?: number;
+    maxResolution?: number;
+}
+interface ClusterConfig {
+    /** Enable clustering (default: false) */
+    enabled: boolean;
+    /** Distance in pixels within which features will be clustered (default: 40) */
+    distance?: number;
+    /** Minimum distance between clusters (default: 20) */
+    minDistance?: number;
+    /** Show count badge on cluster (default: true) */
+    showCount?: boolean;
+    /** Style for individual features when clustering */
+    featureStyle?: Style;
+}
+interface VectorLayerConfig extends LayerConfig {
+    type: 'vector';
+    features?: Feature[];
+    url?: string;
+    format?: 'geojson' | 'topojson' | 'kml';
+    style?: Style | ((feature: Feature) => Style);
+    cluster?: ClusterConfig;
+}
+interface HeatmapLayerConfig extends LayerConfig {
+    type: 'heatmap';
+    features?: Feature[];
+    weight?: string | ((feature: Feature) => number);
+    blur?: number;
+    radius?: number;
+}
+interface TileLayerConfig extends LayerConfig {
+    type: 'tile';
+    source: SourceConfig;
+}
+interface ImageLayerConfig extends LayerConfig {
+    type: 'image';
+    source: ImageSourceConfig;
+}
+interface SourceConfig {
+    type: 'osm' | 'xyz' | 'wms' | 'wmts';
+    url?: string;
+    attributions?: string | string[];
+    params?: Record<string, unknown>;
+}
+interface ImageSourceConfig {
+    type: 'wms' | 'static';
+    url: string;
+    params?: Record<string, unknown>;
+    imageExtent?: Extent;
+}
+type AnyLayerConfig = VectorLayerConfig | TileLayerConfig | ImageLayerConfig | HeatmapLayerConfig;
+
+declare class OlClusterComponent {
+    distance: _angular_core.InputSignal<number>;
+    minDistance: _angular_core.InputSignal<number>;
+    showCount: _angular_core.InputSignal<boolean>;
+    featureStyle: _angular_core.InputSignal<Style>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OlClusterComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OlClusterComponent, "ol-cluster", never, { "distance": { "alias": "distance"; "required": false; "isSignal": true; }; "minDistance": { "alias": "minDistance"; "required": false; "isSignal": true; }; "showCount": { "alias": "showCount"; "required": false; "isSignal": true; }; "featureStyle": { "alias": "featureStyle"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
 declare class OlVectorLayerComponent {
     private layerService;
     private destroyRef;
     id: _angular_core.InputSignal<string>;
     features: _angular_core.InputSignal<Feature[]>;
+    url: _angular_core.InputSignal<string>;
+    format: _angular_core.InputSignal<"geojson" | "topojson" | "kml">;
     zIndex: _angular_core.InputSignal<number>;
     opacity: _angular_core.InputSignal<number>;
     visible: _angular_core.InputSignal<boolean>;
-    style: _angular_core.InputSignal<Style | ((feature: Feature) => Style)>;
+    style: _angular_core.InputSignal<any>;
+    cluster: _angular_core.InputSignal<ClusterConfig>;
+    clusterComponent: _angular_core.Signal<OlClusterComponent>;
     constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<OlVectorLayerComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OlVectorLayerComponent, "ol-vector-layer", never, { "id": { "alias": "id"; "required": true; "isSignal": true; }; "features": { "alias": "features"; "required": false; "isSignal": true; }; "zIndex": { "alias": "zIndex"; "required": false; "isSignal": true; }; "opacity": { "alias": "opacity"; "required": false; "isSignal": true; }; "visible": { "alias": "visible"; "required": false; "isSignal": true; }; "style": { "alias": "style"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OlVectorLayerComponent, "ol-vector-layer", never, { "id": { "alias": "id"; "required": true; "isSignal": true; }; "features": { "alias": "features"; "required": false; "isSignal": true; }; "url": { "alias": "url"; "required": false; "isSignal": true; }; "format": { "alias": "format"; "required": false; "isSignal": true; }; "zIndex": { "alias": "zIndex"; "required": false; "isSignal": true; }; "opacity": { "alias": "opacity"; "required": false; "isSignal": true; }; "visible": { "alias": "visible"; "required": false; "isSignal": true; }; "style": { "alias": "style"; "required": false; "isSignal": true; }; "cluster": { "alias": "cluster"; "required": false; "isSignal": true; }; }, {}, ["clusterComponent"], never, true, never>;
 }
 
 declare class OlTileLayerComponent {
@@ -48,41 +118,124 @@ declare class OlImageLayerComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<OlImageLayerComponent, "ol-image-layer", never, { "id": { "alias": "id"; "required": true; "isSignal": true; }; "sourceType": { "alias": "sourceType"; "required": true; "isSignal": true; }; "url": { "alias": "url"; "required": true; "isSignal": true; }; "params": { "alias": "params"; "required": false; "isSignal": true; }; "imageExtent": { "alias": "imageExtent"; "required": false; "isSignal": true; }; "zIndex": { "alias": "zIndex"; "required": false; "isSignal": true; }; "opacity": { "alias": "opacity"; "required": false; "isSignal": true; }; "visible": { "alias": "visible"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-interface LayerConfig extends Layer {
-    type: 'vector' | 'tile' | 'image';
-    extent?: Extent;
-    minResolution?: number;
-    maxResolution?: number;
-}
-interface VectorLayerConfig extends LayerConfig {
-    type: 'vector';
-    features?: Feature[];
-    style?: Style | ((feature: Feature) => Style);
-}
-interface TileLayerConfig extends LayerConfig {
-    type: 'tile';
-    source: SourceConfig;
-}
-interface ImageLayerConfig extends LayerConfig {
-    type: 'image';
-    source: ImageSourceConfig;
+declare class OlHeatmapLayerComponent {
+    private layerService;
+    private mapService;
+    private destroyRef;
+    id: _angular_core.InputSignal<string>;
+    features: _angular_core.InputSignal<Feature[]>;
+    zIndex: _angular_core.InputSignal<number>;
+    opacity: _angular_core.InputSignal<number>;
+    visible: _angular_core.InputSignal<boolean>;
+    blur: _angular_core.InputSignal<number>;
+    radius: _angular_core.InputSignal<number>;
+    /** Unit for radius and blur: 'pixels' (default) or 'meters' */
+    radiusUnit: _angular_core.InputSignal<"pixels" | "meters">;
+    weight: _angular_core.InputSignal<string | ((feature: Feature) => number)>;
+    /** Computed radius in pixels based on current resolution if unit is 'meters' */
+    private scaledRadius;
+    /** Computed blur in pixels based on current resolution if unit is 'meters' */
+    private scaledBlur;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OlHeatmapLayerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OlHeatmapLayerComponent, "ol-heatmap-layer", never, { "id": { "alias": "id"; "required": true; "isSignal": true; }; "features": { "alias": "features"; "required": false; "isSignal": true; }; "zIndex": { "alias": "zIndex"; "required": false; "isSignal": true; }; "opacity": { "alias": "opacity"; "required": false; "isSignal": true; }; "visible": { "alias": "visible"; "required": false; "isSignal": true; }; "blur": { "alias": "blur"; "required": false; "isSignal": true; }; "radius": { "alias": "radius"; "required": false; "isSignal": true; }; "radiusUnit": { "alias": "radiusUnit"; "required": false; "isSignal": true; }; "weight": { "alias": "weight"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
-interface SourceConfig {
-    type: 'osm' | 'xyz' | 'wms' | 'wmts';
-    url?: string;
-    attributions?: string | string[];
-    params?: Record<string, unknown>;
+
+/**
+ * GPU-accelerated vector layer for rendering large datasets.
+ *
+ * Important: Uses WebGL 2 for rendering. Styles must be provided as
+ * `FlatStyleLike` objects (not `ol/style/Style` instances).
+ * Hit detection is disabled by default for performance.
+ *
+ * @usageNotes
+ * ```html
+ * <ol-webgl-vector-layer
+ *   id="big-dataset"
+ *   [features]="largeDataset()"
+ *   [flatStyle]="{
+ *     'circle-radius': 6,
+ *     'circle-fill-color': ['match', ['get', 'type'], 'alert', 'red', 'blue'],
+ *     'stroke-color': '#333',
+ *     'stroke-width': 1
+ *   }"
+ *   [disableHitDetection]="true">
+ * </ol-webgl-vector-layer>
+ * ```
+ */
+declare class OlWebGLVectorLayerComponent {
+    private mapService;
+    private destroyRef;
+    /** Unique layer identifier */
+    id: _angular_core.InputSignal<string>;
+    /** Features to render */
+    features: _angular_core.InputSignal<Feature[]>;
+    /** WebGL flat style (required — no default provided) */
+    flatStyle: _angular_core.InputSignal<FlatStyleLike>;
+    /** Z-index for layer ordering */
+    zIndex: _angular_core.InputSignal<number>;
+    /** Opacity (0–1) */
+    opacity: _angular_core.InputSignal<number>;
+    /** Layer visibility */
+    visible: _angular_core.InputSignal<boolean>;
+    /** Disable hit detection for better performance (default: true) */
+    disableHitDetection: _angular_core.InputSignal<boolean>;
+    /** Style variables for dynamic expressions (e.g. `['var', 'threshold']`) */
+    variables: _angular_core.InputSignal<Record<string, string | number | boolean | number[]>>;
+    private layer;
+    private vectorSource;
+    constructor();
+    private syncFeatures;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OlWebGLVectorLayerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OlWebGLVectorLayerComponent, "ol-webgl-vector-layer", never, { "id": { "alias": "id"; "required": true; "isSignal": true; }; "features": { "alias": "features"; "required": false; "isSignal": true; }; "flatStyle": { "alias": "flatStyle"; "required": true; "isSignal": true; }; "zIndex": { "alias": "zIndex"; "required": false; "isSignal": true; }; "opacity": { "alias": "opacity"; "required": false; "isSignal": true; }; "visible": { "alias": "visible"; "required": false; "isSignal": true; }; "disableHitDetection": { "alias": "disableHitDetection"; "required": false; "isSignal": true; }; "variables": { "alias": "variables"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
-interface ImageSourceConfig {
-    type: 'wms' | 'static';
-    url: string;
-    params?: Record<string, unknown>;
-    imageExtent?: Extent;
+
+/**
+ * GPU-accelerated tile layer with color/brightness/contrast expressions.
+ *
+ * Supports the same tile sources as `ol-tile-layer` but renders via WebGL,
+ * enabling GPU-powered color manipulation (brightness, contrast, saturation, gamma).
+ *
+ * @usageNotes
+ * ```html
+ * <ol-webgl-tile-layer
+ *   id="satellite-webgl"
+ *   source="xyz"
+ *   [url]="'https://server.arcgisonline.com/.../{z}/{y}/{x}'"
+ *   [tileStyle]="{ brightness: 0.1, contrast: 0.2 }">
+ * </ol-webgl-tile-layer>
+ * ```
+ */
+declare class OlWebGLTileLayerComponent {
+    private mapService;
+    private destroyRef;
+    /** Unique layer identifier */
+    id: _angular_core.InputSignal<string>;
+    /** Tile source type */
+    source: _angular_core.InputSignal<"osm" | "xyz" | "mvt">;
+    /** Tile URL template (required for 'xyz' and 'mvt') */
+    url: _angular_core.InputSignal<string>;
+    /** Attribution text */
+    attributions: _angular_core.InputSignal<string | string[]>;
+    /** WebGL tile style (raster expressions) or flat style (MVT) */
+    tileStyle: _angular_core.InputSignal<FlatStyleLike | Style$1>;
+    /** Z-index for layer ordering */
+    zIndex: _angular_core.InputSignal<number>;
+    /** Opacity (0–1) */
+    opacity: _angular_core.InputSignal<number>;
+    /** Layer visibility */
+    visible: _angular_core.InputSignal<boolean>;
+    /** Preload low-res tiles up to this many zoom levels */
+    preload: _angular_core.InputSignal<number>;
+    private layer;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OlWebGLTileLayerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OlWebGLTileLayerComponent, "ol-webgl-tile-layer", never, { "id": { "alias": "id"; "required": true; "isSignal": true; }; "source": { "alias": "source"; "required": true; "isSignal": true; }; "url": { "alias": "url"; "required": false; "isSignal": true; }; "attributions": { "alias": "attributions"; "required": false; "isSignal": true; }; "tileStyle": { "alias": "tileStyle"; "required": false; "isSignal": true; }; "zIndex": { "alias": "zIndex"; "required": false; "isSignal": true; }; "opacity": { "alias": "opacity"; "required": false; "isSignal": true; }; "visible": { "alias": "visible"; "required": false; "isSignal": true; }; "preload": { "alias": "preload"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 interface LayerInfo {
     id: string;
-    type: 'vector' | 'tile' | 'image';
+    type: 'vector' | 'tile' | 'image' | 'heatmap';
     visible: boolean;
     opacity: number;
     zIndex: number;
@@ -96,7 +249,7 @@ declare class OlLayerService {
     readonly visibleLayers: _angular_core.Signal<LayerInfo[]>;
     readonly tileLayers: _angular_core.Signal<LayerInfo[]>;
     readonly vectorLayers: _angular_core.Signal<LayerInfo[]>;
-    addLayer(config: LayerConfig): {
+    addLayer(config: AnyLayerConfig): {
         id: string;
     };
     private flushPending;
@@ -108,6 +261,11 @@ declare class OlLayerService {
     toggleVisibility(id: string): boolean;
     setOpacity(id: string, opacity: number): void;
     setZIndex(id: string, zIndex: number): void;
+    setHeatmapProperties(id: string, props: {
+        blur?: number;
+        radius?: number;
+        weight?: string | ((feature: any) => number);
+    }): void;
     isVisible(id: string): boolean;
     getOpacity(id: string): number;
     getZIndex(id: string): number;
@@ -126,6 +284,7 @@ declare class OlLayerService {
     updateFeatures(id: string, features: VectorLayerConfig['features']): void;
     private updateLayerState;
     private createVectorLayer;
+    private createHeatmapLayer;
     private createTileLayer;
     private createImageLayer;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<OlLayerService, never>;
@@ -135,5 +294,5 @@ declare class OlLayerService {
 declare function withLayers(): OlFeature<'layers'>;
 declare function provideLayers(): OlFeature<'layers'>;
 
-export { OlImageLayerComponent, OlLayerService, OlTileLayerComponent, OlVectorLayerComponent, provideLayers, withLayers };
-export type { ImageLayerConfig, ImageSourceConfig, LayerConfig, LayerInfo, SourceConfig, TileLayerConfig, VectorLayerConfig };
+export { OlClusterComponent, OlHeatmapLayerComponent, OlImageLayerComponent, OlLayerService, OlTileLayerComponent, OlVectorLayerComponent, OlWebGLTileLayerComponent, OlWebGLVectorLayerComponent, provideLayers, withLayers };
+export type { HeatmapLayerConfig, ImageLayerConfig, ImageSourceConfig, LayerConfig, LayerInfo, SourceConfig, TileLayerConfig, VectorLayerConfig };

package/types/angular-helpers-openlayers-military.d.ts

@@ -1,33 +1,177 @@
-import { Coordinate, Feature, OlFeature } from '@angular-helpers/openlayers/core';
 import * as i0 from '@angular/core';
+import { Coordinate, EllipseConfig, Feature, SectorConfig, DonutConfig, OlFeature } from '@angular-helpers/openlayers/core';
+import { Style } from 'ol/style';
+import { Feature as Feature$1 } from 'ol';
 
-interface EllipseConfig {
-    center: Coordinate;
-    semiMajor: number;
-    semiMinor: number;
-    rotation?: number;
-}
-interface SectorConfig {
-    center: Coordinate;
-    radius: number;
-    startAngle: number;
-    endAngle: number;
-}
+/**
+ * Subset of `milsymbol`'s `SymbolOptions` exposed by this package.
+ * `sidc` is the only required field; everything else is optional and
+ * forwarded verbatim to `new Symbol(sidc, options)`.
+ */
 interface MilSymbolConfig {
+    /** MIL-STD-2525 SIDC code. Required. */
     sidc: string;
+    /** Symbol position as `[lon, lat]` in EPSG:4326. Required. */
     position: Coordinate;
+    /** Symbol size in pixels. Default (set by `milsymbol`): 30. */
+    size?: number;
+    /** Mono-color override (e.g. `'#000'`). */
+    monoColor?: string;
+    /** Outline color. */
+    outlineColor?: string;
+    /** Icon (interior glyph) color. */
+    iconColor?: string;
+    /** Additional information field (top of the symbol). */
+    additionalInformation?: string;
+    /** Staff comments field. */
+    staffComments?: string;
+    /** Quantity field. */
+    quantity?: number;
+    /** Unique designation field (unit identifier). */
+    uniqueDesignation?: string;
+    /** Custom feature properties merged into the output feature's `properties`. */
+    properties?: Record<string, unknown>;
+}
+/**
+ * Result of resolving a `MilSymbolConfig` against `milsymbol`. Embedded
+ * into the output feature's `style.icon` so that `<ol-vector-layer>` can
+ * render it as an `ol/style/Icon`.
+ */
+interface MilSymbolStyleResult {
+    /** `data:image/svg+xml;base64,...` URL produced from `Symbol.asSVG()`. */
+    src: string;
+    /** Pixel `[width, height]` from `Symbol.getSize()`. */
+    size: [number, number];
+    /**
+     * Anchor in fractional coordinates `[x, y]` (0..1), computed from
+     * `Symbol.getAnchor()` divided by the size. `[0.5, 0.5]` centers the
+     * icon on the feature.
+     */
+    anchor: [number, number];
 }
 
+/**
+ * Service exposing geometry helpers and MIL-STD-2525 symbology rendering.
+ *
+ * - `createEllipse`, `createSector`, `createDonut` are **pure math** and
+ *   delegate to {@link OlGeometryService} in core.
+ * - `createMilSymbol` uses the milsymbol library via Angular resource loading.
+ */
 declare class OlMilitaryService {
+    private idCounter;
+    private geometryService;
+    /**
+     * Resource managing the lazy-loading of the milsymbol library.
+     * Angular resource provides native signals for value, loading state, and errors.
+     */
+    private readonly msResource;
+    /** Signal indicating if the milsymbol library is currently being loaded. */
+    readonly isLoading: i0.Signal<boolean>;
+    constructor();
+    /**
+     * Build a `Feature<Polygon>` approximating an ellipse centered at
+     * `config.center`. See {@link EllipseConfig} for parameter semantics.
+     */
     createEllipse(config: EllipseConfig): Feature;
+    /**
+     * Build a `Feature<Polygon>` for a circular sector (pie slice).
+     * See {@link SectorConfig} for parameter semantics.
+     */
     createSector(config: SectorConfig): Feature;
-    addMilSymbol(config: MilSymbolConfig): Feature;
+    /**
+     * Build a `Feature<Polygon>` for a donut (annular ring).
+     */
+    createDonut(config: DonutConfig): Feature;
+    /**
+     * Pre-load the optional `milsymbol` peer dependency.
+     * Since resource() starts loading immediately, this simply returns a promise
+     * that resolves when the resource is ready.
+     */
+    preloadMilsymbol(): Promise<void>;
+    /**
+     * Build a MIL-STD-2525 symbol feature asynchronously.
+     * Waits for the milsymbol resource to resolve.
+     */
+    createMilSymbol(config: MilSymbolConfig): Promise<Feature>;
+    /**
+     * Build a MIL-STD-2525 symbol feature synchronously.
+     * Throws if `milsymbol` resource is not ready.
+     */
+    createMilSymbolSync(config: MilSymbolConfig): Feature;
+    private nextId;
+    private buildSymbolFeature;
+    private symbolToStyleResult;
+    private encodeBase64Utf8;
+    /**
+     * Generates a canvas and anchor for a MIL-STD-2525 symbol.
+     * Requires milsymbol to be loaded (synchronous).
+     */
+    createUnitStyle(sidc: string, selected?: boolean, size?: number): {
+        image: {
+            img: HTMLCanvasElement;
+            size: [number, number];
+            anchor: [number, number];
+        };
+        zIndex: number;
+    } | null;
+    private assertSidc;
+    private assertBrowser;
     static ɵfac: i0.ɵɵFactoryDeclaration<OlMilitaryService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<OlMilitaryService>;
 }
 
+/**
+ * Service providing styles and geometry generators for military tactical graphics
+ * such as battle fronts, axes of attack, and boundaries.
+ *
+ * NOTE: For point symbols (units), it delegates to {@link OlMilitaryService}
+ * for lazy-loading `milsymbol`.
+ */
+declare class OlTacticalGraphicsService {
+    private idCounter;
+    private militaryService;
+    /**
+     * Creates a LineString feature representing a battle front.
+     */
+    createFrontLine(coordinates: Coordinate[], direction?: 'friendly' | 'hostile'): Feature;
+    /**
+     * Creates a LineString feature representing an attack arrow.
+     */
+    createAttackArrow(coordinates: Coordinate[], direction?: 'friendly' | 'hostile'): Feature;
+    /**
+     * Creates a Polygon feature representing a control zone.
+     */
+    createControlZone(coordinates: Coordinate[][], direction?: 'friendly' | 'hostile'): Feature;
+    /**
+     * Creates a Point feature representing a military unit.
+     * @param sidc - Symbol Identification Code (MIL-STD-2525 / APP-6)
+     */
+    createUnit(coordinate: Coordinate, sidc: string, name: string): Feature;
+    private nextId;
+    /**
+     * Style for Troop Units using milsymbol.
+     * NOTE: Requires milsymbol to be pre-loaded via OlMilitaryService.
+     */
+    createUnitStyle(sidc: string, selected?: boolean): Style | null;
+    /**
+     * Style for Battle Fronts (Complex LineString with teeth).
+     */
+    createFrontLineStyle(color: string, direction?: 'friendly' | 'hostile'): (feature: Feature$1, resolution: number) => Style[];
+    /**
+     * Style for Troop Movements (Arrows).
+     */
+    createAttackArrowStyle(color: string): (feature: Feature$1) => Style[];
+    /**
+     * Style for Control Zones (Polygons).
+     */
+    createZoneStyle(color: string, opacity?: number): Style;
+    private hexToRgba;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OlTacticalGraphicsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OlTacticalGraphicsService>;
+}
+
 declare function withMilitary(): OlFeature<'military'>;
 declare function provideMilitary(): OlFeature<'military'>;
 
-export { OlMilitaryService, provideMilitary, withMilitary };
-export type { EllipseConfig, MilSymbolConfig, SectorConfig };
+export { OlMilitaryService, OlTacticalGraphicsService, provideMilitary, withMilitary };
+export type { MilSymbolConfig, MilSymbolStyleResult };