@types/ol

  • Version 6.5.3
  • Published
  • 651 kB
  • 4 dependencies
  • MIT license

Install

npm i @types/ol
yarn add @types/ol
pnpm add @types/ol

Overview

TypeScript definitions for ol

Index

Variables

Functions

Classes

Variables

variable VERSION

const VERSION: string;
  • OpenLayers version.

Functions

function getUid

getUid: (obj: any) => string;
  • Gets a unique ID for an object. This mutates the object so that further calls with the same object as a parameter returns the same value. Unique IDs are generated as a strictly increasing sequence. Adapted from goog.getUid.

Classes

class AssertionError

class AssertionError extends Error {}

    constructor

    constructor(code: number);

      property code

      code: number;
      • Error code. The meaning of the code can be found on https://openlayers.org/en/latest/doc/errors/ (replace latest with the version found in the OpenLayers script's header comment if a version other than the latest is used).

      class Collection

      class Collection<T> extends BaseObject {}

        constructor

        constructor(opt_array?: T[], opt_options?: Options);

          method clear

          clear: () => void;
          • Remove all elements from the collection.

          method extend

          extend: (arr: T[]) => Collection<T>;
          • Add elements to the collection. This pushes each item in the provided array to the end of the collection.

          method forEach

          forEach: (f: (p0: T, p1: number, p2: T[]) => any) => void;
          • Iterate over each element, calling the provided callback.

          method getArray

          getArray: () => T[];
          • Get a reference to the underlying Array object. Warning: if the array is mutated, no events will be dispatched by the collection, and the collection's "length" property won't be in sync with the actual length of the array.

          method getLength

          getLength: () => number;
          • Get the length of this collection.

          method insertAt

          insertAt: (index: number, elem: T) => void;
          • Insert an element at the provided index.

          method item

          item: (index: number) => T;
          • Get the element at the provided index.

          method on

          on: {
          (type: string | string[], listener: (p0: any) => any):
          | EventsKey
          | EventsKey[];
          (type: 'add', listener: (evt: CollectionEvent<T>) => void): EventsKey;
          (type: 'change', listener: (evt: BaseEvent) => void): EventsKey;
          (type: 'change:length', listener: (evt: ObjectEvent) => void): EventsKey;
          (type: 'error', listener: (evt: BaseEvent) => void): EventsKey;
          (type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey;
          (type: 'remove', listener: (evt: CollectionEvent<T>) => void): EventsKey;
          };

            method once

            once: {
            (type: string | string[], listener: (p0: any) => any):
            | EventsKey
            | EventsKey[];
            (type: 'add', listener: (evt: CollectionEvent<T>) => void): EventsKey;
            (type: 'change', listener: (evt: BaseEvent) => void): EventsKey;
            (type: 'change:length', listener: (evt: ObjectEvent) => void): EventsKey;
            (type: 'error', listener: (evt: BaseEvent) => void): EventsKey;
            (type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey;
            (type: 'remove', listener: (evt: CollectionEvent<T>) => void): EventsKey;
            };

              method pop

              pop: () => T | undefined;
              • Remove the last element of the collection and return it. Return undefined if the collection is empty.

              method push

              push: (elem: T) => number;
              • Insert the provided element at the end of the collection.

              method remove

              remove: (elem: T) => T | undefined;
              • Remove the first occurrence of an element from the collection.

              method removeAt

              removeAt: (index: number) => T | undefined;
              • Remove the element at the provided index and return it. Return undefined if the collection does not contain this index.

              method setAt

              setAt: (index: number, elem: T) => void;
              • Set the element at the provided index.

              method un

              un: {
              (type: string | string[], listener: (p0: any) => any): void;
              (type: 'add', listener: (evt: CollectionEvent<T>) => void): void;
              (type: 'change', listener: (evt: BaseEvent) => void): void;
              (type: 'change:length', listener: (evt: ObjectEvent) => void): void;
              (type: 'error', listener: (evt: BaseEvent) => void): void;
              (type: 'propertychange', listener: (evt: ObjectEvent) => void): void;
              (type: 'remove', listener: (evt: CollectionEvent<T>) => void): void;
              };

                class Disposable

                class Disposable {}

                  constructor

                  constructor();

                    property disposed

                    protected disposed: boolean;
                    • The object has already been disposed.

                    method dispose

                    dispose: () => void;
                    • Clean up.

                    method disposeInternal

                    protected disposeInternal: () => void;
                    • Extension point for disposable objects.

                    class Feature

                    class Feature<GeomType extends Geometry = Geometry> extends BaseObject {}

                      constructor

                      constructor(opt_geometryOrProperties?: GeomType | { [key: string]: any });

                        method clone

                        clone: () => Feature<Geometry>;
                        • Clone this feature. If the original feature has a geometry it is also cloned. The feature id is not set in the clone.

                        method getGeometry

                        getGeometry: () => GeomType | undefined;
                        • Get the feature's default geometry. A feature may have any number of named geometries. The "default" geometry (the one that is rendered by default) is set when calling .

                        method getGeometryName

                        getGeometryName: () => string;
                        • Get the name of the feature's default geometry. By default, the default geometry is named geometry.

                        method getId

                        getId: () => number | string | undefined;
                        • Get the feature identifier. This is a stable identifier for the feature and is either set when reading data from a remote source or set explicitly by calling .

                        method getStyle

                        getStyle: () => StyleLike | undefined;
                        • Get the feature's style. Will return what was provided to the method.

                        method getStyleFunction

                        getStyleFunction: () => StyleFunction | undefined;
                        • Get the feature's style function.

                        method on

                        on: {
                        (type: string | string[], listener: (p0: any) => any):
                        | EventsKey
                        | EventsKey[];
                        (type: 'change', listener: (evt: BaseEvent) => void): EventsKey;
                        (type: 'change:geometry', listener: (evt: ObjectEvent) => void): EventsKey;
                        (type: 'error', listener: (evt: BaseEvent) => void): EventsKey;
                        (type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey;
                        };

                          method once

                          once: {
                          (type: string | string[], listener: (p0: any) => any):
                          | EventsKey
                          | EventsKey[];
                          (type: 'change', listener: (evt: BaseEvent) => void): EventsKey;
                          (type: 'change:geometry', listener: (evt: ObjectEvent) => void): EventsKey;
                          (type: 'error', listener: (evt: BaseEvent) => void): EventsKey;
                          (type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey;
                          };

                            method setGeometry

                            setGeometry: (geometry: GeomType | undefined) => void;
                            • Set the default geometry for the feature. This will update the property with the name returned by .

                            method setGeometryName

                            setGeometryName: (name: string) => void;
                            • Set the property name to be used when getting the feature's default geometry. When calling , the value of the property with this name will be returned.

                            method setId

                            setId: (id: number | string | undefined) => void;
                            • Set the feature id. The feature id is considered stable and may be used when requesting features or comparing identifiers returned from a remote source. The feature id can be used with the method.

                            method setStyle

                            setStyle: (opt_style?: StyleLike) => void;
                            • Set the style for the feature to override the layer style. This can be a single style object, an array of styles, or a function that takes a resolution and returns an array of styles. To unset the feature style, call setStyle() without arguments or a falsey value.

                            method un

                            un: {
                            (type: string | string[], listener: (p0: any) => any): void;
                            (type: 'change', listener: (evt: BaseEvent) => void): void;
                            (type: 'change:geometry', listener: (evt: ObjectEvent) => void): void;
                            (type: 'error', listener: (evt: BaseEvent) => void): void;
                            (type: 'propertychange', listener: (evt: ObjectEvent) => void): void;
                            };

                              class Geolocation

                              class Geolocation extends BaseObject {}

                                constructor

                                constructor(opt_options?: Options);

                                  method disposeInternal

                                  disposeInternal: () => void;
                                  • Clean up.

                                  method getAccuracy

                                  getAccuracy: () => number | undefined;
                                  • Get the accuracy of the position in meters.

                                  method getAccuracyGeometry

                                  getAccuracyGeometry: () => Polygon;
                                  • Get a geometry of the position accuracy.

                                  method getAltitude

                                  getAltitude: () => number | undefined;
                                  • Get the altitude associated with the position.

                                  method getAltitudeAccuracy

                                  getAltitudeAccuracy: () => number | undefined;
                                  • Get the altitude accuracy of the position.

                                  method getHeading

                                  getHeading: () => number | undefined;
                                  • Get the heading as radians clockwise from North. Note: depending on the browser, the heading is only defined if the enableHighAccuracy is set to true in the tracking options.

                                  method getPosition

                                  getPosition: () => Coordinate | undefined;
                                  • Get the position of the device.

                                  method getProjection

                                  getProjection: () => Projection | undefined;
                                  • Get the projection associated with the position.

                                  method getSpeed

                                  getSpeed: () => number | undefined;
                                  • Get the speed in meters per second.

                                  method getTracking

                                  getTracking: () => boolean;
                                  • Determine if the device location is being tracked.

                                  method getTrackingOptions

                                  getTrackingOptions: () => PositionOptions | undefined;
                                  • Get the tracking options. See http://www.w3.org/TR/geolocation-API/#position-options.

                                  method on

                                  on: {
                                  (type: string | string[], listener: (p0: any) => any):
                                  | EventsKey
                                  | EventsKey[];
                                  (type: 'change', listener: (evt: BaseEvent) => void): EventsKey;
                                  (type: 'change:accuracy', listener: (evt: ObjectEvent) => void): EventsKey;
                                  (
                                  type: 'change:accuracyGeometry',
                                  listener: (evt: ObjectEvent) => void
                                  ): EventsKey;
                                  (type: 'change:altitude', listener: (evt: ObjectEvent) => void): EventsKey;
                                  (
                                  type: 'change:altitudeAccuracy',
                                  listener: (evt: ObjectEvent) => void
                                  ): EventsKey;
                                  (type: 'change:heading', listener: (evt: ObjectEvent) => void): EventsKey;
                                  (type: 'change:position', listener: (evt: ObjectEvent) => void): EventsKey;
                                  (type: 'change:projection', listener: (evt: ObjectEvent) => void): EventsKey;
                                  (type: 'change:speed', listener: (evt: ObjectEvent) => void): EventsKey;
                                  (type: 'change:tracking', listener: (evt: ObjectEvent) => void): EventsKey;
                                  (
                                  type: 'change:trackingOptions',
                                  listener: (evt: ObjectEvent) => void
                                  ): EventsKey;
                                  (type: 'error', listener: (evt: GeolocationError) => void): EventsKey;
                                  (type: 'error', listener: (evt: BaseEvent) => void): EventsKey;
                                  (type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey;
                                  };

                                    method once

                                    once: {
                                    (type: string | string[], listener: (p0: any) => any):
                                    | EventsKey
                                    | EventsKey[];
                                    (type: 'change', listener: (evt: BaseEvent) => void): EventsKey;
                                    (type: 'change:accuracy', listener: (evt: ObjectEvent) => void): EventsKey;
                                    (
                                    type: 'change:accuracyGeometry',
                                    listener: (evt: ObjectEvent) => void
                                    ): EventsKey;
                                    (type: 'change:altitude', listener: (evt: ObjectEvent) => void): EventsKey;
                                    (
                                    type: 'change:altitudeAccuracy',
                                    listener: (evt: ObjectEvent) => void
                                    ): EventsKey;
                                    (type: 'change:heading', listener: (evt: ObjectEvent) => void): EventsKey;
                                    (type: 'change:position', listener: (evt: ObjectEvent) => void): EventsKey;
                                    (type: 'change:projection', listener: (evt: ObjectEvent) => void): EventsKey;
                                    (type: 'change:speed', listener: (evt: ObjectEvent) => void): EventsKey;
                                    (type: 'change:tracking', listener: (evt: ObjectEvent) => void): EventsKey;
                                    (
                                    type: 'change:trackingOptions',
                                    listener: (evt: ObjectEvent) => void
                                    ): EventsKey;
                                    (type: 'error', listener: (evt: GeolocationError) => void): EventsKey;
                                    (type: 'error', listener: (evt: BaseEvent) => void): EventsKey;
                                    (type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey;
                                    };

                                      method setProjection

                                      setProjection: (projection: ProjectionLike) => void;
                                      • Set the projection to use for transforming the coordinates.

                                      method setTracking

                                      setTracking: (tracking: boolean) => void;
                                      • Enable or disable tracking.

                                      method setTrackingOptions

                                      setTrackingOptions: (options: PositionOptions) => void;
                                      • Set the tracking options. See http://www.w3.org/TR/geolocation-API/#position-options.

                                      method un

                                      un: {
                                      (type: string | string[], listener: (p0: any) => any): void;
                                      (type: 'change', listener: (evt: BaseEvent) => void): void;
                                      (type: 'change:accuracy', listener: (evt: ObjectEvent) => void): void;
                                      (
                                      type: 'change:accuracyGeometry',
                                      listener: (evt: ObjectEvent) => void
                                      ): void;
                                      (type: 'change:altitude', listener: (evt: ObjectEvent) => void): void;
                                      (
                                      type: 'change:altitudeAccuracy',
                                      listener: (evt: ObjectEvent) => void
                                      ): void;
                                      (type: 'change:heading', listener: (evt: ObjectEvent) => void): void;
                                      (type: 'change:position', listener: (evt: ObjectEvent) => void): void;
                                      (type: 'change:projection', listener: (evt: ObjectEvent) => void): void;
                                      (type: 'change:speed', listener: (evt: ObjectEvent) => void): void;
                                      (type: 'change:tracking', listener: (evt: ObjectEvent) => void): void;
                                      (type: 'change:trackingOptions', listener: (evt: ObjectEvent) => void): void;
                                      (type: 'error', listener: (evt: GeolocationError) => void): void;
                                      (type: 'error', listener: (evt: BaseEvent) => void): void;
                                      (type: 'propertychange', listener: (evt: ObjectEvent) => void): void;
                                      };

                                        class Graticule

                                        class Graticule extends VectorLayer {}

                                          constructor

                                          constructor(opt_options?: Options);

                                            method getMeridians

                                            getMeridians: () => LineString[];
                                            • Get the list of meridians. Meridians are lines of equal longitude.

                                            method getParallels

                                            getParallels: () => LineString[];
                                            • Get the list of parallels. Parallels are lines of equal latitude.

                                            method loaderFunction

                                            loaderFunction: (
                                            extent: Extent,
                                            resolution: number,
                                            projection: Projection
                                            ) => void;
                                            • Update geometries in the source based on current view

                                            method on

                                            on: {
                                            (type: string | string[], listener: (p0: any) => any):
                                            | EventsKey
                                            | EventsKey[];
                                            (type: 'change', listener: (evt: BaseEvent) => void): EventsKey;
                                            (type: 'change:extent', listener: (evt: ObjectEvent) => void): EventsKey;
                                            (
                                            type: 'change:maxResolution',
                                            listener: (evt: ObjectEvent) => void
                                            ): EventsKey;
                                            (type: 'change:maxZoom', listener: (evt: ObjectEvent) => void): EventsKey;
                                            (
                                            type: 'change:minResolution',
                                            listener: (evt: ObjectEvent) => void
                                            ): EventsKey;
                                            (type: 'change:minZoom', listener: (evt: ObjectEvent) => void): EventsKey;
                                            (type: 'change:opacity', listener: (evt: ObjectEvent) => void): EventsKey;
                                            (type: 'change:source', listener: (evt: ObjectEvent) => void): EventsKey;
                                            (type: 'change:visible', listener: (evt: ObjectEvent) => void): EventsKey;
                                            (type: 'change:zIndex', listener: (evt: ObjectEvent) => void): EventsKey;
                                            (type: 'error', listener: (evt: BaseEvent) => void): EventsKey;
                                            (type: 'postcompose', listener: (evt: RenderEvent) => void): EventsKey;
                                            (type: 'postrender', listener: (evt: RenderEvent) => void): EventsKey;
                                            (type: 'precompose', listener: (evt: RenderEvent) => void): EventsKey;
                                            (type: 'prerender', listener: (evt: RenderEvent) => void): EventsKey;
                                            (type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey;
                                            (type: 'rendercomplete', listener: (evt: RenderEvent) => void): EventsKey;
                                            };

                                              method once

                                              once: {
                                              (type: string | string[], listener: (p0: any) => any):
                                              | EventsKey
                                              | EventsKey[];
                                              (type: 'change', listener: (evt: BaseEvent) => void): EventsKey;
                                              (type: 'change:extent', listener: (evt: ObjectEvent) => void): EventsKey;
                                              (
                                              type: 'change:maxResolution',
                                              listener: (evt: ObjectEvent) => void
                                              ): EventsKey;
                                              (type: 'change:maxZoom', listener: (evt: ObjectEvent) => void): EventsKey;
                                              (
                                              type: 'change:minResolution',
                                              listener: (evt: ObjectEvent) => void
                                              ): EventsKey;
                                              (type: 'change:minZoom', listener: (evt: ObjectEvent) => void): EventsKey;
                                              (type: 'change:opacity', listener: (evt: ObjectEvent) => void): EventsKey;
                                              (type: 'change:source', listener: (evt: ObjectEvent) => void): EventsKey;
                                              (type: 'change:visible', listener: (evt: ObjectEvent) => void): EventsKey;
                                              (type: 'change:zIndex', listener: (evt: ObjectEvent) => void): EventsKey;
                                              (type: 'error', listener: (evt: BaseEvent) => void): EventsKey;
                                              (type: 'postcompose', listener: (evt: RenderEvent) => void): EventsKey;
                                              (type: 'postrender', listener: (evt: RenderEvent) => void): EventsKey;
                                              (type: 'precompose', listener: (evt: RenderEvent) => void): EventsKey;
                                              (type: 'prerender', listener: (evt: RenderEvent) => void): EventsKey;
                                              (type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey;
                                              (type: 'rendercomplete', listener: (evt: RenderEvent) => void): EventsKey;
                                              };

                                                method strategyFunction

                                                strategyFunction: (extent: Extent, resolution: number) => Extent[];
                                                • Strategy function for loading features based on the view's extent and resolution.

                                                method un

                                                un: {
                                                (type: string | string[], listener: (p0: any) => any): void;
                                                (type: 'change', listener: (evt: BaseEvent) => void): void;
                                                (type: 'change:extent', listener: (evt: ObjectEvent) => void): void;
                                                (type: 'change:maxResolution', listener: (evt: ObjectEvent) => void): void;
                                                (type: 'change:maxZoom', listener: (evt: ObjectEvent) => void): void;
                                                (type: 'change:minResolution', listener: (evt: ObjectEvent) => void): void;
                                                (type: 'change:minZoom', listener: (evt: ObjectEvent) => void): void;
                                                (type: 'change:opacity', listener: (evt: ObjectEvent) => void): void;
                                                (type: 'change:source', listener: (evt: ObjectEvent) => void): void;
                                                (type: 'change:visible', listener: (evt: ObjectEvent) => void): void;
                                                (type: 'change:zIndex', listener: (evt: ObjectEvent) => void): void;
                                                (type: 'error', listener: (evt: BaseEvent) => void): void;
                                                (type: 'postcompose', listener: (evt: RenderEvent) => void): void;
                                                (type: 'postrender', listener: (evt: RenderEvent) => void): void;
                                                (type: 'precompose', listener: (evt: RenderEvent) => void): void;
                                                (type: 'prerender', listener: (evt: RenderEvent) => void): void;
                                                (type: 'propertychange', listener: (evt: ObjectEvent) => void): void;
                                                (type: 'rendercomplete', listener: (evt: RenderEvent) => void): void;
                                                };

                                                  class Image

                                                  class ImageWrapper extends ImageBase {}

                                                    constructor

                                                    constructor(
                                                    extent: Extent,
                                                    resolution: number,
                                                    pixelRatio: number,
                                                    src: string,
                                                    crossOrigin: string,
                                                    imageLoadFunction: LoadFunction
                                                    );

                                                      property state

                                                      protected state: ImageState;

                                                        method getImage

                                                        getImage: () => HTMLCanvasElement | HTMLImageElement | HTMLVideoElement;

                                                          method load

                                                          load: () => void;
                                                          • Load the image or retry if loading previously failed. Loading is taken care of by the tile queue, and calling this method is only needed for preloading or for reloading in case of an error.

                                                          method setImage

                                                          setImage: (
                                                          image: HTMLCanvasElement | HTMLImageElement | HTMLVideoElement
                                                          ) => void;

                                                            class ImageBase

                                                            abstract class ImageBase extends Target {}

                                                              constructor

                                                              constructor(
                                                              extent: Extent,
                                                              resolution: number,
                                                              pixelRatio: number,
                                                              state: ImageState
                                                              );

                                                                property extent

                                                                protected extent: Extent;

                                                                  property resolution

                                                                  protected resolution: number;

                                                                    property state

                                                                    protected state: ImageState;

                                                                      method changed

                                                                      protected changed: () => void;

                                                                        method getExtent

                                                                        getExtent: () => Extent;

                                                                          method getImage

                                                                          abstract getImage: () => HTMLCanvasElement | HTMLImageElement | HTMLVideoElement;

                                                                            method getPixelRatio

                                                                            getPixelRatio: () => number;

                                                                              method getResolution

                                                                              getResolution: () => number;

                                                                                method getState

                                                                                getState: () => ImageState;

                                                                                  method load

                                                                                  abstract load: () => void;
                                                                                  • Load not yet loaded URI.

                                                                                  class ImageCanvas

                                                                                  class ImageCanvas extends ImageBase {}

                                                                                    constructor

                                                                                    constructor(
                                                                                    extent: Extent,
                                                                                    resolution: number,
                                                                                    pixelRatio: number,
                                                                                    canvas: HTMLCanvasElement,
                                                                                    opt_loader?: Loader
                                                                                    );

                                                                                      method getError

                                                                                      getError: () => Error;
                                                                                      • Get any error associated with asynchronous rendering.

                                                                                      method getImage

                                                                                      getImage: () => HTMLCanvasElement;

                                                                                        method load

                                                                                        load: () => void;
                                                                                        • Load not yet loaded URI.

                                                                                        class ImageTile

                                                                                        class ImageTile extends Tile {}

                                                                                          constructor

                                                                                          constructor(
                                                                                          tileCoord: TileCoord,
                                                                                          state: TileState,
                                                                                          src: string,
                                                                                          crossOrigin: string,
                                                                                          tileLoadFunction: LoadFunction,
                                                                                          opt_options?: Options
                                                                                          );

                                                                                            method getImage

                                                                                            getImage: () => HTMLCanvasElement | HTMLImageElement | HTMLVideoElement;
                                                                                            • Get the HTML image element for this tile (may be a Canvas, Image, or Video).

                                                                                            method load

                                                                                            load: () => void;
                                                                                            • Load not yet loaded URI.

                                                                                            class Kinetic

                                                                                            class Kinetic {}

                                                                                              constructor

                                                                                              constructor(decay: number, minVelocity: number, delay: number);

                                                                                                method begin

                                                                                                begin: () => void;
                                                                                                • FIXME empty description for jsdoc

                                                                                                method end

                                                                                                end: () => boolean;

                                                                                                  method getAngle

                                                                                                  getAngle: () => number;

                                                                                                    method getDistance

                                                                                                    getDistance: () => number;

                                                                                                      method update

                                                                                                      update: (x: number, y: number) => void;

                                                                                                        class Map

                                                                                                        class Map extends PluggableMap {}

                                                                                                          constructor

                                                                                                          constructor(options: MapOptions);

                                                                                                            method createRenderer

                                                                                                            createRenderer: () => MapRenderer;

                                                                                                              method on

                                                                                                              on: {
                                                                                                              (type: string | string[], listener: (p0: any) => any):
                                                                                                              | EventsKey
                                                                                                              | EventsKey[];
                                                                                                              (type: 'change', listener: (evt: BaseEvent) => void): EventsKey;
                                                                                                              (type: 'change:layerGroup', listener: (evt: ObjectEvent) => void): EventsKey;
                                                                                                              (type: 'change:size', listener: (evt: ObjectEvent) => void): EventsKey;
                                                                                                              (type: 'change:target', listener: (evt: ObjectEvent) => void): EventsKey;
                                                                                                              (type: 'change:view', listener: (evt: ObjectEvent) => void): EventsKey;
                                                                                                              (
                                                                                                              type: 'click',
                                                                                                              listener: (evt: MapBrowserEvent<UIEvent>) => void
                                                                                                              ): EventsKey;
                                                                                                              (
                                                                                                              type: 'dblclick',
                                                                                                              listener: (evt: MapBrowserEvent<UIEvent>) => void
                                                                                                              ): EventsKey;
                                                                                                              (type: 'error', listener: (evt: BaseEvent) => void): EventsKey;
                                                                                                              (type: 'moveend', listener: (evt: MapEvent) => void): EventsKey;
                                                                                                              (type: 'movestart', listener: (evt: MapEvent) => void): EventsKey;
                                                                                                              (
                                                                                                              type: 'pointerdrag',
                                                                                                              listener: (evt: MapBrowserEvent<UIEvent>) => void
                                                                                                              ): EventsKey;
                                                                                                              (
                                                                                                              type: 'pointermove',
                                                                                                              listener: (evt: MapBrowserEvent<UIEvent>) => void
                                                                                                              ): EventsKey;
                                                                                                              (type: 'postcompose', listener: (evt: RenderEvent) => void): EventsKey;
                                                                                                              (type: 'postrender', listener: (evt: MapEvent) => void): EventsKey;
                                                                                                              (type: 'precompose', listener: (evt: RenderEvent) => void): EventsKey;
                                                                                                              (type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey;
                                                                                                              (type: 'rendercomplete', listener: (evt: RenderEvent) => void): EventsKey;
                                                                                                              (
                                                                                                              type: 'singleclick',
                                                                                                              listener: (evt: MapBrowserEvent<UIEvent>) => void
                                                                                                              ): EventsKey;
                                                                                                              };

                                                                                                                method once

                                                                                                                once: {
                                                                                                                (type: string | string[], listener: (p0: any) => any):
                                                                                                                | EventsKey
                                                                                                                | EventsKey[];
                                                                                                                (type: 'change', listener: (evt: BaseEvent) => void): EventsKey;
                                                                                                                (type: 'change:layerGroup', listener: (evt: ObjectEvent) => void): EventsKey;
                                                                                                                (type: 'change:size', listener: (evt: ObjectEvent) => void): EventsKey;
                                                                                                                (type: 'change:target', listener: (evt: ObjectEvent) => void): EventsKey;
                                                                                                                (type: 'change:view', listener: (evt: ObjectEvent) => void): EventsKey;
                                                                                                                (
                                                                                                                type: 'click',
                                                                                                                listener: (evt: MapBrowserEvent<UIEvent>) => void
                                                                                                                ): EventsKey;
                                                                                                                (
                                                                                                                type: 'dblclick',
                                                                                                                listener: (evt: MapBrowserEvent<UIEvent>) => void
                                                                                                                ): EventsKey;
                                                                                                                (type: 'error', listener: (evt: BaseEvent) => void): EventsKey;
                                                                                                                (type: 'moveend', listener: (evt: MapEvent) => void): EventsKey;
                                                                                                                (type: 'movestart', listener: (evt: MapEvent) => void): EventsKey;
                                                                                                                (
                                                                                                                type: 'pointerdrag',
                                                                                                                listener: (evt: MapBrowserEvent<UIEvent>) => void
                                                                                                                ): EventsKey;
                                                                                                                (
                                                                                                                type: 'pointermove',
                                                                                                                listener: (evt: MapBrowserEvent<UIEvent>) => void
                                                                                                                ): EventsKey;
                                                                                                                (type: 'postcompose', listener: (evt: RenderEvent) => void): EventsKey;
                                                                                                                (type: 'postrender', listener: (evt: MapEvent) => void): EventsKey;
                                                                                                                (type: 'precompose', listener: (evt: RenderEvent) => void): EventsKey;
                                                                                                                (type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey;
                                                                                                                (type: 'rendercomplete', listener: (evt: RenderEvent) => void): EventsKey;
                                                                                                                (
                                                                                                                type: 'singleclick',
                                                                                                                listener: (evt: MapBrowserEvent<UIEvent>) => void
                                                                                                                ): EventsKey;
                                                                                                                };

                                                                                                                  method un

                                                                                                                  un: {
                                                                                                                  (type: string | string[], listener: (p0: any) => any): void;
                                                                                                                  (type: 'change', listener: (evt: BaseEvent) => void): void;
                                                                                                                  (type: 'change:layerGroup', listener: (evt: ObjectEvent) => void): void;
                                                                                                                  (type: 'change:size', listener: (evt: ObjectEvent) => void): void;
                                                                                                                  (type: 'change:target', listener: (evt: ObjectEvent) => void): void;
                                                                                                                  (type: 'change:view', listener: (evt: ObjectEvent) => void): void;
                                                                                                                  (type: 'click', listener: (evt: MapBrowserEvent<UIEvent>) => void): void;
                                                                                                                  (type: 'dblclick', listener: (evt: MapBrowserEvent<UIEvent>) => void): void;
                                                                                                                  (type: 'error', listener: (evt: BaseEvent) => void): void;
                                                                                                                  (type: 'moveend', listener: (evt: MapEvent) => void): void;
                                                                                                                  (type: 'movestart', listener: (evt: MapEvent) => void): void;
                                                                                                                  (
                                                                                                                  type: 'pointerdrag',
                                                                                                                  listener: (evt: MapBrowserEvent<UIEvent>) => void
                                                                                                                  ): void;
                                                                                                                  (
                                                                                                                  type: 'pointermove',
                                                                                                                  listener: (evt: MapBrowserEvent<UIEvent>) => void
                                                                                                                  ): void;
                                                                                                                  (type: 'postcompose', listener: (evt: RenderEvent) => void): void;
                                                                                                                  (type: 'postrender', listener: (evt: MapEvent) => void): void;
                                                                                                                  (type: 'precompose', listener: (evt: RenderEvent) => void): void;
                                                                                                                  (type: 'propertychange', listener: (evt: ObjectEvent) => void): void;
                                                                                                                  (type: 'rendercomplete', listener: (evt: RenderEvent) => void): void;
                                                                                                                  (
                                                                                                                  type: 'singleclick',
                                                                                                                  listener: (evt: MapBrowserEvent<UIEvent>) => void
                                                                                                                  ): void;
                                                                                                                  };

                                                                                                                    class MapBrowserEvent

                                                                                                                    class MapBrowserEvent<EVENT extends UIEvent = UIEvent> extends MapEvent {}

                                                                                                                      constructor

                                                                                                                      constructor(
                                                                                                                      type: string,
                                                                                                                      map: PluggableMap,
                                                                                                                      originalEvent: UIEvent,
                                                                                                                      opt_dragging?: boolean,
                                                                                                                      opt_frameState?: FrameState
                                                                                                                      );

                                                                                                                        property coordinate

                                                                                                                        coordinate: Coordinate;
                                                                                                                        • The coordinate corresponding to the original browser event. This will be in the user projection if one is set. Otherwise it will be in the view projection.

                                                                                                                        property dragging

                                                                                                                        dragging: boolean;
                                                                                                                        • Indicates if the map is currently being dragged. Only set for POINTERDRAG and POINTERMOVE events. Default is false.

                                                                                                                        property originalEvent

                                                                                                                        originalEvent: UIEvent;
                                                                                                                        • The original browser event.

                                                                                                                        property pixel

                                                                                                                        pixel: Pixel;
                                                                                                                        • The map pixel relative to the viewport corresponding to the original event.

                                                                                                                        method preventDefault

                                                                                                                        preventDefault: () => void;
                                                                                                                        • Prevents the default browser action. See https://developer.mozilla.org/en-US/docs/Web/API/event.preventDefault.

                                                                                                                        method stopPropagation

                                                                                                                        stopPropagation: () => void;
                                                                                                                        • Prevents further propagation of the current event. See https://developer.mozilla.org/en-US/docs/Web/API/event.stopPropagation.

                                                                                                                        class MapBrowserEventHandler

                                                                                                                        class MapBrowserEventHandler extends Target {}

                                                                                                                          constructor

                                                                                                                          constructor(map: PluggableMap, moveTolerance?: number);

                                                                                                                            method disposeInternal

                                                                                                                            disposeInternal: () => void;
                                                                                                                            • Clean up.

                                                                                                                            class MapEvent

                                                                                                                            class MapEvent extends BaseEvent {}

                                                                                                                              constructor

                                                                                                                              constructor(type: string, map: PluggableMap, opt_frameState?: FrameState);

                                                                                                                                property frameState

                                                                                                                                frameState: FrameState;
                                                                                                                                • The frame state at the time of the event.

                                                                                                                                property map

                                                                                                                                map: PluggableMap;
                                                                                                                                • The map where the event occurred.

                                                                                                                                class Object

                                                                                                                                class BaseObject extends Observable {}

                                                                                                                                  constructor

                                                                                                                                  constructor(opt_values?: { [key: string]: any });

                                                                                                                                    method applyProperties

                                                                                                                                    protected applyProperties: (source: BaseObject) => void;
                                                                                                                                    • Apply any properties from another object without triggering events.

                                                                                                                                    method get

                                                                                                                                    get: (key: string) => any;
                                                                                                                                    • Gets a value.

                                                                                                                                    method getKeys

                                                                                                                                    getKeys: () => string[];
                                                                                                                                    • Get a list of object property names.

                                                                                                                                    method getProperties

                                                                                                                                    getProperties: () => { [key: string]: any };
                                                                                                                                    • Get an object of all property names and values.

                                                                                                                                    method hasProperties

                                                                                                                                    hasProperties: () => boolean;

                                                                                                                                      method notify

                                                                                                                                      notify: (key: string, oldValue: any) => void;

                                                                                                                                        method on

                                                                                                                                        on: {
                                                                                                                                        (type: string | string[], listener: (p0: any) => any):
                                                                                                                                        | EventsKey
                                                                                                                                        | EventsKey[];
                                                                                                                                        (type: 'change', listener: (evt: BaseEvent) => void): EventsKey;
                                                                                                                                        (type: 'error', listener: (evt: BaseEvent) => void): EventsKey;
                                                                                                                                        (type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey;
                                                                                                                                        };

                                                                                                                                          method once

                                                                                                                                          once: {
                                                                                                                                          (type: string | string[], listener: (p0: any) => any):
                                                                                                                                          | EventsKey
                                                                                                                                          | EventsKey[];
                                                                                                                                          (type: 'change', listener: (evt: BaseEvent) => void): EventsKey;
                                                                                                                                          (type: 'error', listener: (evt: BaseEvent) => void): EventsKey;
                                                                                                                                          (type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey;
                                                                                                                                          };

                                                                                                                                            method set

                                                                                                                                            set: (key: string, value: any, opt_silent?: boolean) => void;
                                                                                                                                            • Sets a value.

                                                                                                                                            method setProperties

                                                                                                                                            setProperties: (values: { [key: string]: any }, opt_silent?: boolean) => void;
                                                                                                                                            • Sets a collection of key-value pairs. Note that this changes any existing properties and adds new ones (it does not remove any existing properties).

                                                                                                                                            method un

                                                                                                                                            un: {
                                                                                                                                            (type: string | string[], listener: (p0: any) => any): void;
                                                                                                                                            (type: 'change', listener: (evt: BaseEvent) => void): void;
                                                                                                                                            (type: 'error', listener: (evt: BaseEvent) => void): void;
                                                                                                                                            (type: 'propertychange', listener: (evt: ObjectEvent) => void): void;
                                                                                                                                            };

                                                                                                                                              method unset

                                                                                                                                              unset: (key: string, opt_silent?: boolean) => void;
                                                                                                                                              • Unsets a property.

                                                                                                                                              class Observable

                                                                                                                                              class Observable extends Target {}

                                                                                                                                                constructor

                                                                                                                                                constructor();

                                                                                                                                                  method changed

                                                                                                                                                  changed: () => void;
                                                                                                                                                  • Increases the revision counter and dispatches a 'change' event.

                                                                                                                                                  method getRevision

                                                                                                                                                  getRevision: () => number;
                                                                                                                                                  • Get the version number for this object. Each time the object is modified, its version number will be incremented.

                                                                                                                                                  method on

                                                                                                                                                  on: {
                                                                                                                                                  (type: string | string[], listener: (p0: any) => any):
                                                                                                                                                  | EventsKey
                                                                                                                                                  | EventsKey[];
                                                                                                                                                  (type: 'change', listener: (evt: BaseEvent) => void): EventsKey;
                                                                                                                                                  (type: 'error', listener: (evt: BaseEvent) => void): EventsKey;
                                                                                                                                                  };
                                                                                                                                                  • Listen for a certain type of event.

                                                                                                                                                  method once

                                                                                                                                                  once: {
                                                                                                                                                  (type: string | string[], listener: (p0: any) => any):
                                                                                                                                                  | EventsKey
                                                                                                                                                  | EventsKey[];
                                                                                                                                                  (type: 'change', listener: (evt: BaseEvent) => void): EventsKey;
                                                                                                                                                  (type: 'error', listener: (evt: BaseEvent) => void): EventsKey;
                                                                                                                                                  };
                                                                                                                                                  • Listen once for a certain type of event.

                                                                                                                                                  method un

                                                                                                                                                  un: {
                                                                                                                                                  (type: string | string[], listener: (p0: any) => any): void;
                                                                                                                                                  (type: 'change', listener: (evt: BaseEvent) => void): void;
                                                                                                                                                  (type: 'error', listener: (evt: BaseEvent) => void): void;
                                                                                                                                                  };
                                                                                                                                                  • Unlisten for a certain type of event.

                                                                                                                                                  class Overlay

                                                                                                                                                  class Overlay extends BaseObject {}

                                                                                                                                                    constructor

                                                                                                                                                    constructor(options: Options);

                                                                                                                                                      property autoPan

                                                                                                                                                      protected autoPan: false | PanIntoViewOptions;

                                                                                                                                                        property element

                                                                                                                                                        protected element: HTMLElement;

                                                                                                                                                          property id

                                                                                                                                                          protected id: string | number;

                                                                                                                                                            property insertFirst

                                                                                                                                                            protected insertFirst: boolean;

                                                                                                                                                              property mapPostrenderListenerKey

                                                                                                                                                              protected mapPostrenderListenerKey: EventsKey;

                                                                                                                                                                property options

                                                                                                                                                                protected options: Options;

                                                                                                                                                                  property rendered

                                                                                                                                                                  protected rendered: any;

                                                                                                                                                                    property stopEvent

                                                                                                                                                                    protected stopEvent: boolean;

                                                                                                                                                                      method getElement

                                                                                                                                                                      getElement: () => HTMLElement | undefined;
                                                                                                                                                                      • Get the DOM element of this overlay.

                                                                                                                                                                      method getId

                                                                                                                                                                      getId: () => number | string | undefined;
                                                                                                                                                                      • Get the overlay identifier which is set on constructor.

                                                                                                                                                                      method getMap

                                                                                                                                                                      getMap: () => PluggableMap | undefined;
                                                                                                                                                                      • Get the map associated with this overlay.

                                                                                                                                                                      method getOffset

                                                                                                                                                                      getOffset: () => number[];
                                                                                                                                                                      • Get the offset of this overlay.

                                                                                                                                                                      method getOptions

                                                                                                                                                                      getOptions: () => Options;
                                                                                                                                                                      • returns the options this Overlay has been created with

                                                                                                                                                                      method getPosition

                                                                                                                                                                      getPosition: () => Coordinate | undefined;
                                                                                                                                                                      • Get the current position of this overlay.

                                                                                                                                                                      method getPositioning

                                                                                                                                                                      getPositioning: () => OverlayPositioning;
                                                                                                                                                                      • Get the current positioning of this overlay.

                                                                                                                                                                      method getRect

                                                                                                                                                                      protected getRect: (element: HTMLElement, size: Size) => Extent;
                                                                                                                                                                      • Get the extent of an element relative to the document

                                                                                                                                                                      method handleElementChanged

                                                                                                                                                                      protected handleElementChanged: () => void;

                                                                                                                                                                        method handleMapChanged

                                                                                                                                                                        protected handleMapChanged: () => void;

                                                                                                                                                                          method handleOffsetChanged

                                                                                                                                                                          protected handleOffsetChanged: () => void;

                                                                                                                                                                            method handlePositionChanged

                                                                                                                                                                            protected handlePositionChanged: () => void;

                                                                                                                                                                              method handlePositioningChanged

                                                                                                                                                                              protected handlePositioningChanged: () => void;

                                                                                                                                                                                method on

                                                                                                                                                                                on: {
                                                                                                                                                                                (type: string | string[], listener: (p0: any) => any):
                                                                                                                                                                                | EventsKey
                                                                                                                                                                                | EventsKey[];
                                                                                                                                                                                (type: 'change', listener: (evt: BaseEvent) => void): EventsKey;
                                                                                                                                                                                (type: 'change:element', listener: (evt: ObjectEvent) => void): EventsKey;
                                                                                                                                                                                (type: 'change:map', listener: (evt: ObjectEvent) => void): EventsKey;
                                                                                                                                                                                (type: 'change:offset', listener: (evt: ObjectEvent) => void): EventsKey;
                                                                                                                                                                                (type: 'change:position', listener: (evt: ObjectEvent) => void): EventsKey;
                                                                                                                                                                                (
                                                                                                                                                                                type: 'change:positioning',
                                                                                                                                                                                listener: (evt: ObjectEvent) => void
                                                                                                                                                                                ): EventsKey;
                                                                                                                                                                                (type: 'error', listener: (evt: BaseEvent) => void): EventsKey;
                                                                                                                                                                                (type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey;
                                                                                                                                                                                };

                                                                                                                                                                                  method once

                                                                                                                                                                                  once: {
                                                                                                                                                                                  (type: string | string[], listener: (p0: any) => any):
                                                                                                                                                                                  | EventsKey
                                                                                                                                                                                  | EventsKey[];
                                                                                                                                                                                  (type: 'change', listener: (evt: BaseEvent) => void): EventsKey;
                                                                                                                                                                                  (type: 'change:element', listener: (evt: ObjectEvent) => void): EventsKey;
                                                                                                                                                                                  (type: 'change:map', listener: (evt: ObjectEvent) => void): EventsKey;
                                                                                                                                                                                  (type: 'change:offset', listener: (evt: ObjectEvent) => void): EventsKey;
                                                                                                                                                                                  (type: 'change:position', listener: (evt: ObjectEvent) => void): EventsKey;
                                                                                                                                                                                  (
                                                                                                                                                                                  type: 'change:positioning',
                                                                                                                                                                                  listener: (evt: ObjectEvent) => void
                                                                                                                                                                                  ): EventsKey;
                                                                                                                                                                                  (type: 'error', listener: (evt: BaseEvent) => void): EventsKey;
                                                                                                                                                                                  (type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey;
                                                                                                                                                                                  };

                                                                                                                                                                                    method panIntoView

                                                                                                                                                                                    panIntoView: (opt_panIntoViewOptions?: PanIntoViewOptions) => void;
                                                                                                                                                                                    • Pan the map so that the overlay is entirely visible in the current viewport (if necessary).

                                                                                                                                                                                    method performAutoPan

                                                                                                                                                                                    protected performAutoPan: () => void;
                                                                                                                                                                                    • Pan the map so that the overlay is entirely visisble in the current viewport (if necessary) using the configured autoPan parameters

                                                                                                                                                                                    method render

                                                                                                                                                                                    protected render: () => void;

                                                                                                                                                                                      method setElement

                                                                                                                                                                                      setElement: (element: HTMLElement | undefined) => void;
                                                                                                                                                                                      • Set the DOM element to be associated with this overlay.

                                                                                                                                                                                      method setMap

                                                                                                                                                                                      setMap: (map: PluggableMap | undefined) => void;
                                                                                                                                                                                      • Set the map to be associated with this overlay.

                                                                                                                                                                                      method setOffset

                                                                                                                                                                                      setOffset: (offset: number[]) => void;
                                                                                                                                                                                      • Set the offset for this overlay.

                                                                                                                                                                                      method setPosition

                                                                                                                                                                                      setPosition: (position: Coordinate | undefined) => void;
                                                                                                                                                                                      • Set the position for this overlay. If the position is undefined the overlay is hidden.

                                                                                                                                                                                      method setPositioning

                                                                                                                                                                                      setPositioning: (positioning: OverlayPositioning) => void;
                                                                                                                                                                                      • Set the positioning for this overlay.

                                                                                                                                                                                      method setVisible

                                                                                                                                                                                      protected setVisible: (visible: boolean) => void;
                                                                                                                                                                                      • Modify the visibility of the element.

                                                                                                                                                                                      method un

                                                                                                                                                                                      un: {
                                                                                                                                                                                      (type: string | string[], listener: (p0: any) => any): void;
                                                                                                                                                                                      (type: 'change', listener: (evt: BaseEvent) => void): void;
                                                                                                                                                                                      (type: 'change:element', listener: (evt: ObjectEvent) => void): void;
                                                                                                                                                                                      (type: 'change:map', listener: (evt: ObjectEvent) => void): void;
                                                                                                                                                                                      (type: 'change:offset', listener: (evt: ObjectEvent) => void): void;
                                                                                                                                                                                      (type: 'change:position', listener: (evt: ObjectEvent) => void): void;
                                                                                                                                                                                      (type: 'change:positioning', listener: (evt: ObjectEvent) => void): void;
                                                                                                                                                                                      (type: 'error', listener: (evt: BaseEvent) => void): void;
                                                                                                                                                                                      (type: 'propertychange', listener: (evt: ObjectEvent) => void): void;
                                                                                                                                                                                      };

                                                                                                                                                                                        method updatePixelPosition

                                                                                                                                                                                        protected updatePixelPosition: () => void;
                                                                                                                                                                                        • Update pixel position.

                                                                                                                                                                                        method updateRenderedPosition

                                                                                                                                                                                        protected updateRenderedPosition: (
                                                                                                                                                                                        pixel: Pixel,
                                                                                                                                                                                        mapSize: Size | undefined
                                                                                                                                                                                        ) => void;

                                                                                                                                                                                          class PluggableMap

                                                                                                                                                                                          class PluggableMap extends BaseObject {}

                                                                                                                                                                                            constructor

                                                                                                                                                                                            constructor(options: MapOptions);

                                                                                                                                                                                              property controls

                                                                                                                                                                                              protected controls: Collection<Control>;

                                                                                                                                                                                                property interactions

                                                                                                                                                                                                protected interactions: Collection<Interaction>;

                                                                                                                                                                                                  method addControl

                                                                                                                                                                                                  addControl: (control: Control) => void;
                                                                                                                                                                                                  • Add the given control to the map.

                                                                                                                                                                                                  method addInteraction

                                                                                                                                                                                                  addInteraction: (interaction: Interaction) => void;
                                                                                                                                                                                                  • Add the given interaction to the map. If you want to add an interaction at another point of the collection use getInteraction() and the methods available on . This can be used to stop the event propagation from the handleEvent function. The interactions get to handle the events in the reverse order of this collection.

                                                                                                                                                                                                  method addLayer

                                                                                                                                                                                                  addLayer: (layer: BaseLayer) => void;
                                                                                                                                                                                                  • Adds the given layer to the top of this map. If you want to add a layer elsewhere in the stack, use getLayers() and the methods available on .

                                                                                                                                                                                                  method addOverlay

                                                                                                                                                                                                  addOverlay: (overlay: Overlay) => void;
                                                                                                                                                                                                  • Add the given overlay to the map.

                                                                                                                                                                                                  method createRenderer

                                                                                                                                                                                                  createRenderer: () => MapRenderer;

                                                                                                                                                                                                    method disposeInternal

                                                                                                                                                                                                    disposeInternal: () => void;
                                                                                                                                                                                                    • Clean up.

                                                                                                                                                                                                    method forEachFeatureAtPixel

                                                                                                                                                                                                    forEachFeatureAtPixel: <S, T>(
                                                                                                                                                                                                    pixel: Pixel,
                                                                                                                                                                                                    callback: (p0: FeatureLike, p1: Layer<Source>, p2: SimpleGeometry) => T,
                                                                                                                                                                                                    opt_options?: AtPixelOptions
                                                                                                                                                                                                    ) => T | undefined;
                                                                                                                                                                                                    • Detect features that intersect a pixel on the viewport, and execute a callback with each intersecting feature. Layers included in the detection can be configured through the layerFilter option in opt_options.

                                                                                                                                                                                                    method forEachLayerAtPixel

                                                                                                                                                                                                    forEachLayerAtPixel: <S, T>(
                                                                                                                                                                                                    pixel: Pixel,
                                                                                                                                                                                                    callback: (
                                                                                                                                                                                                    this: S,
                                                                                                                                                                                                    p0: Layer<Source>,
                                                                                                                                                                                                    p1: Uint8ClampedArray | Uint8Array
                                                                                                                                                                                                    ) => T,
                                                                                                                                                                                                    opt_options?: AtPixelOptions
                                                                                                                                                                                                    ) => T | undefined;
                                                                                                                                                                                                    • Detect layers that have a color value at a pixel on the viewport, and execute a callback with each matching layer. Layers included in the detection can be configured through opt_layerFilter. Note: this may give false positives unless the map layers have had different className properties assigned to them.

                                                                                                                                                                                                    method getControls

                                                                                                                                                                                                    getControls: () => Collection<Control>;
                                                                                                                                                                                                    • Get the map controls. Modifying this collection changes the controls associated with the map.

                                                                                                                                                                                                    method getCoordinateFromPixel

                                                                                                                                                                                                    getCoordinateFromPixel: (pixel: Pixel) => Coordinate;
                                                                                                                                                                                                    • Get the coordinate for a given pixel. This returns a coordinate in the user projection.

                                                                                                                                                                                                    method getCoordinateFromPixelInternal

                                                                                                                                                                                                    getCoordinateFromPixelInternal: (pixel: Pixel) => Coordinate;
                                                                                                                                                                                                    • Get the coordinate for a given pixel. This returns a coordinate in the map view projection.

                                                                                                                                                                                                    method getEventCoordinate

                                                                                                                                                                                                    getEventCoordinate: (event: MouseEvent) => Coordinate;
                                                                                                                                                                                                    • Returns the coordinate in user projection for a browser event.

                                                                                                                                                                                                    method getEventCoordinateInternal

                                                                                                                                                                                                    getEventCoordinateInternal: (event: MouseEvent) => Coordinate;
                                                                                                                                                                                                    • Returns the coordinate in view projection for a browser event.

                                                                                                                                                                                                    method getEventPixel

                                                                                                                                                                                                    getEventPixel: (event: UIEvent) => Pixel;
                                                                                                                                                                                                    • Returns the map pixel position for a browser event relative to the viewport.

                                                                                                                                                                                                    method getFeaturesAtPixel

                                                                                                                                                                                                    getFeaturesAtPixel: (
                                                                                                                                                                                                    pixel: Pixel,
                                                                                                                                                                                                    opt_options?: AtPixelOptions
                                                                                                                                                                                                    ) => FeatureLike[];
                                                                                                                                                                                                    • Get all features that intersect a pixel on the viewport.

                                                                                                                                                                                                    method getInteractions

                                                                                                                                                                                                    getInteractions: () => Collection<Interaction>;
                                                                                                                                                                                                    • Get the map interactions. Modifying this collection changes the interactions associated with the map. Interactions are used for e.g. pan, zoom and rotate.

                                                                                                                                                                                                    method getLayerGroup

                                                                                                                                                                                                    getLayerGroup: () => LayerGroup;
                                                                                                                                                                                                    • Get the layergroup associated with this map.

                                                                                                                                                                                                    method getLayers

                                                                                                                                                                                                    getLayers: () => Collection<BaseLayer>;
                                                                                                                                                                                                    • Get the collection of layers associated with this map.

                                                                                                                                                                                                    method getLoading

                                                                                                                                                                                                    getLoading: () => boolean;

                                                                                                                                                                                                      method getOverlayById

                                                                                                                                                                                                      getOverlayById: (id: string | number) => Overlay;
                                                                                                                                                                                                      • Get an overlay by its identifier (the value returned by overlay.getId()). Note that the index treats string and numeric identifiers as the same. So map.getOverlayById(2) will return an overlay with id '2' or 2.

                                                                                                                                                                                                      method getOverlayContainer

                                                                                                                                                                                                      getOverlayContainer: () => HTMLElement;
                                                                                                                                                                                                      • Get the element that serves as the container for overlays. Elements added to this container will let mousedown and touchstart events through to the map, so clicks and gestures on an overlay will trigger events.

                                                                                                                                                                                                      method getOverlayContainerStopEvent

                                                                                                                                                                                                      getOverlayContainerStopEvent: () => HTMLElement;
                                                                                                                                                                                                      • Get the element that serves as a container for overlays that don't allow event propagation. Elements added to this container won't let mousedown and touchstart events through to the map, so clicks and gestures on an overlay don't trigger any .

                                                                                                                                                                                                      method getOverlays

                                                                                                                                                                                                      getOverlays: () => Collection<Overlay>;
                                                                                                                                                                                                      • Get the map overlays. Modifying this collection changes the overlays associated with the map.

                                                                                                                                                                                                      method getOwnerDocument

                                                                                                                                                                                                      getOwnerDocument: () => Document;

                                                                                                                                                                                                        method getPixelFromCoordinate

                                                                                                                                                                                                        getPixelFromCoordinate: (coordinate: Coordinate) => Pixel;
                                                                                                                                                                                                        • Get the pixel for a coordinate. This takes a coordinate in the user projection and returns the corresponding pixel.

                                                                                                                                                                                                        method getPixelFromCoordinateInternal

                                                                                                                                                                                                        getPixelFromCoordinateInternal: (coordinate: Coordinate) => Pixel;
                                                                                                                                                                                                        • Get the pixel for a coordinate. This takes a coordinate in the map view projection and returns the corresponding pixel.

                                                                                                                                                                                                        method getRenderer

                                                                                                                                                                                                        getRenderer: () => MapRenderer;
                                                                                                                                                                                                        • Get the map renderer.

                                                                                                                                                                                                        method getSize

                                                                                                                                                                                                        getSize: () => Size | undefined;
                                                                                                                                                                                                        • Get the size of this map.

                                                                                                                                                                                                        method getTarget

                                                                                                                                                                                                        getTarget: () => HTMLElement | string | undefined;
                                                                                                                                                                                                        • Get the target in which this map is rendered. Note that this returns what is entered as an option or in setTarget: if that was an element, it returns an element; if a string, it returns that.

                                                                                                                                                                                                        method getTargetElement

                                                                                                                                                                                                        getTargetElement: () => HTMLElement;
                                                                                                                                                                                                        • Get the DOM element into which this map is rendered. In contrast to getTarget this method always return an Element, or null if the map has no target.

                                                                                                                                                                                                        method getTilePriority

                                                                                                                                                                                                        getTilePriority: (
                                                                                                                                                                                                        tile: Tile,
                                                                                                                                                                                                        tileSourceKey: string,
                                                                                                                                                                                                        tileCenter: Coordinate,
                                                                                                                                                                                                        tileResolution: number
                                                                                                                                                                                                        ) => number;

                                                                                                                                                                                                          method getView

                                                                                                                                                                                                          getView: () => View;
                                                                                                                                                                                                          • Get the view associated with this map. A view manages properties such as center and resolution.

                                                                                                                                                                                                          method getViewport

                                                                                                                                                                                                          getViewport: () => HTMLElement;
                                                                                                                                                                                                          • Get the element that serves as the map viewport.

                                                                                                                                                                                                          method handleBrowserEvent

                                                                                                                                                                                                          handleBrowserEvent: (browserEvent: UIEvent, opt_type?: string) => void;

                                                                                                                                                                                                            method handleMapBrowserEvent

                                                                                                                                                                                                            handleMapBrowserEvent: (mapBrowserEvent: MapBrowserEvent<UIEvent>) => void;

                                                                                                                                                                                                              method handlePostRender

                                                                                                                                                                                                              protected handlePostRender: () => void;

                                                                                                                                                                                                                method hasFeatureAtPixel

                                                                                                                                                                                                                hasFeatureAtPixel: (pixel: Pixel, opt_options?: AtPixelOptions) => boolean;
                                                                                                                                                                                                                • Detect if features intersect a pixel on the viewport. Layers included in the detection can be configured through opt_layerFilter.

                                                                                                                                                                                                                method isRendered

                                                                                                                                                                                                                isRendered: () => boolean;

                                                                                                                                                                                                                  method on

                                                                                                                                                                                                                  on: {
                                                                                                                                                                                                                  (type: string | string[], listener: (p0: any) => any):
                                                                                                                                                                                                                  | EventsKey
                                                                                                                                                                                                                  | EventsKey[];
                                                                                                                                                                                                                  (type: 'change', listener: (evt: BaseEvent) => void): EventsKey;
                                                                                                                                                                                                                  (type: 'change:layerGroup', listener: (evt: ObjectEvent) => void): EventsKey;
                                                                                                                                                                                                                  (type: 'change:size', listener: (evt: ObjectEvent) => void): EventsKey;
                                                                                                                                                                                                                  (type: 'change:target', listener: (evt: ObjectEvent) => void): EventsKey;
                                                                                                                                                                                                                  (type: 'change:view', listener: (evt: ObjectEvent) => void): EventsKey;
                                                                                                                                                                                                                  (
                                                                                                                                                                                                                  type: 'click',
                                                                                                                                                                                                                  listener: (evt: MapBrowserEvent<UIEvent>) => void
                                                                                                                                                                                                                  ): EventsKey;
                                                                                                                                                                                                                  (
                                                                                                                                                                                                                  type: 'dblclick',
                                                                                                                                                                                                                  listener: (evt: MapBrowserEvent<UIEvent>) => void
                                                                                                                                                                                                                  ): EventsKey;
                                                                                                                                                                                                                  (type: 'error', listener: (evt: BaseEvent) => void): EventsKey;
                                                                                                                                                                                                                  (type: 'moveend', listener: (evt: MapEvent) => void): EventsKey;
                                                                                                                                                                                                                  (type: 'movestart', listener: (evt: MapEvent) => void): EventsKey;
                                                                                                                                                                                                                  (
                                                                                                                                                                                                                  type: 'pointerdrag',
                                                                                                                                                                                                                  listener: (evt: MapBrowserEvent<UIEvent>) => void
                                                                                                                                                                                                                  ): EventsKey;
                                                                                                                                                                                                                  (
                                                                                                                                                                                                                  type: 'pointermove',
                                                                                                                                                                                                                  listener: (evt: MapBrowserEvent<UIEvent>) => void
                                                                                                                                                                                                                  ): EventsKey;
                                                                                                                                                                                                                  (type: 'postcompose', listener: (evt: RenderEvent) => void): EventsKey;
                                                                                                                                                                                                                  (type: 'postrender', listener: (evt: MapEvent) => void): EventsKey;
                                                                                                                                                                                                                  (type: 'precompose', listener: (evt: RenderEvent) => void): EventsKey;
                                                                                                                                                                                                                  (type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey;
                                                                                                                                                                                                                  (type: 'rendercomplete', listener: (evt: RenderEvent) => void): EventsKey;
                                                                                                                                                                                                                  (
                                                                                                                                                                                                                  type: 'singleclick',
                                                                                                                                                                                                                  listener: (evt: MapBrowserEvent<UIEvent>) => void
                                                                                                                                                                                                                  ): EventsKey;
                                                                                                                                                                                                                  };

                                                                                                                                                                                                                    method once

                                                                                                                                                                                                                    once: {
                                                                                                                                                                                                                    (type: string | string[], listener: (p0: any) => any):
                                                                                                                                                                                                                    | EventsKey
                                                                                                                                                                                                                    | EventsKey[];
                                                                                                                                                                                                                    (type: 'change', listener: (evt: BaseEvent) => void): EventsKey;
                                                                                                                                                                                                                    (type: 'change:layerGroup', listener: (evt: ObjectEvent) => void): EventsKey;
                                                                                                                                                                                                                    (type: 'change:size', listener: (evt: ObjectEvent) => void): EventsKey;
                                                                                                                                                                                                                    (type: 'change:target', listener: (evt: ObjectEvent) => void): EventsKey;
                                                                                                                                                                                                                    (type: 'change:view', listener: (evt: ObjectEvent) => void): EventsKey;
                                                                                                                                                                                                                    (
                                                                                                                                                                                                                    type: 'click',
                                                                                                                                                                                                                    listener: (evt: MapBrowserEvent<UIEvent>) => void
                                                                                                                                                                                                                    ): EventsKey;
                                                                                                                                                                                                                    (
                                                                                                                                                                                                                    type: 'dblclick',
                                                                                                                                                                                                                    listener: (evt: MapBrowserEvent<UIEvent>) => void
                                                                                                                                                                                                                    ): EventsKey;
                                                                                                                                                                                                                    (type: 'error', listener: (evt: BaseEvent) => void): EventsKey;
                                                                                                                                                                                                                    (type: 'moveend', listener: (evt: MapEvent) => void): EventsKey;
                                                                                                                                                                                                                    (type: 'movestart', listener: (evt: MapEvent) => void): EventsKey;
                                                                                                                                                                                                                    (
                                                                                                                                                                                                                    type: 'pointerdrag',
                                                                                                                                                                                                                    listener: (evt: MapBrowserEvent<UIEvent>) => void
                                                                                                                                                                                                                    ): EventsKey;
                                                                                                                                                                                                                    (
                                                                                                                                                                                                                    type: 'pointermove',
                                                                                                                                                                                                                    listener: (evt: MapBrowserEvent<UIEvent>) => void
                                                                                                                                                                                                                    ): EventsKey;
                                                                                                                                                                                                                    (type: 'postcompose', listener: (evt: RenderEvent) => void): EventsKey;
                                                                                                                                                                                                                    (type: 'postrender', listener: (evt: MapEvent) => void): EventsKey;
                                                                                                                                                                                                                    (type: 'precompose', listener: (evt: RenderEvent) => void): EventsKey;
                                                                                                                                                                                                                    (type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey;
                                                                                                                                                                                                                    (type: 'rendercomplete', listener: (evt: RenderEvent) => void): EventsKey;
                                                                                                                                                                                                                    (
                                                                                                                                                                                                                    type: 'singleclick',
                                                                                                                                                                                                                    listener: (evt: MapBrowserEvent<UIEvent>) => void
                                                                                                                                                                                                                    ): EventsKey;
                                                                                                                                                                                                                    };

                                                                                                                                                                                                                      method redrawText

                                                                                                                                                                                                                      redrawText: () => void;
                                                                                                                                                                                                                      • Redraws all text after new fonts have loaded

                                                                                                                                                                                                                      method removeControl

                                                                                                                                                                                                                      removeControl: (control: Control) => Control | undefined;
                                                                                                                                                                                                                      • Remove the given control from the map.

                                                                                                                                                                                                                      method removeInteraction

                                                                                                                                                                                                                      removeInteraction: (interaction: Interaction) => Interaction | undefined;
                                                                                                                                                                                                                      • Remove the given interaction from the map.

                                                                                                                                                                                                                      method removeLayer

                                                                                                                                                                                                                      removeLayer: (layer: BaseLayer) => BaseLayer | undefined;
                                                                                                                                                                                                                      • Removes the given layer from the map.

                                                                                                                                                                                                                      method removeOverlay

                                                                                                                                                                                                                      removeOverlay: (overlay: Overlay) => Overlay | undefined;
                                                                                                                                                                                                                      • Remove the given overlay from the map.

                                                                                                                                                                                                                      method render

                                                                                                                                                                                                                      render: () => void;
                                                                                                                                                                                                                      • Request a map rendering (at the next animation frame).

                                                                                                                                                                                                                      method renderSync

                                                                                                                                                                                                                      renderSync: () => void;
                                                                                                                                                                                                                      • Requests an immediate render in a synchronous manner.

                                                                                                                                                                                                                      method setLayerGroup

                                                                                                                                                                                                                      setLayerGroup: (layerGroup: LayerGroup) => void;
                                                                                                                                                                                                                      • Sets the layergroup of this map.

                                                                                                                                                                                                                      method setSize

                                                                                                                                                                                                                      setSize: (size: Size | undefined) => void;
                                                                                                                                                                                                                      • Set the size of this map.

                                                                                                                                                                                                                      method setTarget

                                                                                                                                                                                                                      setTarget: (target: HTMLElement | string | undefined) => void;
                                                                                                                                                                                                                      • Set the target element to render this map into.

                                                                                                                                                                                                                      method setView

                                                                                                                                                                                                                      setView: (view: View) => void;
                                                                                                                                                                                                                      • Set the view for this map.

                                                                                                                                                                                                                      method un

                                                                                                                                                                                                                      un: {
                                                                                                                                                                                                                      (type: string | string[], listener: (p0: any) => any): void;
                                                                                                                                                                                                                      (type: 'change', listener: (evt: BaseEvent) => void): void;
                                                                                                                                                                                                                      (type: 'change:layerGroup', listener: (evt: ObjectEvent) => void): void;
                                                                                                                                                                                                                      (type: 'change:size', listener: (evt: ObjectEvent) => void): void;
                                                                                                                                                                                                                      (type: 'change:target', listener: (evt: ObjectEvent) => void): void;
                                                                                                                                                                                                                      (type: 'change:view', listener: (evt: ObjectEvent) => void): void;
                                                                                                                                                                                                                      (type: 'click', listener: (evt: MapBrowserEvent<UIEvent>) => void): void;
                                                                                                                                                                                                                      (type: 'dblclick', listener: (evt: MapBrowserEvent<UIEvent>) => void): void;
                                                                                                                                                                                                                      (type: 'error', listener: (evt: BaseEvent) => void): void;
                                                                                                                                                                                                                      (type: 'moveend', listener: (evt: MapEvent) => void): void;
                                                                                                                                                                                                                      (type: 'movestart', listener: (evt: MapEvent) => void): void;
                                                                                                                                                                                                                      (
                                                                                                                                                                                                                      type: 'pointerdrag',
                                                                                                                                                                                                                      listener: (evt: MapBrowserEvent<UIEvent>) => void
                                                                                                                                                                                                                      ): void;
                                                                                                                                                                                                                      (
                                                                                                                                                                                                                      type: 'pointermove',
                                                                                                                                                                                                                      listener: (evt: MapBrowserEvent<UIEvent>) => void
                                                                                                                                                                                                                      ): void;
                                                                                                                                                                                                                      (type: 'postcompose', listener: (evt: RenderEvent) => void): void;
                                                                                                                                                                                                                      (type: 'postrender', listener: (evt: MapEvent) => void): void;
                                                                                                                                                                                                                      (type: 'precompose', listener: (evt: RenderEvent) => void): void;
                                                                                                                                                                                                                      (type: 'propertychange', listener: (evt: ObjectEvent) => void): void;
                                                                                                                                                                                                                      (type: 'rendercomplete', listener: (evt: RenderEvent) => void): void;
                                                                                                                                                                                                                      (
                                                                                                                                                                                                                      type: 'singleclick',
                                                                                                                                                                                                                      listener: (evt: MapBrowserEvent<UIEvent>) => void
                                                                                                                                                                                                                      ): void;
                                                                                                                                                                                                                      };

                                                                                                                                                                                                                        method updateSize

                                                                                                                                                                                                                        updateSize: () => void;
                                                                                                                                                                                                                        • Force a recalculation of the map viewport size. This should be called when third-party code changes the size of the map viewport.

                                                                                                                                                                                                                        class Tile

                                                                                                                                                                                                                        abstract class Tile extends Target {}

                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                          constructor(tileCoord: TileCoord, state: TileState, opt_options?: Options);

                                                                                                                                                                                                                            property state

                                                                                                                                                                                                                            protected state: TileState;

                                                                                                                                                                                                                              method changed

                                                                                                                                                                                                                              protected changed: () => void;

                                                                                                                                                                                                                                method endTransition

                                                                                                                                                                                                                                endTransition: (id: string) => void;
                                                                                                                                                                                                                                • Mark a transition as complete.

                                                                                                                                                                                                                                method getAlpha

                                                                                                                                                                                                                                getAlpha: (id: string, time: number) => number;
                                                                                                                                                                                                                                • Get the alpha value for rendering.

                                                                                                                                                                                                                                method getInterimTile

                                                                                                                                                                                                                                getInterimTile: () => Tile;
                                                                                                                                                                                                                                • Get the interim tile most suitable for rendering using the chain of interim tiles. This corresponds to the most recent tile that has been loaded, if no such tile exists, the original tile is returned.

                                                                                                                                                                                                                                method getKey

                                                                                                                                                                                                                                getKey: () => string;

                                                                                                                                                                                                                                  method getState

                                                                                                                                                                                                                                  getState: () => TileState;

                                                                                                                                                                                                                                    method getTileCoord

                                                                                                                                                                                                                                    getTileCoord: () => TileCoord;
                                                                                                                                                                                                                                    • Get the tile coordinate for this tile.

                                                                                                                                                                                                                                    method inTransition

                                                                                                                                                                                                                                    inTransition: (id: string) => boolean;
                                                                                                                                                                                                                                    • Determine if a tile is in an alpha transition. A tile is considered in transition if tile.getAlpha() has not yet been called or has been called and returned 1.

                                                                                                                                                                                                                                    method load

                                                                                                                                                                                                                                    abstract load: () => void;
                                                                                                                                                                                                                                    • Load the image or retry if loading previously failed. Loading is taken care of by the tile queue, and calling this method is only needed for preloading or for reloading in case of an error.

                                                                                                                                                                                                                                    method refreshInterimChain

                                                                                                                                                                                                                                    refreshInterimChain: () => void;
                                                                                                                                                                                                                                    • Goes through the chain of interim tiles and discards sections of the chain that are no longer relevant.

                                                                                                                                                                                                                                    method release

                                                                                                                                                                                                                                    release: () => void;
                                                                                                                                                                                                                                    • Called by the tile cache when the tile is removed from the cache due to expiry

                                                                                                                                                                                                                                    method setState

                                                                                                                                                                                                                                    setState: (state: TileState) => void;
                                                                                                                                                                                                                                    • Sets the state of this tile. If you write your own , it is important to set the state correctly to when the tile cannot be loaded. Otherwise the tile cannot be removed from the tile queue and will block other requests.

                                                                                                                                                                                                                                    class TileCache

                                                                                                                                                                                                                                    class TileCache extends LRUCache<any> {}

                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                      constructor();

                                                                                                                                                                                                                                        method expireCache

                                                                                                                                                                                                                                        expireCache: (usedTiles: { [key: string]: boolean }) => void;

                                                                                                                                                                                                                                          method on

                                                                                                                                                                                                                                          on: {
                                                                                                                                                                                                                                          (type: string | string[], listener: (p0: any) => any):
                                                                                                                                                                                                                                          | EventsKey
                                                                                                                                                                                                                                          | EventsKey[];
                                                                                                                                                                                                                                          (type: 'change', listener: (evt: BaseEvent) => void): EventsKey;
                                                                                                                                                                                                                                          (type: 'error', listener: (evt: BaseEvent) => void): EventsKey;
                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                            method once

                                                                                                                                                                                                                                            once: {
                                                                                                                                                                                                                                            (type: string | string[], listener: (p0: any) => any):
                                                                                                                                                                                                                                            | EventsKey
                                                                                                                                                                                                                                            | EventsKey[];
                                                                                                                                                                                                                                            (type: 'change', listener: (evt: BaseEvent) => void): EventsKey;
                                                                                                                                                                                                                                            (type: 'error', listener: (evt: BaseEvent) => void): EventsKey;
                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                              method pruneExceptNewestZ

                                                                                                                                                                                                                                              pruneExceptNewestZ: () => void;
                                                                                                                                                                                                                                              • Prune all tiles from the cache that don't have the same z as the newest tile.

                                                                                                                                                                                                                                              method un

                                                                                                                                                                                                                                              un: {
                                                                                                                                                                                                                                              (type: string | string[], listener: (p0: any) => any): void;
                                                                                                                                                                                                                                              (type: 'change', listener: (evt: BaseEvent) => void): void;
                                                                                                                                                                                                                                              (type: 'error', listener: (evt: BaseEvent) => void): void;
                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                class TileQueue

                                                                                                                                                                                                                                                class TileQueue extends PriorityQueue<any> {}

                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                  constructor(
                                                                                                                                                                                                                                                  tilePriorityFunction: PriorityFunction,
                                                                                                                                                                                                                                                  tileChangeCallback: () => any
                                                                                                                                                                                                                                                  );

                                                                                                                                                                                                                                                    method enqueue

                                                                                                                                                                                                                                                    enqueue: (element: any[]) => boolean;

                                                                                                                                                                                                                                                      method getTilesLoading

                                                                                                                                                                                                                                                      getTilesLoading: () => number;

                                                                                                                                                                                                                                                        method handleTileChange

                                                                                                                                                                                                                                                        protected handleTileChange: (event: BaseEvent) => void;

                                                                                                                                                                                                                                                          method loadMoreTiles

                                                                                                                                                                                                                                                          loadMoreTiles: (maxTotalLoading: number, maxNewLoads: number) => void;

                                                                                                                                                                                                                                                            class TileRange

                                                                                                                                                                                                                                                            class TileRange {}

                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                              constructor(minX: number, maxX: number, minY: number, maxY: number);

                                                                                                                                                                                                                                                                method contains

                                                                                                                                                                                                                                                                contains: (tileCoord: TileCoord) => boolean;

                                                                                                                                                                                                                                                                  method containsTileRange

                                                                                                                                                                                                                                                                  containsTileRange: (tileRange: TileRange) => boolean;

                                                                                                                                                                                                                                                                    method containsXY

                                                                                                                                                                                                                                                                    containsXY: (x: number, y: number) => boolean;

                                                                                                                                                                                                                                                                      method equals

                                                                                                                                                                                                                                                                      equals: (tileRange: TileRange) => boolean;

                                                                                                                                                                                                                                                                        method extend

                                                                                                                                                                                                                                                                        extend: (tileRange: TileRange) => void;

                                                                                                                                                                                                                                                                          method getHeight

                                                                                                                                                                                                                                                                          getHeight: () => number;

                                                                                                                                                                                                                                                                            method getSize

                                                                                                                                                                                                                                                                            getSize: () => Size;

                                                                                                                                                                                                                                                                              method getWidth

                                                                                                                                                                                                                                                                              getWidth: () => number;

                                                                                                                                                                                                                                                                                method intersects

                                                                                                                                                                                                                                                                                intersects: (tileRange: TileRange) => boolean;

                                                                                                                                                                                                                                                                                  class VectorRenderTile

                                                                                                                                                                                                                                                                                  class VectorRenderTile extends Tile {}

                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                    constructor(
                                                                                                                                                                                                                                                                                    tileCoord: TileCoord,
                                                                                                                                                                                                                                                                                    state: TileState,
                                                                                                                                                                                                                                                                                    urlTileCoord: TileCoord,
                                                                                                                                                                                                                                                                                    getSourceTiles: (p0: VectorRenderTile) => VectorTile[]
                                                                                                                                                                                                                                                                                    );

                                                                                                                                                                                                                                                                                      method getContext

                                                                                                                                                                                                                                                                                      getContext: (layer: Layer<Source>) => CanvasRenderingContext2D;

                                                                                                                                                                                                                                                                                        method getImage

                                                                                                                                                                                                                                                                                        getImage: (layer: Layer<Source>) => HTMLCanvasElement;
                                                                                                                                                                                                                                                                                        • Get the Canvas for this tile.

                                                                                                                                                                                                                                                                                        method getReplayState

                                                                                                                                                                                                                                                                                        getReplayState: (layer: Layer<Source>) => ReplayState;

                                                                                                                                                                                                                                                                                          method hasContext

                                                                                                                                                                                                                                                                                          hasContext: (layer: Layer<Source>) => boolean;

                                                                                                                                                                                                                                                                                            method load

                                                                                                                                                                                                                                                                                            load: () => void;
                                                                                                                                                                                                                                                                                            • Load the tile.

                                                                                                                                                                                                                                                                                            method release

                                                                                                                                                                                                                                                                                            release: () => void;
                                                                                                                                                                                                                                                                                            • Remove from the cache due to expiry

                                                                                                                                                                                                                                                                                            class VectorTile

                                                                                                                                                                                                                                                                                            class VectorTile extends Tile {}

                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                              constructor(
                                                                                                                                                                                                                                                                                              tileCoord: TileCoord,
                                                                                                                                                                                                                                                                                              state: TileState,
                                                                                                                                                                                                                                                                                              src: string,
                                                                                                                                                                                                                                                                                              format: FeatureFormat,
                                                                                                                                                                                                                                                                                              tileLoadFunction: LoadFunction,
                                                                                                                                                                                                                                                                                              opt_options?: Options
                                                                                                                                                                                                                                                                                              );

                                                                                                                                                                                                                                                                                                method getFeatures

                                                                                                                                                                                                                                                                                                getFeatures: () => FeatureLike[];
                                                                                                                                                                                                                                                                                                • Get the features for this tile. Geometries will be in the view projection.

                                                                                                                                                                                                                                                                                                method getFormat

                                                                                                                                                                                                                                                                                                getFormat: () => FeatureFormat;
                                                                                                                                                                                                                                                                                                • Get the feature format assigned for reading this tile's features.

                                                                                                                                                                                                                                                                                                method load

                                                                                                                                                                                                                                                                                                load: () => void;
                                                                                                                                                                                                                                                                                                • Load not yet loaded URI.

                                                                                                                                                                                                                                                                                                method onError

                                                                                                                                                                                                                                                                                                onError: () => void;
                                                                                                                                                                                                                                                                                                • Handler for tile load errors.

                                                                                                                                                                                                                                                                                                method onLoad

                                                                                                                                                                                                                                                                                                onLoad: (features: Feature<Geometry>[], dataProjection: Projection) => void;
                                                                                                                                                                                                                                                                                                • Handler for successful tile load.

                                                                                                                                                                                                                                                                                                method setFeatures

                                                                                                                                                                                                                                                                                                setFeatures: (features: Feature<Geometry>[]) => void;
                                                                                                                                                                                                                                                                                                • Function for use in an 's tileLoadFunction. Sets the features for the tile.

                                                                                                                                                                                                                                                                                                method setLoader

                                                                                                                                                                                                                                                                                                setLoader: (loader: FeatureLoader) => void;
                                                                                                                                                                                                                                                                                                • Set the feature loader for reading this tile's features.

                                                                                                                                                                                                                                                                                                class View

                                                                                                                                                                                                                                                                                                class View extends BaseObject {}

                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                  constructor(opt_options?: ViewOptions);

                                                                                                                                                                                                                                                                                                    property padding

                                                                                                                                                                                                                                                                                                    padding: number[];
                                                                                                                                                                                                                                                                                                    • Padding (in css pixels). If the map viewport is partially covered with other content (overlays) along its edges, this setting allows to shift the center of the viewport away from that content. The order of the values in the array is top, right, bottom, left. The default is no padding, which is equivalent to [0, 0, 0, 0].

                                                                                                                                                                                                                                                                                                    method adjustCenter

                                                                                                                                                                                                                                                                                                    adjustCenter: (deltaCoordinates: Coordinate) => void;
                                                                                                                                                                                                                                                                                                    • Adds relative coordinates to the center of the view. Any extent constraint will apply.

                                                                                                                                                                                                                                                                                                    method adjustCenterInternal

                                                                                                                                                                                                                                                                                                    adjustCenterInternal: (deltaCoordinates: Coordinate) => void;
                                                                                                                                                                                                                                                                                                    • Adds relative coordinates to the center of the view. Any extent constraint will apply.

                                                                                                                                                                                                                                                                                                    method adjustResolution

                                                                                                                                                                                                                                                                                                    adjustResolution: (ratio: number, opt_anchor?: Coordinate) => void;
                                                                                                                                                                                                                                                                                                    • Multiply the view resolution by a ratio, optionally using an anchor. Any resolution constraint will apply.

                                                                                                                                                                                                                                                                                                    method adjustResolutionInternal

                                                                                                                                                                                                                                                                                                    adjustResolutionInternal: (ratio: number, opt_anchor?: Coordinate) => void;
                                                                                                                                                                                                                                                                                                    • Multiply the view resolution by a ratio, optionally using an anchor. Any resolution constraint will apply.

                                                                                                                                                                                                                                                                                                    method adjustRotation

                                                                                                                                                                                                                                                                                                    adjustRotation: (delta: number, opt_anchor?: Coordinate) => void;
                                                                                                                                                                                                                                                                                                    • Adds a value to the view rotation, optionally using an anchor. Any rotation constraint will apply.

                                                                                                                                                                                                                                                                                                    method adjustRotationInternal

                                                                                                                                                                                                                                                                                                    adjustRotationInternal: (delta: number, opt_anchor?: Coordinate) => void;

                                                                                                                                                                                                                                                                                                      method adjustZoom

                                                                                                                                                                                                                                                                                                      adjustZoom: (delta: number, opt_anchor?: Coordinate) => void;
                                                                                                                                                                                                                                                                                                      • Adds a value to the view zoom level, optionally using an anchor. Any resolution constraint will apply.

                                                                                                                                                                                                                                                                                                      method animate

                                                                                                                                                                                                                                                                                                      animate: (...var_args: (AnimationOptions | ((p0: boolean) => void))[]) => void;
                                                                                                                                                                                                                                                                                                      • Animate the view. The view's center, zoom (or resolution), and rotation can be animated for smooth transitions between view states. For example, to animate the view to a new zoom level: view.animate({zoom: view.getZoom() + 1});By default, the animation lasts one second and uses in-and-out easing. You can customize this behavior by including duration (in milliseconds) and easing options (see ). To chain together multiple animations, call the method with multiple animation objects. For example, to first zoom and then pan: view.animate({zoom: 10}, {center: [0, 0]});If you provide a function as the last argument to the animate method, it will get called at the end of an animation series. The callback will be called with true if the animation series completed on its own or false if it was cancelled. Animations are cancelled by user interactions (e.g. dragging the map) or by calling view.setCenter(), view.setResolution(), or view.setRotation() (or another method that calls one of these).

                                                                                                                                                                                                                                                                                                      method animateInternal

                                                                                                                                                                                                                                                                                                      animateInternal: (
                                                                                                                                                                                                                                                                                                      ...var_args: (AnimationOptions | ((p0: boolean) => void))[]
                                                                                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                                                                                        method applyOptions_

                                                                                                                                                                                                                                                                                                        applyOptions_: (options: ViewOptions) => void;
                                                                                                                                                                                                                                                                                                        • Set up the view with the given options.

                                                                                                                                                                                                                                                                                                        method beginInteraction

                                                                                                                                                                                                                                                                                                        beginInteraction: () => void;
                                                                                                                                                                                                                                                                                                        • Notify the View that an interaction has started. The view state will be resolved to a stable one if needed (depending on its constraints).

                                                                                                                                                                                                                                                                                                        method calculateCenterRotate

                                                                                                                                                                                                                                                                                                        calculateCenterRotate: (
                                                                                                                                                                                                                                                                                                        rotation: number,
                                                                                                                                                                                                                                                                                                        anchor: Coordinate
                                                                                                                                                                                                                                                                                                        ) => Coordinate | undefined;

                                                                                                                                                                                                                                                                                                          method calculateCenterShift

                                                                                                                                                                                                                                                                                                          calculateCenterShift: (
                                                                                                                                                                                                                                                                                                          center: Coordinate,
                                                                                                                                                                                                                                                                                                          resolution: number,
                                                                                                                                                                                                                                                                                                          rotation: number,
                                                                                                                                                                                                                                                                                                          size: Size
                                                                                                                                                                                                                                                                                                          ) => number[] | undefined;
                                                                                                                                                                                                                                                                                                          • Calculates the shift between map and viewport center.

                                                                                                                                                                                                                                                                                                          method calculateCenterZoom

                                                                                                                                                                                                                                                                                                          calculateCenterZoom: (
                                                                                                                                                                                                                                                                                                          resolution: number,
                                                                                                                                                                                                                                                                                                          anchor: Coordinate
                                                                                                                                                                                                                                                                                                          ) => Coordinate | undefined;

                                                                                                                                                                                                                                                                                                            method calculateExtent

                                                                                                                                                                                                                                                                                                            calculateExtent: (opt_size?: Size) => Extent;
                                                                                                                                                                                                                                                                                                            • Calculate the extent for the current view state and the passed size. The size is the pixel dimensions of the box into which the calculated extent should fit. In most cases you want to get the extent of the entire map, that is map.getSize().

                                                                                                                                                                                                                                                                                                            method calculateExtentInternal

                                                                                                                                                                                                                                                                                                            calculateExtentInternal: (opt_size?: Size) => Extent;

                                                                                                                                                                                                                                                                                                              method cancelAnimations

                                                                                                                                                                                                                                                                                                              cancelAnimations: () => void;
                                                                                                                                                                                                                                                                                                              • Cancel any ongoing animations.

                                                                                                                                                                                                                                                                                                              method centerOn

                                                                                                                                                                                                                                                                                                              centerOn: (coordinate: Coordinate, size: Size, position: Pixel) => void;
                                                                                                                                                                                                                                                                                                              • Center on coordinate and view position.

                                                                                                                                                                                                                                                                                                              method centerOnInternal

                                                                                                                                                                                                                                                                                                              centerOnInternal: (coordinate: Coordinate, size: Size, position: Pixel) => void;

                                                                                                                                                                                                                                                                                                                method endInteraction

                                                                                                                                                                                                                                                                                                                endInteraction: (
                                                                                                                                                                                                                                                                                                                opt_duration?: number,
                                                                                                                                                                                                                                                                                                                opt_resolutionDirection?: number,
                                                                                                                                                                                                                                                                                                                opt_anchor?: Coordinate
                                                                                                                                                                                                                                                                                                                ) => void;
                                                                                                                                                                                                                                                                                                                • Notify the View that an interaction has ended. The view state will be resolved to a stable one if needed (depending on its constraints).

                                                                                                                                                                                                                                                                                                                method endInteractionInternal

                                                                                                                                                                                                                                                                                                                endInteractionInternal: (
                                                                                                                                                                                                                                                                                                                opt_duration?: number,
                                                                                                                                                                                                                                                                                                                opt_resolutionDirection?: number,
                                                                                                                                                                                                                                                                                                                opt_anchor?: Coordinate
                                                                                                                                                                                                                                                                                                                ) => void;
                                                                                                                                                                                                                                                                                                                • Notify the View that an interaction has ended. The view state will be resolved to a stable one if needed (depending on its constraints).

                                                                                                                                                                                                                                                                                                                method fit

                                                                                                                                                                                                                                                                                                                fit: (
                                                                                                                                                                                                                                                                                                                geometryOrExtent: SimpleGeometry | Extent,
                                                                                                                                                                                                                                                                                                                opt_options?: FitOptions
                                                                                                                                                                                                                                                                                                                ) => void;
                                                                                                                                                                                                                                                                                                                • Fit the given geometry or extent based on the given map size and border. The size is pixel dimensions of the box to fit the extent into. In most cases you will want to use the map size, that is map.getSize(). Takes care of the map angle.

                                                                                                                                                                                                                                                                                                                method fitInternal

                                                                                                                                                                                                                                                                                                                fitInternal: (geometry: SimpleGeometry, opt_options?: FitOptions) => void;

                                                                                                                                                                                                                                                                                                                  method getAnimating

                                                                                                                                                                                                                                                                                                                  getAnimating: () => boolean;
                                                                                                                                                                                                                                                                                                                  • Determine if the view is being animated.

                                                                                                                                                                                                                                                                                                                  method getCenter

                                                                                                                                                                                                                                                                                                                  getCenter: () => Coordinate | undefined;
                                                                                                                                                                                                                                                                                                                  • Get the view center.

                                                                                                                                                                                                                                                                                                                  method getCenterInternal

                                                                                                                                                                                                                                                                                                                  getCenterInternal: () => Coordinate | undefined;
                                                                                                                                                                                                                                                                                                                  • Get the view center without transforming to user projection.

                                                                                                                                                                                                                                                                                                                  method getConstrainedCenter

                                                                                                                                                                                                                                                                                                                  getConstrainedCenter: (
                                                                                                                                                                                                                                                                                                                  targetCenter: Coordinate | undefined,
                                                                                                                                                                                                                                                                                                                  opt_targetResolution?: number
                                                                                                                                                                                                                                                                                                                  ) => Coordinate | undefined;
                                                                                                                                                                                                                                                                                                                  • Get a valid position for the view center according to the current constraints.

                                                                                                                                                                                                                                                                                                                  method getConstrainedResolution

                                                                                                                                                                                                                                                                                                                  getConstrainedResolution: (
                                                                                                                                                                                                                                                                                                                  targetResolution: number | undefined,
                                                                                                                                                                                                                                                                                                                  opt_direction?: number
                                                                                                                                                                                                                                                                                                                  ) => number | undefined;
                                                                                                                                                                                                                                                                                                                  • Get a valid resolution according to the current view constraints.

                                                                                                                                                                                                                                                                                                                  method getConstrainedZoom

                                                                                                                                                                                                                                                                                                                  getConstrainedZoom: (
                                                                                                                                                                                                                                                                                                                  targetZoom: number | undefined,
                                                                                                                                                                                                                                                                                                                  opt_direction?: number
                                                                                                                                                                                                                                                                                                                  ) => number | undefined;
                                                                                                                                                                                                                                                                                                                  • Get a valid zoom level according to the current view constraints.

                                                                                                                                                                                                                                                                                                                  method getConstrainResolution

                                                                                                                                                                                                                                                                                                                  getConstrainResolution: () => boolean;

                                                                                                                                                                                                                                                                                                                    method getConstraints

                                                                                                                                                                                                                                                                                                                    getConstraints: () => Constraints;

                                                                                                                                                                                                                                                                                                                      method getHints

                                                                                                                                                                                                                                                                                                                      getHints: (opt_hints?: number[]) => number[];

                                                                                                                                                                                                                                                                                                                        method getInteracting

                                                                                                                                                                                                                                                                                                                        getInteracting: () => boolean;
                                                                                                                                                                                                                                                                                                                        • Determine if the user is interacting with the view, such as panning or zooming.

                                                                                                                                                                                                                                                                                                                        method getMaxResolution

                                                                                                                                                                                                                                                                                                                        getMaxResolution: () => number;
                                                                                                                                                                                                                                                                                                                        • Get the maximum resolution of the view.

                                                                                                                                                                                                                                                                                                                        method getMaxZoom

                                                                                                                                                                                                                                                                                                                        getMaxZoom: () => number;
                                                                                                                                                                                                                                                                                                                        • Get the maximum zoom level for the view.

                                                                                                                                                                                                                                                                                                                        method getMinResolution

                                                                                                                                                                                                                                                                                                                        getMinResolution: () => number;
                                                                                                                                                                                                                                                                                                                        • Get the minimum resolution of the view.

                                                                                                                                                                                                                                                                                                                        method getMinZoom

                                                                                                                                                                                                                                                                                                                        getMinZoom: () => number;
                                                                                                                                                                                                                                                                                                                        • Get the minimum zoom level for the view.

                                                                                                                                                                                                                                                                                                                        method getProjection

                                                                                                                                                                                                                                                                                                                        getProjection: () => Projection;
                                                                                                                                                                                                                                                                                                                        • Get the view projection.

                                                                                                                                                                                                                                                                                                                        method getResolution

                                                                                                                                                                                                                                                                                                                        getResolution: () => number | undefined;
                                                                                                                                                                                                                                                                                                                        • Get the view resolution.

                                                                                                                                                                                                                                                                                                                        method getResolutionForExtent

                                                                                                                                                                                                                                                                                                                        getResolutionForExtent: (extent: Extent, opt_size?: Size) => number;
                                                                                                                                                                                                                                                                                                                        • Get the resolution for a provided extent (in map units) and size (in pixels).

                                                                                                                                                                                                                                                                                                                        method getResolutionForExtentInternal

                                                                                                                                                                                                                                                                                                                        getResolutionForExtentInternal: (extent: Extent, opt_size?: Size) => number;
                                                                                                                                                                                                                                                                                                                        • Get the resolution for a provided extent (in map units) and size (in pixels).

                                                                                                                                                                                                                                                                                                                        method getResolutionForValueFunction

                                                                                                                                                                                                                                                                                                                        getResolutionForValueFunction: (opt_power?: number) => (p0: number) => number;
                                                                                                                                                                                                                                                                                                                        • Return a function that returns a value between 0 and 1 for a resolution. Exponential scaling is assumed.

                                                                                                                                                                                                                                                                                                                        method getResolutionForZoom

                                                                                                                                                                                                                                                                                                                        getResolutionForZoom: (zoom: number) => number;
                                                                                                                                                                                                                                                                                                                        • Get the resolution for a zoom level.

                                                                                                                                                                                                                                                                                                                        method getResolutions

                                                                                                                                                                                                                                                                                                                        getResolutions: () => number[] | undefined;
                                                                                                                                                                                                                                                                                                                        • Get the resolutions for the view. This returns the array of resolutions passed to the constructor of the View, or undefined if none were given.

                                                                                                                                                                                                                                                                                                                        method getRotation

                                                                                                                                                                                                                                                                                                                        getRotation: () => number;
                                                                                                                                                                                                                                                                                                                        • Get the view rotation.

                                                                                                                                                                                                                                                                                                                        method getState

                                                                                                                                                                                                                                                                                                                        getState: () => State;

                                                                                                                                                                                                                                                                                                                          method getUpdatedOptions_

                                                                                                                                                                                                                                                                                                                          getUpdatedOptions_: (newOptions: ViewOptions) => ViewOptions;
                                                                                                                                                                                                                                                                                                                          • Get an updated version of the view options used to construct the view. The current resolution (or zoom), center, and rotation are applied to any stored options. The provided options can be used to apply new min/max zoom or resolution limits.

                                                                                                                                                                                                                                                                                                                          method getValueForResolutionFunction

                                                                                                                                                                                                                                                                                                                          getValueForResolutionFunction: (opt_power?: number) => (p0: number) => number;
                                                                                                                                                                                                                                                                                                                          • Return a function that returns a resolution for a value between 0 and 1. Exponential scaling is assumed.

                                                                                                                                                                                                                                                                                                                          method getZoom

                                                                                                                                                                                                                                                                                                                          getZoom: () => number | undefined;
                                                                                                                                                                                                                                                                                                                          • Get the current zoom level. This method may return non-integer zoom levels if the view does not constrain the resolution, or if an interaction or animation is underway.

                                                                                                                                                                                                                                                                                                                          method getZoomForResolution

                                                                                                                                                                                                                                                                                                                          getZoomForResolution: (resolution: number) => number | undefined;
                                                                                                                                                                                                                                                                                                                          • Get the zoom level for a resolution.

                                                                                                                                                                                                                                                                                                                          method isDef

                                                                                                                                                                                                                                                                                                                          isDef: () => boolean;

                                                                                                                                                                                                                                                                                                                            method on

                                                                                                                                                                                                                                                                                                                            on: {
                                                                                                                                                                                                                                                                                                                            (type: string | string[], listener: (p0: any) => any):
                                                                                                                                                                                                                                                                                                                            | EventsKey
                                                                                                                                                                                                                                                                                                                            | EventsKey[];
                                                                                                                                                                                                                                                                                                                            (type: 'change', listener: (evt: BaseEvent) => void): EventsKey;
                                                                                                                                                                                                                                                                                                                            (type: 'change:center', listener: (evt: ObjectEvent) => void): EventsKey;
                                                                                                                                                                                                                                                                                                                            (type: 'change:resolution', listener: (evt: ObjectEvent) => void): EventsKey;
                                                                                                                                                                                                                                                                                                                            (type: 'change:rotation', listener: (evt: ObjectEvent) => void): EventsKey;
                                                                                                                                                                                                                                                                                                                            (type: 'error', listener: (evt: BaseEvent) => void): EventsKey;
                                                                                                                                                                                                                                                                                                                            (type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey;
                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                              method once

                                                                                                                                                                                                                                                                                                                              once: {
                                                                                                                                                                                                                                                                                                                              (type: string | string[], listener: (p0: any) => any):
                                                                                                                                                                                                                                                                                                                              | EventsKey
                                                                                                                                                                                                                                                                                                                              | EventsKey[];
                                                                                                                                                                                                                                                                                                                              (type: 'change', listener: (evt: BaseEvent) => void): EventsKey;
                                                                                                                                                                                                                                                                                                                              (type: 'change:center', listener: (evt: ObjectEvent) => void): EventsKey;
                                                                                                                                                                                                                                                                                                                              (type: 'change:resolution', listener: (evt: ObjectEvent) => void): EventsKey;
                                                                                                                                                                                                                                                                                                                              (type: 'change:rotation', listener: (evt: ObjectEvent) => void): EventsKey;
                                                                                                                                                                                                                                                                                                                              (type: 'error', listener: (evt: BaseEvent) => void): EventsKey;
                                                                                                                                                                                                                                                                                                                              (type: 'propertychange', listener: (evt: ObjectEvent) => void): EventsKey;
                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                method resolveConstraints

                                                                                                                                                                                                                                                                                                                                resolveConstraints: (
                                                                                                                                                                                                                                                                                                                                opt_duration?: number,
                                                                                                                                                                                                                                                                                                                                opt_resolutionDirection?: number,
                                                                                                                                                                                                                                                                                                                                opt_anchor?: Coordinate</