@zvonimirsun/leaflet-geoman/dist/leaflet-geoman.d.ts

A Leaflet Plugin For Editing Geometry Layers in Leaflet 1.0

import * as L from 'leaflet';

// redeclare module, maintains compatibility with @types/leaflet
declare module 'leaflet' {
  /**
   * Extends built in leaflet Layer Options.
   */
  interface LayerOptions {
    pmIgnore?: boolean;
    snapIgnore?: boolean;
    /** Layers can be excluded from splitting with splitMark: false and splitOnlyMarkedLayers: false. Or included with splitMark: true and splitOnlyMarkedLayers: true. ⭐ */
    splitMark?: boolean;
  }

  /**
   * Extends built in leaflet Map Options.
   */
  interface MapOptions {
    pmIgnore?: boolean;
  }

  /**
   * Extends built in leaflet Map.
   */
  interface Map {
    pm: PM.PMMap;
  }

  /**
   * Extends built in leaflet Path.
   */
  interface Path {
    pm: PM.PMLayer;
  }
  /**
   * Extends built in leaflet ImageOverlay.
   */
  interface ImageOverlay {
    pm: PM.PMLayer;
  }

  /**
   * Extends built in leaflet LayerGroup.
   */
  interface LayerGroup {
    pm: PM.PMLayerGroup;
  }

  /**
   * Extends built in leaflet MarkerOptions with options for Text-Layer
   */
  interface MarkerOptions {
    textMarker?: boolean;
    text?: string;

    /** Centers the text around the marker. ⭐ */
    textMarkerCentered?: boolean;
  }

  /**
   * Extends built in leaflet Marker.
   */
  interface Marker {
    pm: PM.PMLayer;
  }

  /**
   * Extends @types/leaflet events...
   *
   * Todo: This is kind of a mess, and it makes all these event handlers show
   * up on Layers and Map. Leaflet itself is based around Evented, and @types/leaflet
   * makes this very hard to work around.
   *
   */
  interface Evented {
    /******************************************
     *
     * AVAILABLE ON MAP + LAYER, THESE ARE OK ON EVENTED.
     *
     ********************************************/

    /** Fired when a layer is removed via Removal Mode. */
    on(type: 'pm:remove', fn: PM.RemoveEventHandler): this;
    once(type: 'pm:remove', fn: PM.RemoveEventHandler): this;
    off(type: 'pm:remove', fn?: PM.RemoveEventHandler): this;

    /** Fired when the layer being cut. Draw+Edit Mode*/
    on(type: 'pm:cut', fn: PM.CutEventHandler): this;
    once(type: 'pm:cut', fn: PM.CutEventHandler): this;
    off(type: 'pm:cut', fn?: PM.CutEventHandler): this;

    /** Fired when the layer being split. Draw+Edit Mode ⭐*/
    on(type: 'pm:split', fn: PM.SplitEventHandler): this;
    once(type: 'pm:split', fn: PM.SplitEventHandler): this;
    off(type: 'pm:split', fn?: PM.SplitEventHandler): this;

    /** Fired when rotation is enabled for a layer. */
    on(type: 'pm:rotateenable', fn: PM.RotateEnableEventHandler): this;
    once(type: 'pm:rotateenable', fn: PM.RotateEnableEventHandler): this;
    off(type: 'pm:rotateenable', fn?: PM.RotateEnableEventHandler): this;

    /** Fired when rotation is disabled for a layer. */
    on(type: 'pm:rotatedisable', fn: PM.RotateDisableEventHandler): this;
    once(type: 'pm:rotatedisable', fn: PM.RotateDisableEventHandler): this;
    off(type: 'pm:rotatedisable', fn?: PM.RotateDisableEventHandler): this;

    /** Fired when rotation starts on a layer. */
    on(type: 'pm:rotatestart', fn: PM.RotateStartEventHandler): this;
    once(type: 'pm:rotatestart', fn: PM.RotateStartEventHandler): this;
    off(type: 'pm:rotatestart', fn?: PM.RotateStartEventHandler): this;

    /** Fired when a layer is rotated. */
    on(type: 'pm:rotate', fn: PM.RotateEventHandler): this;
    once(type: 'pm:rotate', fn: PM.RotateEventHandler): this;
    off(type: 'pm:rotate', fn?: PM.RotateEventHandler): this;

    /** Fired when rotation ends on a layer. */
    on(type: 'pm:rotateend', fn: PM.RotateEndEventHandler): this;
    once(type: 'pm:rotateend', fn: PM.RotateEndEventHandler): this;
    off(type: 'pm:rotateend', fn?: PM.RotateEndEventHandler): this;

    /** Fired when scaling is enabled for a layer. */
    on(type: 'pm:scaleenable', fn: PM.ScaleEnableEventHandler): this;
    once(type: 'pm:scaleenable', fn: PM.ScaleEnableEventHandler): this;
    off(type: 'pm:scaleenable', fn?: PM.ScaleEnableEventHandler): this;

    /** Fired when scaling is disabled for a layer. */
    on(type: 'pm:scaledisable', fn: PM.ScaleDisableEventHandler): this;
    once(type: 'pm:scaledisable', fn: PM.ScaleDisableEventHandler): this;
    off(type: 'pm:scaledisable', fn?: PM.ScaleDisableEventHandler): this;

    /** Fired when scaling starts on a layer. */
    on(type: 'pm:scalestart', fn: PM.ScaleStartEventHandler): this;
    once(type: 'pm:scalestart', fn: PM.ScaleStartEventHandler): this;
    off(type: 'pm:scalestart', fn?: PM.ScaleStartEventHandler): this;

    /** Fired when a layer is scaled. */
    on(type: 'pm:scale', fn: PM.ScaleEventHandler): this;
    once(type: 'pm:scale', fn: PM.ScaleEventHandler): this;
    off(type: 'pm:scale', fn?: PM.ScaleEventHandler): this;

    /** Fired when scaling ends on a layer. */
    on(type: 'pm:scaleend', fn: PM.ScaleEndEventHandler): this;
    once(type: 'pm:scaleend', fn: PM.ScaleEndEventHandler): this;
    off(type: 'pm:scaleend', fn?: PM.ScaleEndEventHandler): this;

    /******************************************
     *
     * TODO: DRAW/EDIT MODE EVENTS LAYER ONLY
     *
     ********************************************/

    /** Fired during a marker move/drag. */
    on(type: 'pm:snapdrag', fn: PM.SnapEventHandler): this;
    once(type: 'pm:snapdrag', fn: PM.SnapEventHandler): this;
    off(type: 'pm:snapdrag', fn?: PM.SnapEventHandler): this;

    /** Fired when a vertex is snapped. */
    on(type: 'pm:snap', fn: PM.SnapEventHandler): this;
    once(type: 'pm:snap', fn: PM.SnapEventHandler): this;
    off(type: 'pm:snap', fn?: PM.SnapEventHandler): this;

