jmapcloud-ng-core-types 2.0.15-qa.6 → 2.0.15-qa.8

package/index.d.ts

@@ -4,6 +4,7 @@ import { JAttribute, JDataSource, JDataSourceType, JForm, JRelationship } from "
 import type * as maplibregl from "maplibre-gl"
 import { Action, Store } from "redux"
 import { JDataSourceData, JDataSourceDataParams, JDataSourcePermissions } from "./public/jmap/datasource.ts"
+import type { JDrawEventModule, JDrawService } from "./public/jmap/draw.d.ts"
 import type { JCoreState, JMapLegendMode } from "./public/state.d.ts"
 
 export type { JCoreOptions } from "./public/jmap/startup-options.d.ts"
@@ -24,6 +25,28 @@ export type {
   JUIState,
   JUserState
 } from "./public/state.d.ts"
+export type {
+  JDrawArmedChangedReason,
+  JDrawArmedEventChannel,
+  JDrawArmedEventParams,
+  JDrawArmOptions,
+  JDrawEventModule,
+  JDrawEventParams,
+  JDrawFeature,
+  JDrawFeatureEventChannel,
+  JDrawFeatureId,
+  JDrawFeaturePatch,
+  JDrawListenerOptions,
+  JDrawMode,
+  JDrawModeEventChannel,
+  JDrawModeEventParams,
+  JDrawProperties,
+  JDrawRegisterOptions,
+  JDrawService,
+  JDrawShape,
+  JDrawSnapping,
+  JDrawStyle
+} from "./public/jmap/draw.d.ts"
 export type { JAppConfirmMessage, JAppMessage, JAppMessageOptions, JAppMessageService, JAppMessageState, JAppOverlayMessage, JAppRenderableMessage } from "./public/jmap/message.d.ts"
 export type { JAppUserAction } from "./public/jmap/user.d.ts"
 
@@ -52,6 +75,7 @@ export interface JCoreService extends JCoreMainService {
   UI: JUIService
   SimpleSearch: JSimpleSearchService
   DataSource: JDataSourceService
+  Draw: JDrawService
   Table: JTableService
 }
 
@@ -71,7 +95,11 @@ export interface JSimpleSearchService {
 }
 
 export interface JLibraryService {
-  maplibregl(): any
+  /**
+   * Returns the host's maplibre-gl namespace. The namespace is versioned with the host;
+   * a host major version bump is a breaking change through this door.
+   */
+  maplibregl(): typeof import("maplibre-gl")
   html2canvas(): any
 }
 
@@ -228,6 +256,7 @@ export interface JEventService {
   User: JUserEventModule
   Feature: JFeatureEventModule
   Extension: JExtensionEventModule
+  Draw: JDrawEventModule
   MouseOver: JMouseOverEventModule
   MapContext: JMapContextEventModule
   Server: JServerEventModule

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jmapcloud-ng-core-types",
-  "version": "2.0.15-qa.6",
+  "version": "2.0.15-qa.8",
   "description": "JMap Cloud specific version of JMap Cloud NG Core types and interfaces",
   "main": "index.js",
   "types": "ambient.d.ts",
@@ -34,7 +34,7 @@
     "@types/geojson": "^7946.0.14",
     "geojson": "^0.5.0",
     "jmapcloud-types": "../packages/jmapcloud-types",
-    "maplibre-gl": "^4.7.1",
+    "maplibre-gl": "^6.4.0",
     "redux": "^5.0.1"
   }
 }

package/public/core.d.ts

@@ -4,6 +4,20 @@ import type { JRequestConfig } from "./jmap/ajax.d.ts"
 import type { JAttachment, JAttachmentFile, JCreateAttachmentParams, JUpdateAttachmentParams } from "./jmap/attachment.d.ts"
 import type { JDataSourceData, JDataSourceDataParams, JDataSourcePermissions } from "./jmap/datasource.ts"
 import type { JDateFormatParams, JDateLike, JTIME_UNITS } from "./jmap/date.d.ts"
