@angular-helpers/openlayers 0.4.0 → 0.5.1

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

@@ -1,9 +1,11 @@
 import * as _angular_core from '@angular/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';
+    type: 'vector' | 'tile' | 'image' | 'heatmap';
     extent?: Extent;
     minResolution?: number;
     maxResolution?: number;
@@ -19,13 +21,26 @@ interface ClusterConfig {
     showCount?: boolean;
     /** Style for individual features when clustering */
     featureStyle?: Style;
+    /** Automatically spiderfy overlapping points on click (default: false) */
+    spiderfyOnSelect?: boolean;
+    /** Callback when a spider leg feature is clicked */
+    onSpiderfyClick?: (feature: Feature) => void;
 }
 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;
@@ -46,20 +61,35 @@ interface ImageSourceConfig {
     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>;
+    spiderfyOnSelect: _angular_core.InputSignal<boolean>;
+    spiderfyClick: _angular_core.OutputEmitterRef<Feature>;
+    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; }; "spiderfyOnSelect": { "alias": "spiderfyOnSelect"; "required": false; "isSignal": true; }; }, { "spiderfyClick": "spiderfyClick"; }, 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; }; "cluster": { "alias": "cluster"; "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 {
@@ -94,9 +124,130 @@ 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>;
 }
 
+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>;
+}
+
+/**
+ * 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();
+    /**
+     * Imperatively update style variables without triggering Angular change detection.
+     * Ideal for 60FPS animations (e.g., linked to OlTimeService) where you don't want
+     * to use the declarative [variables] input.
+     */
+    updateVariables(vars: Record<string, string | number | boolean | number[]>): void;
+    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>;
+}
+
+/**
+ * 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;
@@ -106,11 +257,12 @@ declare class OlLayerService {
     private layerCache;
     private pendingConfigs;
     private layerState;
+    private spiderManager;
     readonly layers: _angular_core.Signal<LayerInfo[]>;
     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;
@@ -122,26 +274,19 @@ declare class OlLayerService {
     toggleVisibility(id: string): boolean;
     setOpacity(id: string, opacity: number): void;
     setZIndex(id: string, zIndex: number): void;
+    setClusterDistance(id: string, distance: number): void;
+    setClusterMinDistance(id: string, minDistance: 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;
-    /**
-     * Clears all features from a vector layer's source.
-     * Does not remove the layer itself.
-     * @param id - Layer identifier
-     */
     clearFeatures(id: string): void;
-    /**
-     * Updates the features of a vector layer.
-     * Syncs new features without clearing existing ones (preserves OL modifications).
-     * @param id - Layer identifier
-     * @param features - New features to sync
-     */
     updateFeatures(id: string, features: VectorLayerConfig['features']): void;
     private updateLayerState;
-    private createVectorLayer;
-    private createTileLayer;
-    private createImageLayer;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<OlLayerService, never>;
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<OlLayerService>;
 }
@@ -149,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,78 +1,8 @@
-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';
 