    /** Fired when a vertex is unsnapped. */
    on(type: 'pm:unsnap', fn: PM.SnapEventHandler): this;
    once(type: 'pm:unsnap', fn: PM.SnapEventHandler): this;
    off(type: 'pm:unsnap', fn?: PM.SnapEventHandler): this;

    /** Called when the center of a circle is placed/moved. */
    on(type: 'pm:centerplaced', fn: PM.CenterPlacedEventHandler): this;
    once(type: 'pm:centerplaced', fn: PM.CenterPlacedEventHandler): this;
    off(type: 'pm:centerplaced', fn?: PM.CenterPlacedEventHandler): this;

    /******************************************
     *
     * TODO: CUT/EDIT MODE EVENTS LAYER ONLY
     *
     ********************************************/

    /** Fired when a layer is edited. */
    on(type: 'pm:edit', fn: PM.EditEventHandler): this;
    once(type: 'pm:edit', fn: PM.EditEventHandler): this;
    off(type: 'pm:edit', fn?: PM.EditEventHandler): this;

    /******************************************
     *
     * TODO: DRAW MODE EVENTS ON MAP ONLY
     *
     ********************************************/

    /** Fired when Drawing Mode is toggled. */
    on(
      type: 'pm:globaldrawmodetoggled',
      fn: PM.GlobalDrawModeToggledEventHandler,
      context?: any
    ): L.Evented;
    once(
      type: 'pm:globaldrawmodetoggled',
      fn: PM.GlobalDrawModeToggledEventHandler,
      context?: any
    ): L.Evented;
    off(
      type: 'pm:globaldrawmodetoggled',
      fn?: PM.GlobalDrawModeToggledEventHandler,
      context?: any
    ): L.Evented;

    /** Called when drawing mode is enabled. Payload includes the shape type and working layer. */
    on(
      type: 'pm:drawstart',
      fn: PM.DrawStartEventHandler,
      context?: any
    ): L.Evented;
    once(
      type: 'pm:drawstart',
      fn: PM.DrawStartEventHandler,
      context?: any
    ): L.Evented;
    off(
      type: 'pm:drawstart',
      fn?: PM.DrawStartEventHandler,
      context?: any
    ): L.Evented;

    /** Called when drawing mode is disabled. Payload includes the shape type. */
    on(
      type: 'pm:drawend',
      fn: PM.DrawEndEventHandler,
      context?: any
    ): L.Evented;
    once(
      type: 'pm:drawend',
      fn: PM.DrawEndEventHandler,
      context?: any
    ): L.Evented;
    off(
      type: 'pm:drawend',
      fn?: PM.DrawEndEventHandler,
      context?: any
    ): L.Evented;

    /** Called when drawing mode is disabled. Payload includes the shape type. */
    on(type: 'pm:create', fn: PM.CreateEventHandler, context?: any): L.Evented;
    once(
      type: 'pm:create',
      fn: PM.CreateEventHandler,
      context?: any
    ): L.Evented;
    off(
      type: 'pm:create',
      fn?: PM.CreateEventHandler,
      context?: any
    ): L.Evented;

    /******************************************
     *
     * TODO: DRAW MODE EVENTS ON LAYER ONLY
     *
     ********************************************/

    /** Called when a new vertex is added. */
    on(type: 'pm:vertexadded', fn: PM.VertexAddedEventHandler): this;
    once(type: 'pm:vertexadded', fn: PM.VertexAddedEventHandler): this;
    off(type: 'pm:vertexadded', fn?: PM.VertexAddedEventHandler): this;

    /******************************************
     *
     * TODO: EDIT MODE EVENTS ON LAYER ONLY
     *
     ********************************************/

    /** Fired when edit mode is disabled and a layer is edited and its coordinates have changed. */
    on(type: 'pm:update', fn: PM.UpdateEventHandler): this;
    once(type: 'pm:update', fn: PM.UpdateEventHandler): this;
    off(type: 'pm:update', fn?: PM.UpdateEventHandler): this;

    /** Fired when edit mode on a layer is enabled. */
    on(type: 'pm:enable', fn: PM.EnableEventHandler): this;
    once(type: 'pm:enable', fn: PM.EnableEventHandler): this;
    off(type: 'pm:enable', fn?: PM.EnableEventHandler): this;

    /** Fired when edit mode on a layer is disabled. */
    on(type: 'pm:disable', fn: PM.DisableEventHandler): this;
    once(type: 'pm:disable', fn: PM.DisableEventHandler): this;
    off(type: 'pm:disable', fn?: PM.DisableEventHandler): this;

    /** Fired when a vertex is added. */
    on(type: 'pm:vertexadded', fn: PM.VertexAddedEventHandler2): this;
    once(type: 'pm:vertexadded', fn: PM.VertexAddedEventHandler2): this;
    off(type: 'pm:vertexadded', fn?: PM.VertexAddedEventHandler2): this;

    /** Fired when a vertex is removed. */
    on(type: 'pm:vertexremoved', fn: PM.VertexRemovedEventHandler): this;
    once(type: 'pm:vertexremoved', fn: PM.VertexRemovedEventHandler): this;
    off(type: 'pm:vertexremoved', fn?: PM.VertexRemovedEventHandler): this;

    /** Fired when a vertex is clicked. */
    on(type: 'pm:vertexclick', fn: PM.VertexClickEventHandler): this;
    once(type: 'pm:vertexclick', fn: PM.VertexClickEventHandler): this;
    off(type: 'pm:vertexclick', fn?: PM.VertexClickEventHandler): this;

    /** Fired when dragging of a marker which corresponds to a vertex starts. */
    on(type: 'pm:markerdragstart', fn: PM.MarkerDragStartEventHandler): this;
    once(type: 'pm:markerdragstart', fn: PM.MarkerDragStartEventHandler): this;
    off(type: 'pm:markerdragstart', fn?: PM.MarkerDragStartEventHandler): this;

    /** Fired when dragging a vertex-marker. */
    on(type: 'pm:markerdrag', fn: PM.MarkerDragEventHandler): this;
    once(type: 'pm:markerdrag', fn: PM.MarkerDragEventHandler): this;
    off(type: 'pm:markerdrag', fn?: PM.MarkerDragEventHandler): this;

    /** Fired when dragging of a vertex-marker ends. */
    on(type: 'pm:markerdragend', fn: PM.MarkerDragEndEventHandler): this;
    once(type: 'pm:markerdragend', fn: PM.MarkerDragEndEventHandler): this;
    off(type: 'pm:markerdragend', fn?: PM.MarkerDragEndEventHandler): this;

    /** Fired when coords of a layer are reset. E.g. by self-intersection. */
    on(type: 'pm:layerreset', fn: PM.LayerResetEventHandler): this;
    once(type: 'pm:layerreset', fn: PM.LayerResetEventHandler): this;
    off(type: 'pm:layerreset', fn?: PM.LayerResetEventHandler): this;