+import type {
+  JDrawArmedEventParams,
+  JDrawArmOptions,
+  JDrawEventParams,
+  JDrawFeature,
+  JDrawFeatureId,
+  JDrawFeaturePatch,
+  JDrawListenerOptions,
+  JDrawMode,
+  JDrawModeEventParams,
+  JDrawRegisterOptions,
+  JDrawSnapping,
+  JDrawStyle
+} from "./jmap/draw.d.ts"
 import type { JCoreExtension, JExtensionEventParams, JExtensionMouseOver } from "./jmap/extension.d.ts"
 import type {
   JAttributeValueByName,
@@ -7032,6 +7046,325 @@ export namespace JMap {
      */
     function getInvalidQueryStringCharacters(): string
   }
+  /**
+   * **JMap.Draw**
+   *
+   * Owner-scoped drawing primitives for applications and extensions. Each consumer registers
+   * an owner before adding features or arming an interactive mode. Features are plain GeoJSON
+   * tagged with `properties.owner` and `properties.shape`; drawing-engine bookkeeping is never
+   * exposed.
+   *
+   * Only one owner is interactive at a time. Completed features from every registered owner
+   * remain rendered while Draw is disarmed or another owner is armed.
+   *
+   * @example
+   * ```ts
+   * JMap.Draw.register("analysis-mask", {
+   *   style: {
+   *     fillColor: "#ff0066",
+   *     fillOpacity: 0.2,
+   *     strokeColor: "#ff0066",
+   *     strokeWidth: 2
+   *   }
+   * })
+   * JMap.Event.Draw.featureCreated.on(
+   *   "analysis-mask-created",
+   *   ({ features }) => console.log(features[0]),
+   *   { owner: "analysis-mask" }
+   * )
+   * JMap.Draw.arm({ owner: "analysis-mask", mode: "polygon" })
+   * ```
+   */
+  namespace Draw {
+    /**
+     * **JMap.Draw.register**
+     *
+     * Registers a non-empty, unique owner and its default style and snapping options.
+     * Registration persists across map changes.
+     *
+     * @param owner Unique owner id used to scope features and events.
+     * @param options Default rendering style and optional snapping configuration.
+     * @throws If the owner is empty or already registered, or if no style object is supplied.
+     * @example
+     * ```ts
+     * JMap.Draw.register("analysis-mask", {
+     *   style: {
+     *     fillColor: "#ff0066",
+     *     fillOpacity: 0.2,
+     *     strokeColor: "#ff0066",
+     *     strokeWidth: 2
+     *   },
+     *   snapping: { enabled: true, toDrawFeatures: true }
+     * })
+     * ```
+     */
+    function register(owner: string, options: JDrawRegisterOptions): void
+    /**
+     * **JMap.Draw.unregister**
+     *
+     * Unregisters an owner and deletes all of its Draw features.
+     *
+     * @param owner Registered owner id.
+     * @throws If the owner is armed or is not registered.
+     * @example
+     * ```ts
+     * JMap.Draw.unregister("analysis-mask")
+     * ```
+     */
+    function unregister(owner: string): void
+    /**
+     * **JMap.Draw.arm**
+     *
+     * Makes an owner interactive in a drawing or selection mode. Draw temporarily takes map
+     * interaction ownership and restores the previous interactor when the final arm is disarmed.
+     * Arming another owner suspends the current Draw arm on the internal arm stack.
+     *
+     * Keyboard handling is enabled by default. Set `keyboard: false` when the consumer owns
+     * Escape/Delete handling itself.
+     *
+     * @param options Registered owner, mode, optional per-arm style overrides, and keyboard flag.
+     * @throws If the owner is not registered, the mode is invalid, or Draw has no active map.
+     * @example
+     * ```ts
+     * // Let the user draw a polygon with keyboard cancellation enabled.
+     * JMap.Draw.arm({ owner: "analysis-mask", mode: "polygon" })
+     * ```
+     */
+    function arm(options: JDrawArmOptions): void
+    /**
+     * **JMap.Draw.disarm**
+     *
+     * Cancels any provisional feature and disarms the active owner. If a previous Draw arm was
+     * suspended, it is restored; otherwise the map's previous interactor and handlers are restored.
+     * Does nothing when Draw is not armed.
+     *
+     * @example
+     * ```ts
+     * JMap.Draw.disarm()
+     * ```
+     */
+    function disarm(): void
+    /**
+     * **JMap.Draw.isArmed**
+     *
+     * Returns whether Draw is currently armed. If an owner is supplied, returns true only when
+     * that owner is the active owner.
+     *
+     * @param owner Optional registered owner id to test.
+     * @example
+     * ```ts
+     * const isMaskToolActive = JMap.Draw.isArmed("analysis-mask")
+     * ```
+     */
+    function isArmed(owner?: string): boolean
+    /**
+     * **JMap.Draw.getMode**
+     *
+     * Returns the active public Draw mode, or `undefined` while Draw is disarmed.
+     *
+     * @example
+     * ```ts
+     * console.log(JMap.Draw.getMode()) // "polygon"
+     * ```
+     */
+    function getMode(): JDrawMode | undefined
+    /**
+     * **JMap.Draw.getFeatures**
+     *
+     * Returns a snapshot of all completed and provisional Draw features belonging to an owner.
+     *
+     * @param owner Registered owner id.
+     * @throws If the owner is not registered.
+     * @example
+     * ```ts
+     * const masks = JMap.Draw.getFeatures("analysis-mask")
+     * console.log(masks[0].geometry)
+     * ```
+     */
+    function getFeatures(owner: string): JDrawFeature[]
+    /**
+     * **JMap.Draw.addFeatures**
+     *
+     * Adds plain GeoJSON features to Draw. Each feature's owner must already be registered and
+     * its geometry must match its declared shape. A missing feature id is generated by Draw.
+     * Added features emit `JMap.Event.Draw.featureCreated` grouped by owner.
+     *
+     * @param features Features to add.
+     * @throws If an owner is not registered or a feature is invalid.
+     * @example
+     * ```ts
+     * JMap.Draw.addFeatures([
+     *   {
+     *     type: "Feature",
+     *     id: "mask-1",
+     *     geometry: {
+     *       type: "Polygon",
+     *       coordinates: [[[-73.62, 45.5], [-73.6, 45.5], [-73.6, 45.52], [-73.62, 45.5]]]
+     *     },
+     *     properties: { owner: "analysis-mask", shape: "polygon" }
+     *   }
+     * ])
+     * ```
+     */
+    function addFeatures(features: JDrawFeature[]): void
+    /**
+     * **JMap.Draw.setFeatures**
+     *
+     * Replaces all features belonging to an owner. Every replacement feature must carry the
+     * same owner id.
+     *
+     * @param owner Registered owner id.
+     * @param features Complete replacement feature set for the owner.
+     * @throws If the owner is not registered or a feature belongs to another owner.
+     * @example
+     * ```ts
+     * JMap.Draw.setFeatures("analysis-mask", [
+     *   {
+     *     type: "Feature",
+     *     id: "mask-center",
+     *     geometry: { type: "Point", coordinates: [-73.61, 45.51] },
+     *     properties: { owner: "analysis-mask", shape: "point" }
+     *   }
+     * ])
+     * ```
+     */
+    function setFeatures(owner: string, features: JDrawFeature[]): void
+    /**
+     * **JMap.Draw.updateFeature**
+     *
+     * Updates a feature's geometry and/or consumer properties, then emits
+     * `JMap.Event.Draw.featureUpdated`. The routing properties `owner` and `shape`, and the
+     * drawing engine's reserved properties, cannot be changed.
+     *
+     * @param id Feature id.
+     * @param patch Geometry and/or property changes.
+     * @throws If the feature is missing or the patch contains reserved properties.
+     * @example
+     * ```ts
+     * JMap.Draw.updateFeature("mask-1", {
+     *   properties: { fillColor: "#3366ff", fillOpacity: 0.35 }
+     * })
+     * ```
+     */
+    function updateFeature(id: JDrawFeatureId, patch: JDrawFeaturePatch): void
+    /**
+     * **JMap.Draw.deleteFeatures**
+     *
+     * Deletes features by id and emits `JMap.Event.Draw.featureDeleted` grouped by owner.
+     * This mutation also works during the map teardown gap, using Draw's cached snapshot.
+     *
+     * @param ids Feature ids to delete.
+     * @throws If any feature id is unknown.
+     * @example
+     * ```ts
+     * JMap.Draw.deleteFeatures(["mask-1", "mask-2"])
+     * ```
+     */
+    function deleteFeatures(ids: JDrawFeatureId[]): void
+    /**
+     * **JMap.Draw.deleteAll**
+     *
+     * Deletes every feature belonging to an owner.
+     *
+     * @param owner Registered owner id.
+     * @throws If the owner is not registered.
+     * @example
+     * ```ts
+     * JMap.Draw.deleteAll("analysis-mask")
+     * ```
+     */
+    function deleteAll(owner: string): void
+    /**
+     * **JMap.Draw.select**
+     *
+     * Selects features for editing. Draw must be armed in `select` mode, and every feature must
+     * belong to the active owner.
+     *
+     * @param ids Feature ids to select.
+     * @throws If select mode is not armed, a feature is missing, or a feature belongs to another owner.
+     * @example
+     * ```ts
+     * JMap.Draw.arm({ owner: "analysis-mask", mode: "select" })
+     * JMap.Draw.select(["mask-1"])
+     * ```
+     */
+    function select(ids: JDrawFeatureId[]): void
+    /**
+     * **JMap.Draw.deselect**
+     *
+     * Clears the current Draw selection and emits `JMap.Event.Draw.selectionChanged` with an
+     * empty feature array. Does nothing while Draw is disarmed.
+     *
+     * @example
+     * ```ts
+     * JMap.Draw.deselect()
+     * ```
+     */
+    function deselect(): void
+    /**
+     * **JMap.Draw.getSelected**
+     *
+     * Returns a snapshot of the currently selected Draw features. Returns an empty array when
+     * there is no active map or selection.
+     *
+     * @example
+     * ```ts
+     * const selectedMasks = JMap.Draw.getSelected()
+     * ```
+     */
+    function getSelected(): JDrawFeature[]
+    /**
+     * **JMap.Draw.setStyle**
+     *
+     * Merges style changes into an owner's default style and refreshes that owner's rendering.
+     * Per-feature style properties continue to override owner defaults.
+     *
+     * @param owner Registered owner id.
+     * @param style Partial style to merge into the owner's defaults.
+     * @throws If the owner is not registered.
+     * @example
+     * ```ts
+     * JMap.Draw.setStyle("analysis-mask", {
+     *   fillColor: "#3366ff",
+     *   strokeColor: "#003399"
+     * })
+     * ```
+     */
+    function setStyle(owner: string, style: Partial<JDrawStyle>): void
+    /**
+     * **JMap.Draw.setSnapping**
+     *
+     * Merges snapping changes into an owner's configuration and refreshes the shared snapping
+     * candidate cache.
+     *
+     * @param owner Registered owner id.
+     * @param snapping Partial snapping configuration.
+     * @throws If the owner is not registered.
+     * @example
+     * ```ts
+     * JMap.Draw.setSnapping("analysis-mask", {
+     *   enabled: true,
+     *   toDrawFeatures: true,
+     *   toLayers: ["roads"],
+     *   tolerancePx: 20
+     * })
+     * ```
+     */
+    function setSnapping(owner: string, snapping: Partial<JDrawSnapping>): void
+    /**
+     * **JMap.Draw.cancel**
+     *
+     * Cancels the provisional feature, if one is being drawn, and emits
+     * `JMap.Event.Draw.drawingCancelled`. The active owner remains armed in the same mode.
+     *
+     * @example
+     * ```ts
+     * // Abandon the current polygon but keep polygon drawing active.
+     * JMap.Draw.cancel()
+     * ```
+     */
+    function cancel(): void
+  }
   /**
    * **JMap.Event**
    *
@@ -7054,6 +7387,200 @@ export namespace JMap {
    * Deactivating a listener keep it in the JMap Cloud NG Core library, but ignore it when an event is emitted.
    */
   namespace Event {
+    /**
+     * ***JMap.Event.Draw***
+     *
+     * Draw lifecycle and feature events. Register listeners through each channel's `on` method.
+     * The optional `{ owner }` filter limits delivery to one Draw owner. Listener ids should be
+     * unique across Draw channels because activation, deactivation, and removal operate by id.
+     */
+    namespace Draw {
+      /** Emitted after an interactive feature is completed or features are added through the API. */
+      namespace featureCreated {
+        /**
+         * Registers a feature-created listener.
+         *
+         * @param listenerId Non-empty listener id.
+         * @param fn Listener receiving the event owner and created features.
+         * @param options Optional owner filter.
+         * @example
+         * ```ts
+         * JMap.Event.Draw.featureCreated.on(
+         *   "mask-created",
+         *   ({ features }) => console.log("Created", features),
+         *   { owner: "analysis-mask" }
+         * )
+         * ```
+         */
+        function on(listenerId: string, fn: (params: JDrawEventParams) => void, options?: JDrawListenerOptions): void
+      }
+      /** Emitted after a selected feature edit or a call to `JMap.Draw.updateFeature`. */
+      namespace featureUpdated {
+        /**
+         * Registers a feature-updated listener.
+         *
+         * @param listenerId Non-empty listener id.
+         * @param fn Listener receiving the event owner and updated features.
+         * @param options Optional owner filter.
+         * @example
+         * ```ts
+         * JMap.Event.Draw.featureUpdated.on(
+         *   "mask-updated",
+         *   ({ features }) => console.log("Updated", features),
+         *   { owner: "analysis-mask" }
+         * )
+         * ```
+         */
+        function on(listenerId: string, fn: (params: JDrawEventParams) => void, options?: JDrawListenerOptions): void
+      }
+      /** Emitted after Draw features are deleted. */
+      namespace featureDeleted {
+        /**
+         * Registers a feature-deleted listener.
+         *
+         * @param listenerId Non-empty listener id.
+         * @param fn Listener receiving the event owner and deleted feature snapshots.
+         * @param options Optional owner filter.
+         * @example
+         * ```ts
+         * JMap.Event.Draw.featureDeleted.on(
+         *   "mask-deleted",
+         *   ({ features }) => console.log("Deleted ids", features.map(feature => feature.id)),
+         *   { owner: "analysis-mask" }
+         * )
+         * ```
+         */
+        function on(listenerId: string, fn: (params: JDrawEventParams) => void, options?: JDrawListenerOptions): void
+      }
+      /** Emitted when the active owner's feature selection changes. */
+      namespace selectionChanged {
+        /**
+         * Registers a selection-changed listener.
+         *
+         * @param listenerId Non-empty listener id.
+         * @param fn Listener receiving the event owner and complete selected feature snapshot.
+         * @param options Optional owner filter.
+         * @example
+         * ```ts
+         * JMap.Event.Draw.selectionChanged.on(
+         *   "mask-selection",
+         *   ({ features }) => console.log("Selected ids", features.map(feature => feature.id)),
+         *   { owner: "analysis-mask" }
+         * )
+         * ```
+         */
+        function on(listenerId: string, fn: (params: JDrawEventParams) => void, options?: JDrawListenerOptions): void
+      }
+      /** Emitted when an owner's active drawing or selection mode changes. */
+      namespace modeChanged {
+        /**
+         * Registers a mode-changed listener.
+         *
+         * @param listenerId Non-empty listener id.
+         * @param fn Listener receiving the event owner and active mode.
+         * @param options Optional owner filter.
+         * @example
+         * ```ts
+         * JMap.Event.Draw.modeChanged.on(
+         *   "mask-mode",
+         *   ({ mode }) => console.log("Active mode", mode),
+         *   { owner: "analysis-mask" }
+         * )
+         * ```
+         */
+        function on(listenerId: string, fn: (params: JDrawModeEventParams) => void, options?: JDrawListenerOptions): void
+      }
+      /**
+       * Emitted when an owner is armed or disarmed. The reason distinguishes an explicit
+       * `disarm`, external `preempted` interaction, stack `restored` arm, and `mapChanged` teardown.
+       */
+      namespace armedChanged {
+        /**
+         * Registers an armed-state listener.
+         *
+         * @param listenerId Non-empty listener id.
+         * @param fn Listener receiving the owner, armed state, and transition reason.
+         * @param options Optional owner filter.
+         * @example
+         * ```ts
+         * JMap.Event.Draw.armedChanged.on(
+         *   "mask-armed",
+         *   ({ armed, reason }) => console.log({ armed, reason }),
+         *   { owner: "analysis-mask" }
+         * )
+         * ```
+         */
+        function on(listenerId: string, fn: (params: JDrawArmedEventParams) => void, options?: JDrawListenerOptions): void
+      }
+      /** Emitted with a provisional feature while drawing, throttled to at most once per animation frame. */
+      namespace drawingProgress {
+        /**
+         * Registers a drawing-progress listener.
+         *
+         * @param listenerId Non-empty listener id.
+         * @param fn Listener receiving the owner and provisional feature snapshot.
+         * @param options Optional owner filter.
+         * @example
+         * ```ts
+         * JMap.Event.Draw.drawingProgress.on(
+         *   "mask-progress",
+         *   ({ features }) => console.log("Provisional geometry", features[0].geometry),
+         *   { owner: "analysis-mask" }
+         * )
+         * ```
+         */
+        function on(listenerId: string, fn: (params: JDrawEventParams) => void, options?: JDrawListenerOptions): void
+      }
+      /** Emitted when a provisional feature is cancelled before completion. */
+      namespace drawingCancelled {
+        /**
+         * Registers a drawing-cancelled listener.
+         *
+         * @param listenerId Non-empty listener id.
+         * @param fn Listener receiving the owner and cancelled provisional feature snapshot.
+         * @param options Optional owner filter.
+         * @example
+         * ```ts
+         * JMap.Event.Draw.drawingCancelled.on(
+         *   "mask-cancelled",
+         *   ({ features }) => console.log("Cancelled", features[0]),
+         *   { owner: "analysis-mask" }
+         * )
+         * ```
+         */
+        function on(listenerId: string, fn: (params: JDrawEventParams) => void, options?: JDrawListenerOptions): void
+      }
+      /**
+       * Reactivates every Draw listener carrying the id.
+       *
+       * @param listenerId Listener id.
+       * @example
+       * ```ts
+       * JMap.Event.Draw.activateListener("mask-created")
+       * ```
+       */
+      function activateListener(listenerId: string): void
+      /**
+       * Deactivates every Draw listener carrying the id without removing it.
+       *
+       * @param listenerId Listener id.
+       * @example
+       * ```ts
+       * JMap.Event.Draw.deactivateListener("mask-created")
+       * ```
+       */
+      function deactivateListener(listenerId: string): void
+      /**
+       * Removes every Draw listener carrying the id.
+       *
+       * @param listenerId Listener id.
+       * @example
+       * ```ts
+       * JMap.Event.Draw.removeListener("mask-created")
+       * ```
+       */
+      function removeListener(listenerId: string): void
+    }
     /**
      * ***JMap.Event.Main***
      *
@@ -11094,7 +11621,8 @@ export namespace JMap {
     /**
      * **JMap.Library.maplibregl**
      *
-     * Returns the maplibre-gl library.
+     * Returns the host's maplibre-gl namespace. The namespace is versioned with the host;
+     * a host major version bump is a breaking change through this door.
      *
      * @example
      * ```ts
@@ -11102,7 +11630,7 @@ export namespace JMap {
      * const maplibregl = JMap.Library.maplibregl()
      * ```
      */
-    function maplibregl(): any
+    function maplibregl(): typeof import("maplibre-gl")
     /**
      * **JMap.Library.html2canvas**
      *

package/public/jmap/draw.d.ts

@@ -0,0 +1,127 @@
+import type { Feature, Geometry } from "geojson"
+
+export type JDrawShape = "point" | "linestring" | "polygon" | "rectangle" | "circle" | "freehand" | "text"
+export type JDrawMode = JDrawShape | "select"
+export type JDrawFeatureId = string | number
+
+export interface JDrawProperties {
+  owner: string
+  shape: JDrawShape
+  text?: string
+  textSize?: number
+  textColor?: string
+  textRotation?: number
+  zoomRef?: number
+  [key: string]: unknown
+}
+
+export type JDrawFeature = Feature<Geometry, JDrawProperties>
+
+export interface JDrawStyle {
+  fillColor?: string
+  fillOpacity?: number
+  strokeColor?: string
+  strokeOpacity?: number
+  strokeWidth?: number
+  pointRadius?: number
+  pointOutlineColor?: string
+  pointOutlineWidth?: number
+  vertexActiveColor?: string
+  vertexInactiveColor?: string
+  textColor?: string
+  textRotation?: number
+  textSize?: number
+}
+
+export interface JDrawSnapping {
+  enabled: boolean
+  toDrawFeatures?: boolean
+  toLayers?: string[]
+  tolerancePx?: number
+}
+
+export interface JDrawRegisterOptions {
+  style: JDrawStyle
+  snapping?: JDrawSnapping
+}
+
+export interface JDrawArmOptions {
+  owner: string
+  mode: JDrawMode
+  style?: Partial<JDrawStyle>
+  keyboard?: boolean
+}
+
+export interface JDrawFeaturePatch {
+  properties?: Partial<Omit<JDrawProperties, "owner" | "shape">>
+  geometry?: Geometry
+}
+
+export interface JDrawService {
+  register(owner: string, options: JDrawRegisterOptions): void
+  unregister(owner: string): void
+  arm(options: JDrawArmOptions): void
+  disarm(): void
+  isArmed(owner?: string): boolean
+  getMode(): JDrawMode | undefined
+  getFeatures(owner: string): JDrawFeature[]
+  addFeatures(features: JDrawFeature[]): void
+  setFeatures(owner: string, features: JDrawFeature[]): void
+  updateFeature(id: JDrawFeatureId, patch: JDrawFeaturePatch): void
+  deleteFeatures(ids: JDrawFeatureId[]): void
+  deleteAll(owner: string): void
+  select(ids: JDrawFeatureId[]): void
+  deselect(): void
+  getSelected(): JDrawFeature[]
+  setStyle(owner: string, style: Partial<JDrawStyle>): void
+  setSnapping(owner: string, snapping: Partial<JDrawSnapping>): void
+  cancel(): void
+}
+
+export interface JDrawEventParams {
+  owner: string
+  features: JDrawFeature[]
+}
+
+export type JDrawArmedChangedReason = "disarm" | "preempted" | "restored" | "mapChanged"
+
+export interface JDrawArmedEventParams {
+  owner: string
+  armed: boolean
+  reason: JDrawArmedChangedReason
+}
+
+export interface JDrawModeEventParams {
+  owner: string
+  mode: JDrawMode
+}
+
+export interface JDrawListenerOptions {
+  owner?: string
+}
+
+export interface JDrawFeatureEventChannel {
+  on(listenerId: string, fn: (params: JDrawEventParams) => void, options?: JDrawListenerOptions): void
+}
+
+export interface JDrawModeEventChannel {
+  on(listenerId: string, fn: (params: JDrawModeEventParams) => void, options?: JDrawListenerOptions): void
+}
+
+export interface JDrawArmedEventChannel {
+  on(listenerId: string, fn: (params: JDrawArmedEventParams) => void, options?: JDrawListenerOptions): void
+}
+
+export interface JDrawEventModule {
+  featureCreated: JDrawFeatureEventChannel
+  featureUpdated: JDrawFeatureEventChannel
+  featureDeleted: JDrawFeatureEventChannel
+  selectionChanged: JDrawFeatureEventChannel
+  modeChanged: JDrawModeEventChannel
+  armedChanged: JDrawArmedEventChannel
+  drawingProgress: JDrawFeatureEventChannel
+  drawingCancelled: JDrawFeatureEventChannel
+  activateListener(listenerId: string): void
+  deactivateListener(listenerId: string): void
+  removeListener(listenerId: string): void
+}