-/**
- * Configuration for an ellipse polygon centered at `center`.
- * Coordinates are emitted in EPSG:4326 (lon/lat) using a local tangent-plane
- * approximation; accuracy degrades for radii > ~100 km or near the poles.
- */
-interface EllipseConfig {
-    /** Ellipse center as `[lon, lat]` in EPSG:4326. */
-    center: Coordinate;
-    /** Semi-major axis in meters. Must be > 0. */
-    semiMajor: number;
-    /** Semi-minor axis in meters. Must be > 0. */
-    semiMinor: number;
-    /**
-     * Rotation in radians, counter-clockwise from East. Default: 0
-     * (semi-major axis points East).
-     */
-    rotation?: number;
-    /**
-     * Number of vertices used to approximate the ellipse. Default: 64.
-     * Minimum: 8.
-     */
-    segments?: number;
-    /** Custom feature properties to attach to the output feature. */
-    properties?: Record<string, unknown>;
-}
-/**
- * Configuration for a circular sector (pie-slice) polygon.
- * Same projection caveats as `EllipseConfig`.
- */
-interface SectorConfig {
-    /** Sector apex / center as `[lon, lat]` in EPSG:4326. */
-    center: Coordinate;
-    /** Sector radius in meters. Must be > 0. */
-    radius: number;
-    /** Start angle in radians (0 = East, CCW positive). */
-    startAngle: number;
-    /**
-     * End angle in radians. Must satisfy `startAngle < endAngle <= startAngle + 2π`.
-     */
-    endAngle: number;
-    /**
-     * Number of vertices along the arc. Default: 32. Minimum: 4. The output
-     * polygon has `segments + 3` vertices (apex + arc + apex closer).
-     */
-    segments?: number;
-    /** Custom feature properties to attach to the output feature. */
-    properties?: Record<string, unknown>;
-}
-/**
- * Configuration for a donut (annular ring) polygon — a disk with a
- * concentric circular hole. Useful for range rings, exclusion zones,
- * and similar GIS military primitives.
- *
- * The output `Feature<Polygon>` has TWO rings: an outer ring (CCW) and
- * an inner ring (CW per the GeoJSON right-hand rule), so renderers that
- * follow the spec fill only the band between the radii.
- */
-interface DonutConfig {
-    /** Donut center as `[lon, lat]` in EPSG:4326. */
-    center: Coordinate;
-    /** Outer radius in meters. Must be > `innerRadius`. */
-    outerRadius: number;
-    /** Inner radius in meters. Must be > 0 and < `outerRadius`. */
-    innerRadius: number;
-    /**
-     * Number of vertices per ring. Default: 64. Minimum: 8. Both rings use
-     * the same segment count.
-     */
-    segments?: number;
-    /** Custom feature properties to attach to the output feature. */
-    properties?: Record<string, unknown>;
-}
 /**
  * Subset of `milsymbol`'s `SymbolOptions` exposed by this package.
  * `sidc` is the only required field; everything else is optional and
@@ -124,13 +54,20 @@ interface MilSymbolStyleResult {
  * Service exposing geometry helpers and MIL-STD-2525 symbology rendering.
  *
  * - `createEllipse`, `createSector`, `createDonut` are **pure math** and
- *   have no runtime dependencies beyond the bundled types.
- * - `createMilSymbol` uses the milsymbol library via dynamic ESM import.
+ *   delegate to {@link OlGeometryService} in core.
+ * - `createMilSymbol` uses the milsymbol library via Angular resource loading.
  */
 declare class OlMilitaryService {
     private idCounter;
-    private mlLoader;
-    private msModule;
+    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.
@@ -142,46 +79,99 @@ declare class OlMilitaryService {
      */
     createSector(config: SectorConfig): Feature;
     /**
-     * Build a `Feature<Polygon>` for a donut (annular ring). The output has
-     * two rings: an outer ring wound counter-clockwise and an inner ring
-     * wound clockwise so the GeoJSON right-hand rule renders the hole.
+     * Build a `Feature<Polygon>` for a donut (annular ring).
      */
     createDonut(config: DonutConfig): Feature;
     /**
-     * Pre-load the optional `milsymbol` peer dependency so subsequent calls
-     * to `createMilSymbol` / `createMilSymbolSync` resolve immediately.
-     * Idempotent — multiple calls share the same promise.
+     * 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.
-     * Lazy-loads `milsymbol` on the first call.
+     * Waits for the milsymbol resource to resolve.
      */
     createMilSymbol(config: MilSymbolConfig): Promise<Feature>;
     /**
      * Build a MIL-STD-2525 symbol feature synchronously.
-     * Throws if `milsymbol` has not been preloaded via `preloadMilsymbol()`
-     * or a previous `createMilSymbol()` call.
+     * Throws if `milsymbol` resource is not ready.
      */
     createMilSymbolSync(config: MilSymbolConfig): Feature;
-    /**
-     * Project an `(dx, dy)` meter offset from `center` to lon/lat using a
-     * local tangent-plane (equirectangular) approximation. Acceptable for
-     * the radii typical in military symbology (<100 km from center).
-     */
-    private offsetMetersToLonLat;
     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 { DonutConfig, EllipseConfig, MilSymbolConfig, MilSymbolStyleResult, SectorConfig };
+export { OlMilitaryService, OlTacticalGraphicsService, provideMilitary, withMilitary };
+export type { MilSymbolConfig, MilSymbolStyleResult };