    /** When allowSelfIntersection: false, this event is fired as soon as a self-intersection is detected. */
    on(type: 'pm:intersect', fn: PM.IntersectEventHandler): this;
    once(type: 'pm:intersect', fn: PM.IntersectEventHandler): this;
    off(type: 'pm:intersect', fn?: PM.IntersectEventHandler): this;

    /** Fired coordinates of the layer changed. */
    on(type: 'pm:change', fn: PM.ChangeEventHandler): this;
    once(type: 'pm:change', fn: PM.ChangeEventHandler): this;
    off(type: 'pm:change', fn?: PM.ChangeEventHandler): this;

    /** Fired when the text of a layer is changed. */
    on(type: 'pm:textchange', fn: PM.TextChangeEventHandler): this;
    once(type: 'pm:textchange', fn: PM.TextChangeEventHandler): this;
    off(type: 'pm:textchange', fn?: PM.TextChangeEventHandler): this;

    /** Fired when the text layer is focused. */
    on(type: 'pm:textfocus', fn: PM.TextFocusEventHandler): this;
    once(type: 'pm:textfocus', fn: PM.TextFocusEventHandler): this;
    off(type: 'pm:textfocus', fn?: PM.TextFocusEventHandler): this;

    /** Fired when the text layer is blurred.  */
    on(type: 'pm:textblur', fn: PM.TextBlurEventHandler): this;
    once(type: 'pm:textblur', fn: PM.TextBlurEventHandler): this;
    off(type: 'pm:textblur', fn?: PM.TextBlurEventHandler): this;

    /** Fired when the layer violates requireContainment.  */
    on(
      type: 'pm:containmentviolation',
      fn: PM.ContainmentViolationEventHandler
    ): this;
    once(
      type: 'pm:containmentviolation',
      fn: PM.ContainmentViolationEventHandler
    ): this;
    off(
      type: 'pm:containmentviolation',
      fn?: PM.ContainmentViolationEventHandler
    ): this;

    /** Fired when the layer violates preventIntersection.  */
    on(
      type: 'pm:intersectionviolation',
      fn: PM.IntersectionViolationEventHandler
    ): this;
    once(
      type: 'pm:intersectionviolation',
      fn: PM.IntersectionViolationEventHandler
    ): this;
    off(
      type: 'pm:intersectionviolation',
      fn?: PM.IntersectionViolationEventHandler
    ): this;

    /** Fired when the layer changes are canceled. */
    on(type: 'pm:cancel', fn: PM.CancelEventHandler): this;
    once(type: 'pm:cancel', fn: PM.CancelEventHandler): this;
    off(type: 'pm:cancel', fn?: PM.CancelEventHandler): this;

    /** Fired when the layer removing is canceled and the layer is re-added to the map. */
    on(type: 'pm:undoremove', fn: PM.UndoRemoveEventHandler): this;
    once(type: 'pm:undoremove', fn: PM.UndoRemoveEventHandler): this;
    off(type: 'pm:undoremove', fn?: PM.UndoRemoveEventHandler): this;

    /******************************************
     *
     * TODO: EDIT MODE EVENTS ON MAP ONLY
     *
     ********************************************/

    /** Fired when Edit Mode is toggled. */
    on(
      type: 'pm:globaleditmodetoggled',
      fn: PM.GlobalEditModeToggledEventHandler
    ): this;
    once(
      type: 'pm:globaleditmodetoggled',
      fn: PM.GlobalEditModeToggledEventHandler
    ): this;
    off(
      type: 'pm:globaleditmodetoggled',
      fn?: PM.GlobalEditModeToggledEventHandler
    ): this;

    /******************************************
     *
     * TODO: DRAG MODE EVENTS ON MAP ONLY
     *
     ********************************************/

    /** Fired when Drag Mode is toggled. */
    on(
      type: 'pm:globaldragmodetoggled',
      fn: PM.GlobalDragModeToggledEventHandler
    ): this;
    once(
      type: 'pm:globaldragmodetoggled',
      fn: PM.GlobalDragModeToggledEventHandler
    ): this;
    off(
      type: 'pm:globaldragmodetoggled',
      fn?: PM.GlobalDragModeToggledEventHandler
    ): this;

    /******************************************
     *
     * TODO: DRAG MODE EVENTS ON LAYER ONLY
     *
     ********************************************/

    /** Fired when a layer starts being dragged. */
    on(type: 'pm:dragstart', fn: PM.DragStartEventHandler): this;
    once(type: 'pm:dragstart', fn: PM.DragStartEventHandler): this;
    off(type: 'pm:dragstart', fn?: PM.DragStartEventHandler): this;

    /** Fired when a layer is dragged. */
    on(type: 'pm:drag', fn: PM.DragEventHandler): this;
    once(type: 'pm:drag', fn: PM.DragEventHandler): this;
    off(type: 'pm:drag', fn?: PM.DragEventHandler): this;

    /** Fired when a layer stops being dragged. */
    on(type: 'pm:dragend', fn: PM.DragEndEventHandler): this;
    once(type: 'pm:dragend', fn: PM.DragEndEventHandler): this;
    off(type: 'pm:dragend', fn?: PM.DragEndEventHandler): this;

    /** Fired when drag mode on a layer is enabled. */
    on(type: 'pm:dragenable', fn: PM.DragEnableEventHandler): this;
    once(type: 'pm:dragenable', fn: PM.DragEnableEventHandler): this;
    off(type: 'pm:dragenable', fn?: PM.DragEnableEventHandler): this;

    /** Fired when drag mode on a layer is disabled. */
    on(type: 'pm:dragdisable', fn: PM.DragDisableEventHandler): this;
    once(type: 'pm:dragdisable', fn: PM.DragDisableEventHandler): this;
    off(type: 'pm:dragdisable', fn?: PM.DragDisableEventHandler): this;

    /******************************************
     *
     * TODO: REMOVE MODE EVENTS ON MAP ONLY
     *
     ********************************************/

    /** Fired when Removal Mode is toggled. */
    on(
      type: 'pm:globalremovalmodetoggled',
      fn: PM.GlobalRemovalModeToggledEventHandler
    ): this;
    once(
      type: 'pm:globalremovalmodetoggled',
      fn: PM.GlobalRemovalModeToggledEventHandler
    ): this;
    off(
      type: 'pm:globalremovalmodetoggled',
      fn?: PM.GlobalRemovalModeToggledEventHandler
    ): this;

    /******************************************
     *
     * TODO: CUT MODE EVENTS ON MAP ONLY
     *
     ********************************************/

    /** Fired when a layer is removed via Removal Mode. */
    on(
      type: 'pm:globalcutmodetoggled',
      fn: PM.GlobalCutModeToggledEventHandler
    ): this;
    once(
      type: 'pm:globalcutmodetoggled',
      fn: PM.GlobalCutModeToggledEventHandler
    ): this;
    off(
      type: 'pm:globalcutmodetoggled',
      fn?: PM.GlobalCutModeToggledEventHandler
    ): this;

    /******************************************
     *
     * TODO: ROTATE MODE EVENTS ON MAP ONLY
     *
     ********************************************/

    /** Fired when Rotate Mode is toggled. */
    on(
      type: 'pm:globalrotatemodetoggled',
      fn: PM.GlobalRotateModeToggledEventHandler
    ): this;
    once(
      type: 'pm:globalrotatemodetoggled',
      fn: PM.GlobalRotateModeToggledEventHandler
    ): this;
    off(
      type: 'pm:globalrotatemodetoggled',
      fn?: PM.GlobalRotateModeToggledEventHandler
    ): this;

    /******************************************
     *
     * TODO: Union MODE EVENTS ON MAP ONLY
     *
     ********************************************/

    /** Fired when Union Mode is toggled. */
    on(
      type: 'pm:globalunionmodetoggled',
      fn: PM.GlobalUnionModeToggledEventHandler
    ): this;
    once(
      type: 'pm:globalunionmodetoggled',
      fn: PM.GlobalUnionModeToggledEventHandler
    ): this;
    off(
      type: 'pm:globalunionmodetoggled',
      fn?: PM.GlobalUnionModeToggledEventHandler
    ): this;

    /** Fired when Union is executed. */
    on(type: 'pm:union', fn: PM.UnionEventHandler): this;
    once(type: 'pm:union', fn: PM.UnionEventHandler): this;
    off(type: 'pm:union', fn: PM.UnionEventHandler): this;

    /******************************************
     *
     * TODO: Difference MODE EVENTS ON MAP ONLY
     *
     ********************************************/

    /** Fired when Difference Mode is toggled. */
    on(
      type: 'pm:globaldifferencemodetoggled',
      fn: PM.GlobalDifferenceModeToggledEventHandler
    ): this;
    once(
      type: 'pm:globaldifferencemodetoggled',
      fn: PM.GlobalDifferenceModeToggledEventHandler
    ): this;
    off(
      type: 'pm:globaldifferencemodetoggled',
      fn?: PM.GlobalDifferenceModeToggledEventHandler
    ): this;

    /** Fired when Difference is executed. */
    on(type: 'pm:difference', fn: PM.DifferenceEventHandler): this;
    once(type: 'pm:difference', fn: PM.DifferenceEventHandler): this;
    off(type: 'pm:difference', fn?: PM.DifferenceEventHandler): this;

    /******************************************
     *
     * TODO: Selection MODE EVENTS ON MAP ONLY
     *
     ********************************************/

    /** Fired when a layer is added to the selection. */
    on(type: 'pm:selectionadd', fn: PM.SelectionEventHandler): this;
    once(type: 'pm:selectionadd', fn: PM.SelectionEventHandler): this;
    off(type: 'pm:selectionadd', fn: PM.SelectionEventHandler): this;

    /** Fired when a layer is removed from the selection. */
    on(type: 'pm:selectionremove', fn: PM.SelectionEventHandler): this;
    once(type: 'pm:selectionremove', fn: PM.SelectionEventHandler): this;
    off(type: 'pm:selectionremove', fn: PM.SelectionEventHandler): this;

    /******************************************
     *
     * TODO: BringTo MODE EVENTS ON MAP ONLY
     *
     ********************************************/

    /** Fired when SendToBack Mode is toggled. */
    on(
      type: 'pm:globalbringtobackmodetoggled',
      fn: PM.GlobalSendToBackModeToggledEventHandler
    ): this;
    once(
      type: 'pm:globalbringtobackmodetoggled',
      fn: PM.GlobalSendToBackModeToggledEventHandler
    ): this;
    off(
      type: 'pm:globalbringtobackmodetoggled',
      fn?: PM.GlobalSendToBackModeToggledEventHandler
    ): this;

    /** Fired when BringToFront Mode is toggled. */
    on(
      type: 'pm:globalbringtofrontmodetoggled',
      fn: PM.GlobalBringToFrontModeToggledEventHandler
    ): this;
    once(
      type: 'pm:globalbringtofrontmodetoggled',
      fn: PM.GlobalBringToFrontModeToggledEventHandler
    ): this;
    off(
      type: 'pm:globalbringtofrontmodetoggled',
      fn?: PM.GlobalBringToFrontModeToggledEventHandler
    ): this;

    /******************************************
     *
     * TODO: CopyLayer MODE EVENTS ON MAP ONLY
     *
     ********************************************/

    /** Fired when CopyLayer Mode is toggled. */
    on(
      type: 'pm:globalcopylayermodetoggled',
      fn: PM.GlobalCopyLayerModeToggledEventHandler
    ): this;
    once(
      type: 'pm:globalcopylayermodetoggled',
      fn: PM.GlobalCopyLayerModeToggledEventHandler
    ): this;
    off(
      type: 'pm:globalcopylayermodetoggled',
      fn?: PM.GlobalCopyLayerModeToggledEventHandler
    ): this;

    /** Fired when CopyLayer is executed. */
    on(type: 'pm:copylayer', fn: PM.CopyLayerEventHandler): this;
    once(type: 'pm:copylayer', fn: PM.CopyLayerEventHandler): this;
    off(type: 'pm:copylayer', fn?: PM.CopyLayerEventHandler): this;

    /******************************************
     *
     * TODO: LINE SIMPLIFICATION MODE EVENTS ON MAP ONLY
     *
     ********************************************/

    /** Fired when CopyLayer Mode is toggled. */
    on(
      type: 'pm:globallinesimplificationmodetoggled',
      fn: PM.GlobalLineSimplificationModeToggledEventHandler
    ): this;
    once(
      type: 'pm:globallinesimplificationmodetoggled',
      fn: PM.GlobalLineSimplificationModeToggledEventHandler
    ): this;
    off(
      type: 'pm:globallinesimplificationmodetoggled',
      fn?: PM.GlobalLineSimplificationModeToggledEventHandler
    ): this;

    /******************************************
     *
     * TODO: Lasso MODE EVENTS ON MAP ONLY
     *
     ********************************************/

    /** Fired when Lasso Mode is toggled. */
    on(
      type: 'pm:globallassomodetoggled',
      fn: PM.GlobalLassoModeToggledEventHandler
    ): this;
    once(
      type: 'pm:globallassomodetoggled',
      fn: PM.GlobalLassoModeToggledEventHandler
    ): this;
    off(
      type: 'pm:globallassomodetoggled',
      fn?: PM.GlobalLassoModeToggledEventHandler
    ): this;

    /** Fired when the Lasso has been drawn. */
    on(type: 'pm:lasso-select', fn: PM.LassoSelectEventHandler): this;
    once(type: 'pm:lasso-select', fn: PM.LassoSelectEventHandler): this;
    off(type: 'pm:lasso-select', fn?: PM.LassoSelectEventHandler): this;

    /******************************************
     *
     * TODO: TRANSLATION EVENTS ON MAP ONLY
     *
     ********************************************/

    /** Standard Leaflet event. Fired when any layer is removed. */
    on(type: 'pm:langchange', fn: PM.LangChangeEventHandler): this;
    once(type: 'pm:langchange', fn: PM.LangChangeEventHandler): this;
    off(type: 'pm:langchange', fn?: PM.LangChangeEventHandler): this;

    /******************************************
     *
     * TODO: CONTROL EVENTS ON MAP ONLY
     *
     ********************************************/

    /** Fired when a Toolbar button is clicked. */
    on(type: 'pm:buttonclick', fn: PM.ButtonClickEventHandler): this;
    once(type: 'pm:buttonclick', fn: PM.ButtonClickEventHandler): this;
    off(type: 'pm:buttonclick', fn?: PM.ButtonClickEventHandler): this;

    /** Fired when a Toolbar action is clicked. */
    on(type: 'pm:actionclick', fn: PM.ActionClickEventHandler): this;
    once(type: 'pm:actionclick', fn: PM.ActionClickEventHandler): this;
    off(type: 'pm:actionclick', fn?: PM.ActionClickEventHandler): this;

    /******************************************
     *
     * TODO: Keyboard EVENT ON MAP ONLY
     *
     ********************************************/

    /** Fired when `keydown` or `keyup` on the document is fired. */
    on(type: 'pm:keyevent', fn: PM.KeyboardKeyEventHandler): this;
    once(type: 'pm:keyevent', fn: PM.KeyboardKeyEventHandler): this;
    off(type: 'pm:keyevent', fn?: PM.KeyboardKeyEventHandler): this;

    /******************************************
     *
     * TODO: GLOBAL OPTIONS EVENTS ON MAP ONLY
     *
     ********************************************/

    /** Fired when global options are changed. */
    on(
      type: 'pm:globaloptionschanged',
      fn: PM.GlobalOptionsChangedEventHandler
    ): this;
    once(
      type: 'pm:globaloptionschanged',
      fn: PM.GlobalOptionsChangedEventHandler
    ): this;
    off(
      type: 'pm:globaloptionschanged',
      fn?: PM.GlobalOptionsChangedEventHandler
    ): this;

    /******************************************
     *
     * TODO: AUTO TRACING EVENTS ON MAP ONLY
     *
     ********************************************/

    /** Fired when auto tracing is started and connected with a layer. ⭐ */
    on(type: 'pm:autotracestart', fn: PM.AutoTraceEventHandler): this;
    once(type: 'pm:autotracestart', fn: PM.AutoTraceEventHandler): this;
    off(type: 'pm:autotracestart', fn?: PM.AutoTraceEventHandler): this;

    /** Fired when auto tracing hintline is changed. ⭐ */
    on(
      type: 'pm:autotracelinechange',
      fn: PM.AutoTraceLineChangeEventHandler
    ): this;
    once(
      type: 'pm:autotracelinechange',
      fn: PM.AutoTraceLineChangeEventHandler
    ): this;
    off(
      type: 'pm:autotracelinechange',
      fn?: PM.AutoTraceLineChangeEventHandler
    ): this;

    /** 	Fired when auto tracing is ended. ⭐ */
    on(type: 'pm:autotraceend', fn: PM.AutoTraceEventHandler): this;
    once(type: 'pm:autotraceend', fn: PM.AutoTraceEventHandler): this;
    off(type: 'pm:autotraceend', fn?: PM.AutoTraceEventHandler): this;

    /******************************************
     *
     * TODO: Split MODE EVENTS ON MAP ONLY
     *
     ********************************************/

    /** Fired when a layer is split via Split Mode. */
    on(
      type: 'pm:globalsplitmodetoggled',
      fn: PM.GlobalSplitModeToggledEventHandler
    ): this;
    once(
      type: 'pm:globalsplitmodetoggled',
      fn: PM.GlobalSplitModeToggledEventHandler
    ): this;
    off(
      type: 'pm:globalsplitmodetoggled',
      fn?: PM.GlobalSplitModeToggledEventHandler
    ): this;

    /******************************************
     *
     * TODO: SCALE MODE EVENTS ON MAP ONLY
     *
     ********************************************/

    /** Fired when Scale Mode is toggled. */
    on(
      type: 'pm:globalscalemodetoggled',
      fn: PM.GlobalScaleModeToggledEventHandler
    ): this;
    once(
      type: 'pm:globalscalemodetoggled',
      fn: PM.GlobalScaleModeToggledEventHandler
    ): this;
    off(
      type: 'pm:globalscalemodetoggled',
      fn?: PM.GlobalScaleModeToggledEventHandler
    ): this;

    /******************************************
     *
     * TODO: GLOBAL MODE CANCEL EVENTS ON MAP ONLY
     *
     ********************************************/

    /** Fired when cancel of Mode is called. */
    on(type: 'pm:globalcancel', fn: PM.GlobalCancelEventHandler): this;
    once(type: 'pm:globalcancel', fn: PM.GlobalCancelEventHandler): this;
    off(type: 'pm:globalcancel', fn?: PM.GlobalCancelEventHandler): this;

    /******************************************
     *
     * TODO: ERROR EVENTS ON MAP ONLY
     *
     ********************************************/

    /** Fired when an error is thrown. */
    on(type: 'pm:error', fn: PM.ErrorEventHandler): this;
    once(type: 'pm:error', fn: PM.ErrorEventHandler): this;
    off(type: 'pm:error', fn?: PM.ErrorEventHandler): this;
  }

  namespace PM {
    export const version: string;

    /** Supported shape names. 'ImageOverlay' is in Edit Mode only. Also accepts custom shape name. */
    type SUPPORTED_SHAPES =
      | 'Marker'
      | 'Circle'
      | 'Line'
      | 'Rectangle'
      | 'Polygon'
      | 'Cut'
      | 'CircleMarker'
      | 'ImageOverlay'
      | 'Text'
      | 'Freehand' // ⭐
      | 'Lasso' // ⭐
      | 'CustomShape' // ⭐
      | string;

    type SupportLocales =
      | 'cz'
      | 'da'
      | 'de'
      | 'el'
      | 'en'
      | 'es'
      | 'fa'
      | 'fi'
      | 'fr'
      | 'hu'
      | 'id'
      | 'it'
      | 'ja'
      | 'ko'
      | 'ky'
      | 'nl'
      | 'no'
      | 'pl'
      | 'pt_br'
      | 'pt_pt'
      | 'ro'
      | 'ru'
      | 'sv'
      | 'tr'
      | 'ua'
      | 'zh'
      | 'zh_tw';

    /**
     * Changes default registration of leaflet-geoman on leaflet layers.
     *
     * @param optIn - if true, a layers pmIgnore property has to be set to false to get initiated.
     */
    function setOptIn(optIn: boolean): void;

    /**
     * Enable leaflet-geoman on an ignored layer.
     *
     * @param layer - re-reads layer.options.pmIgnore to initialize leaflet-geoman.
     */
    function reInitLayer(layer: L.Layer): void;

    /**
     * PM map interface.
     */
    interface PMMap
      extends PMDrawMap,
        PMEditMap,
        PMDragMap,
        PMRemoveMap,
        PMCutMap,
        PMRotateMap,
        PMScaleMap,
        PMSelectionMap,
        PMUnionMap,
        PMLineSimplificationMap,
        PMDifferenceMap,
        PMLassoMap {
      Toolbar: PMMapToolbar;

      Keyboard: PMMapKeyboard;

      /** Adds the Toolbar to the map. */
      addControls(options?: ToolbarOptions): void;

      /** Toggle the visiblity of the Toolbar. */
      removeControls(): void;

      /** Returns true if the Toolbar is visible on the map. */
      controlsVisible(): boolean;

      /** Toggle the visiblity of the Toolbar. */
      toggleControls(): void;

      setLang(
        lang: SupportLocales,
        customTranslations?: Translations,
        fallbackLanguage?: string
      ): void;

      /** Set globalOptions and apply them. */
      setGlobalOptions(options: GlobalOptions): void;

      /** Apply the current globalOptions to all existing layers. */
      applyGlobalOptions(): void;

      /** Returns the globalOptions. */
      getGlobalOptions(): GlobalOptions;
    }

    class Translations {
      tooltips?: {
        placeMarker?: string;
        firstVertex?: string;
        continueLine?: string;
        finishLine?: string;
        finishPoly?: string;
        finishRect?: string;
        startCircle?: string;
        finishCircle?: string;
        placeCircleMarker?: string;
        placeText?: string;
        selectFirstLayerFor?: string;
        selectSecondLayerFor?: string;
        'freehand-start'?: string;
        'lasso-start'?: string;
        placeCustomShape?: string;
      };

      actions?: {
        finish?: string;
        cancel?: string;
        removeLastVertex?: string;
        reset?: string;
        clear?: string;
      };

      buttonTitles?: {
        drawMarkerButton?: string;
        drawPolyButton?: string;
        drawLineButton?: string;
        drawCircleButton?: string;
        drawRectButton?: string;
        editButton?: string;
        dragButton?: string;
        cutButton?: string;
        deleteButton?: string;
        drawCircleMarkerButton?: string;
        snappingButton?: string;
        pinningButton?: string;
        rotateButton?: string;
        drawTextButton?: string;
        scaleButton?: string;
        autoTracingButton?: string;
        snapGuidesButton?: string;
        unionButton?: string;
        differenceButton?: string;
        sendToBackButton?: string;
        bringToFrontButton?: string;
        copyLayerButton?: string;
        splitButton?: string;
        lineSimplificationButton?: string;
        lassoButton?: string;
        freeHandButton?: string;
        customShapeButton?: string;
      };

      measurements?: {
        totalLength?: string;
        segmentLength?: string;
        area?: string;
        radius?: string;
        perimeter?: string;
        height?: string;
        width?: string;
        coordinates?: string;
        coordinatesMarker?: string;
      };
    }

    type ACTION_NAMES = 'cancel' | 'removeLastVertex' | 'finish' | 'finishMode';

    class Action {
      text: string;
      onClick?: (e: any) => void;
      title?: string;
      name?: string;
      isActive?: () => boolean;
    }

    type TOOLBAR_CONTROL_ORDER =
      | 'drawMarker'
      | 'drawCircleMarker'
      | 'drawPolyline'
      | 'drawRectangle'
      | 'drawPolygon'
      | 'drawCircle'
      | 'editMode'
      | 'dragMode'
      | 'cutPolygon'
      | 'removalMode'
      | 'rotateMode'
      | 'drawText'
      | 'scaleMode'
      | 'pinningOption'
      | 'snappingOption'
      | 'autoTracingOption'
      | 'snapGuidesOption'
      | 'spitalMode'
      | 'unionMode'
      | 'differenceMode'
      | 'bringToMode'
      | 'drawFreehand'
      | 'lassoMode'
      | 'drawCustomShape'
      | string;

    interface PMMapToolbar {
      /** Pass an array of button names to reorder the buttons in the Toolbar. */
      changeControlOrder(order?: TOOLBAR_CONTROL_ORDER[]): void;

      /** Receive the current order with. */
      getControlOrder(): TOOLBAR_CONTROL_ORDER[];

      /** The position of a block (draw, edit, custom, options⭐) in the Toolbar can be changed. If not set, the value from position of the Toolbar is taken. */
      setBlockPosition(
        block: 'draw' | 'edit' | 'custom' | 'options',
        position: L.ControlPosition
      ): void;

      /** Returns all of the active buttons */
      getButtons(): Record<string, L.Control>;

      /** Returns the full button object or undefined if the name does not exist */
      getButton(name: string): L.Control | undefined;

      /** Checks whether a button has been mounted */
      controlExists(name: string): boolean;

      /** Returns all of the custom, active buttons */
      getButtonsInBlock(name: string): Record<string, L.Control>;

      /** Returns a Object with the positions for all blocks */
      getBlockPositions(): BlockPositions;

      /** To add a custom Control to the Toolbar */
      createCustomControl(options: CustomControlOptions): L.Control;

      /** Creates a copy of a draw Control. Returns the drawInstance and the control. */
      copyDrawControl(
        copyInstance: string,
        options: CustomControlOptions | string
      ): {
        drawInstance: DrawShape;
        control: L.Control;
      };

      /** Change the actions of an existing button. */
      changeActionsOfControl(
        name: string,
        actions: (ACTION_NAMES | Action)[]
      ): void;

      /** Disable button by control name */
      setButtonDisabled(name: TOOLBAR_CONTROL_ORDER, state: boolean): void;

      /** Deletes and removes a Control from the Toolbar */
      deleteControl(name: string): void;
    }

    type KEYBOARD_EVENT_TYPE = 'current' | 'keydown' | 'keyup';

    interface PMMapKeyboard {
      /** Pass an array of button names to reorder the buttons in the Toolbar. */
      getLastKeyEvent(type: KEYBOARD_EVENT_TYPE[]): KeyboardKeyEventHandler;

      /** Returns the current pressed key. [KeyboardEvent.key](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key). */
      getPressedKey(): string;

      /** Returns true if the `Shift` key is currently pressed. */
      isShiftKeyPressed(): boolean;

      /** Returns true if the `Alt` key is currently pressed. */
      isAltKeyPressed(): boolean;

      /** Returns true if the `Ctrl` key is currently pressed. */
      isCtrlKeyPressed(): boolean;

      /** Returns true if the `Meta` key is currently pressed. */
      isMetaKeyPressed(): boolean;
    }

    interface Button {
      /** Actions */
      actions?: (ACTION_NAMES | Action)[];

      /** Function fired after clicking the control. */
      afterClick?: () => void;

      /** CSS class with the Icon. */
      className?: string;

      /** If true, other buttons will be disabled on click (default: true) */
      disableOtherButtons?: boolean;

      /** Control can be toggled. */
      doToggle?: boolean;

      /** Extending Class f. ex. Line, Polygon, ... L.PM.Draw.EXTENDINGCLASS */
      jsClass?: string;

      /** Function fired when clicking the control. */
      onClick?: () => void;

      position?: L.ControlPosition;

      /** Text showing when you hover the control. */
      title?: string;

      /** Toggle state true -> enabled, false -> disabled (default: false) */
      toggleStatus?: boolean;

      /** Block of the control. 'options' is ⭐ only. */
      tool?: 'draw' | 'edit' | 'custom' | 'options';
    }

    interface CustomControlOptions {
      /** Name of the control */
      name: string;

      /** Block of the control. 'options' is ⭐ only. */
      block?: 'draw' | 'edit' | 'custom' | 'options';

      /** Text showing when you hover the control. */
      title?: string;

      /** CSS class with the Icon. */
      className?: string;

      /** Function fired when clicking the control. */
      onClick?: () => void;

      /** Function fired after clicking the control. */
      afterClick?: () => void;

      /** Actions */
      actions?: (ACTION_NAMES | Action)[];

      /** Control can be toggled. */
      toggle?: boolean;

      /** Control is disabled. */
      disabled?: boolean;

      /** Control disables other buttons if enabled. */
      disableOtherButtons?: boolean;

      /** Control disabled if other buttons is enabled. */
      disableByOtherButtons?: boolean;
    }

    type PANE =
      | 'mapPane'
      | 'tilePane'
      | 'overlayPane'
      | 'shadowPane'
      | 'markerPane'
      | 'tooltipPane'
      | 'popupPane'
      | string;

    type DISPLAY_FORMAT = 'metric' | 'imperial';

    interface GlobalOptions extends DrawModeOptions, EditModeOptions {
      /** Add the created layers to a layergroup instead to the map. */
      layerGroup?: L.Map | L.LayerGroup;

      /** Prioritize the order of snapping. Default: ['Marker','CircleMarker','Circle','Line','Polygon','Rectangle']. */
      snappingOrder?: SUPPORTED_SHAPES[];

      /** Defines in which panes the layers and helper vertices are created. Default: { vertexPane: 'markerPane', layerPane: 'overlayPane', markerPane: 'markerPane' } */
      panes?: { vertexPane?: PANE; layerPane?: PANE; markerPane?: PANE };

      /** Measurement options. ⭐*/
      measurements?: {
        measurement?: boolean;
        showTooltip?: boolean;
        showTooltipOnHover?: boolean;
        totalLength?: boolean;
        segmentLength?: boolean;
        area?: boolean;
        radius?: boolean;
        perimeter?: boolean;
        height?: boolean;
        width?: boolean;
        coordinates?: boolean;
        displayFormat?: DISPLAY_FORMAT;
      };

      /** Until which zoom level the coordinates of the layers in the viewport will be used. Default: 10 ⭐ */
      autoTraceMaxZoom?: number;

      /** The distance to the layer when a snap for auto tracing should happen. Default: 20 ⭐ */
      autoTraceMaxDistance?: number;

      /** Style options for selected layers. ⭐ */
      selectionLayerStyle?: L.PathOptions;

      /** Changing the cut behavior to use a circle instead of a polygon. Default: false ⭐ */
      cutAsCircle?: boolean;

      /** Enable exiting active modes (draw, edit, drag, rotate, remove, cut) by pressing the Escape key. Default: false */
      exitModeOnEscape?: boolean;

      /** Enable finishing drawing shapes (Line, Polygon, Cut) by pressing the Enter key when enough vertices are placed. Default: false */
      finishOnEnter?: boolean;
    }

    interface PMDrawMap {
      /** Enable Draw Mode with the passed shape. */
      enableDraw(shape: SUPPORTED_SHAPES, options?: DrawModeOptions): void;

      /** Disable all drawing */
      disableDraw(shape?: SUPPORTED_SHAPES): void;

      /** Enable Custom Shape Draw Mode with a passed shape from the storage or as GeoJSON. ⭐ */
      enableCustomShapeDraw(
        shape: string | object,
        options?: DrawModeOptions
      ): void;

      /** Disable Custom Shape drawing. ⭐ */
      disableCustomShapeDraw(): void;

      /** Draw */
      Draw: Draw;

      /** Returns true if global Draw Mode is enabled. false when disabled. */
      globalDrawModeEnabled(): boolean;

      /** Customize the style of the drawn layer. Only for L.Path layers. Shapes can be excluded with a ignoreShapes array or merged with the current style with merge: true in  optionsModifier. */
      setPathOptions(
        options: L.PathOptions | L.CircleMarkerOptions,
        optionsModifier?: {
          ignoreShapes?: SUPPORTED_SHAPES[],
          merge?: boolean
        }
      ): void;

      /** Returns all Geoman layers on the map as array. Pass true to get a L.FeatureGroup. */
      getGeomanLayers(asFeatureGroup: true): L.FeatureGroup;
      getGeomanLayers(asFeatureGroup?: false): L.Layer[];

      /** Returns all Geoman draw layers on the map as array. Pass true to get a L.FeatureGroup. */
      getGeomanDrawLayers(asFeatureGroup: true): L.FeatureGroup;
      getGeomanDrawLayers(asFeatureGroup?: false): L.Layer[];

      /** Returns if CustomShape Draw Mode is enabled. ⭐ */
      customShapeDrawEnabled(): boolean;

      /** Adds a CustomShape to the storage. ⭐ */
      addCustomShape(
        name: string,
        geojson: object,
        options?: DrawModeOptions
      ): void;

      /** Removes a CustomShape from the storage. ⭐ */
      removeCustomShape(name: string): void;

      /** Returns all CustomShapes in the storage. ⭐ */
      getCustomShapes(): {
        [name: string]: { geojson: string; options?: DrawModeOptions };
      };

      /** Adds a CustomShape to the Toolbar. ⭐ */
      addCustomShapeToToolbar(
        name: string,
        options:
          | { className: string; text?: string; title?: string }
          | { className?: string; text: string; title?: string }
      ): void;

      /** Removes a CustomShape from the Toolbar. ⭐ */
      removeCustomShapeFromToolbar(name: string): void;
    }

    interface PMEditMap {
      /** Enables edit mode. The passed options are preserved, even when the mode is enabled via the Toolbar */
      enableGlobalEditMode(options?: EditModeOptions): void;

      /** Disables global edit mode. */
      disableGlobalEditMode(): void;

      /** Toggles global edit mode. */
      toggleGlobalEditMode(options?: EditModeOptions): void;

      /** Returns true if global edit mode is enabled. false when disabled. */
      globalEditModeEnabled(): boolean;
    }

    interface PMDragMap {
      /** Enables global drag mode. */
      enableGlobalDragMode(): void;

      /** Disables global drag mode. */
      disableGlobalDragMode(): void;

      /** Toggles global drag mode. */
      toggleGlobalDragMode(): void;

      /** Returns true if global drag mode is enabled. false when disabled. */
      globalDragModeEnabled(): boolean;

      /** Reverts the layers to the state before changing. ⭐  */
      cancelGlobalDragMode(): void;
    }

    interface PMRemoveMap {
      /** Enables global removal mode. */
      enableGlobalRemovalMode(): void;

      /** Disables global removal mode. */
      disableGlobalRemovalMode(): void;

      /** Toggles global removal mode. */
      toggleGlobalRemovalMode(): void;

      /** Returns true if global removal mode is enabled. false when disabled. */
      globalRemovalModeEnabled(): boolean;

      /** Reverts the layers to the state before changing. ⭐  */
      cancelGlobalRemovalMode(): void;
    }

    interface PMCutMap {
      /** Enables global cut mode. */
      enableGlobalCutMode(options?: CutModeOptions): void;

      /** Disables global cut mode. */
      disableGlobalCutMode(): void;

      /** Toggles global cut mode. */
      toggleGlobalCutMode(options?: CutModeOptions): void;

      /** Returns true if global cut mode is enabled. false when disabled. */
      globalCutModeEnabled(): boolean;
    }

    interface PMRotateMap {
      /** Enables global rotate mode. */
      enableGlobalRotateMode(): void;

      /** Disables global rotate mode. */
      disableGlobalRotateMode(): void;

      /** Toggles global rotate mode. */
      toggleGlobalRotateMode(): void;

      /** Returns true if global rotate mode is enabled. false when disabled. */
      globalRotateModeEnabled(): boolean;

      /** Reverts the layers to the state before changing. ⭐  */
      cancelGlobalRotateMode(): void;
    }

    interface PMScaleMap {
      /** Enables global scale mode. ⭐ */
      enableGlobalScaleMode(): void;

      /** Disables global scale mode. ⭐ */
      disableGlobalScaleMode(): void;

      /** Toggles global scale mode. ⭐ */
      toggleGlobalScaleMode(): void;

      /** Returns true if global scale mode is enabled. false when disabled. ⭐ */
      globalScaleModeEnabled(): boolean;

      /** Reverts the layers to the state before changing. ⭐  */
      cancelGlobalScaleMode(): void;
    }

    interface PMSelectionMap {
      /** Enables global selection mode. Optional a filter can be added, which checks if the selection is allowed. ⭐ */
      enableSelectionTool(filterFnc?: () => boolean): void;

      /** Disables global selection mode. ⭐ */
      disableSelectionTool(): void;

      /** Returns true if global selection mode is enabled. false when disabled. ⭐ */
      selectionToolEnabled(): boolean;

      /** Adds a layer to the selection. ⭐ */
      addSelection(layer: L.Layer): void;

      /** Removes a layer from the selection. ⭐ */
      removeSelection(layer: L.Layer): void;

      /** Returns selected layers. ⭐ */
      getSelectedLayers(): L.Layer[];

      /** Returns if the layer is selected. ⭐ */
      isLayerSelected(layer: L.Layer): boolean;
    }

    interface PMUnionMap {
      /** Enables global union mode. ⭐ */
      enableGlobalUnionMode(): void;

      /** Disables global union mode. ⭐ */
      disableGlobalUnionMode(): void;

      /** Toggles global union mode. ⭐ */
      toggleGlobalUnionMode(): void;

      /** Returns true if global union mode is enabled. false when disabled. ⭐ */
      globalUnionModeEnabled(): boolean;

      /** Unifies the two layers. ⭐ */
      union(layer1: L.Layer, layer2: L.Layer): void;
    }

    interface PMDifferenceMap {
      /** Enables global difference mode. ⭐ */
      enableGlobalDifferenceMode(): void;

      /** Disables global difference mode. ⭐ */
      disableGlobalDifferenceMode(): void;

      /** Toggles global difference mode. ⭐ */
      toggleGlobalDifferenceMode(): void;

      /** Returns true if global difference mode is enabled. false when disabled. ⭐ */
      globalDifferenceModeEnabled(): boolean;

      /** Subtracts the second selected layer from the first selected layer. ⭐ */
      difference(layer1: L.Layer, layer2: L.Layer): void;
    }

    interface PMCopyLayerMap {
      /** Enables global CopyLayer mode. ⭐ */
      enableGlobalCopyLayerMode(): void;

      /** Disables global CopyLayer mode. ⭐ */
      disableGlobalCopyLayerMode(): void;

      /** Toggles global CopyLayer mode. ⭐ */
      toggleGlobalCopyLayerMode(): void;

      /** Returns true if global CopyLayer mode is enabled. false when disabled. ⭐ */
      globalCopyLayerModeEnabled(): boolean;

      /** Resets the current source layer. ⭐ */
      resetCopyLayerMode(): void;
    }

    interface PMLineSimplificationMap {
      /** Enables global LineSimplification mode. ⭐ */
      enableGlobalLineSimplificationMode(): void;

      /** Disables global LineSimplification mode. ⭐ */
      disableGlobalLineSimplificationMode(): void;

      /** Toggles global LineSimplification mode. ⭐ */
      toggleGlobalLineSimplificationMode(): void;

      /** Returns true if global LineSimplification mode is enabled. false when disabled. ⭐ */
      globalLineSimplificationModeEnabled(): boolean;

      /** Reverts the layers to the state before changing. ⭐  */
      cancelGlobalLineSimplificationMode(): void;
    }

    interface PMLassoMap {
      /** Enables global Lasso mode. ⭐ */
      enableGlobalLassoMode(options?: LassoModeOptions): void;

      /** Disables global Lasso mode. ⭐ */
      disableGlobalLassoMode(): void;

      /** Toggles global Lasso mode. ⭐ */
      toggleGlobalLassoMode(options?: LassoModeOptions): void;

      /** Returns true if global Lasso mode is enabled. false when disabled. ⭐ */
      globalLassoModeEnabled(): boolean;

      /** Sets the Lasso Mode to Append. ⭐ */
      setLassoAppendMode(): void;

      /** Sets the Lasso Mode to Subtract. ⭐ */
      setLassoSubtractMode(): void;

      /** Sets the Lasso Mode to Reset. ⭐ */
      setLassoResetMode(): void;

      /** Get current Lasso Mode. ⭐ */