# Source: externs/olx.js

    /**
     * @type {Object}
     */
    var olx;

    /* typedefs for object literals provided by applications */

    /**
     * @typedef {{html: string,
     *     tileRanges: (Object.<string, Array.<ol.TileRange>>|undefined)}}
     * @todo api
     */
    olx.AttributionOptions;

    /**
     * HTML markup for this attribution.
     * @type {string}
     */
    olx.AttributionOptions.prototype.html;

    /**
     * Tile ranges (FOR INTERNAL USE ONLY).
     * @type {Object.<string, Array.<ol.TileRange>>|undefined}
     */
    olx.AttributionOptions.prototype.tileRanges;

    /**
     * @typedef {{loadTilesWhileAnimating: (boolean|undefined),
     *     loadTilesWhileInteracting: (boolean|undefined)}}
     * @todo api
     */
    olx.DeviceOptions;

    /**
     * When set to false, no tiles will be loaded while animating, which improves
     * responsiveness on devices with slow memory. Default is `true`.
     * @type {boolean|undefined}
     */
    olx.DeviceOptions.prototype.loadTilesWhileAnimating;

    /**
     * When set to false, no tiles will be loaded while interacting, which improves
     * responsiveness on devices with slow memory. Default is `true`.
     * @type {boolean|undefined}
     */
    olx.DeviceOptions.prototype.loadTilesWhileInteracting;

    /**
     * @typedef {{tracking: (boolean|undefined)}}
     * @todo api
     */
    olx.DeviceOrientationOptions;

    /**
     * Start tracking. Default is `false`.
     * @type {boolean|undefined}
     */
    olx.DeviceOrientationOptions.prototype.tracking;

    /**
     * @typedef {{tracking: (boolean|undefined),
     *     trackingOptions: (GeolocationPositionOptions|undefined),
     *     projection: ol.proj.ProjectionLike}}
     * @todo api
     */
    olx.GeolocationOptions;

    /**
     * Start Tracking. Default is `false`.
     * @type {boolean|undefined}
     */
    olx.GeolocationOptions.prototype.tracking;

    /**
     * Tracking options. See
     * {@link http://www.w3.org/TR/geolocation-API/#position_options_interface}.
     * @type {GeolocationPositionOptions|undefined}
     */
    olx.GeolocationOptions.prototype.trackingOptions;

    /**
     * Projection.
     * @type {ol.proj.ProjectionLike}
     */
    olx.GeolocationOptions.prototype.projection;

    /**
     * Object literal with config options for the map.
     * @typedef {{controls: (ol.Collection|Array.<ol.control.Control>|undefined),
     *     deviceOptions: (olx.DeviceOptions|undefined),
     *     pixelRatio: (number|undefined),
     *     interactions: (ol.Collection|Array.<ol.interaction.Interaction>|undefined),
     *     keyboardEventTarget: (Element|Document|string|undefined),
     *     layers: (Array.<ol.layer.Base>|ol.Collection|undefined),
     *     ol3Logo: (boolean|undefined),
     *     overlays: (ol.Collection|Array.<ol.Overlay>|undefined),
     *     renderer: (ol.RendererType|Array.<ol.RendererType|string>|string|undefined),
     *     target: (Element|string|undefined),
     *     view: (ol.IView|undefined)}}
     * @todo api
     */
    olx.MapOptions;

    /**
     * Controls initially added to the map.
     * @type {ol.Collection|Array.<ol.control.Control>|undefined}
     */
    olx.MapOptions.prototype.controls;

    /**
     * Device options for the map.
     * @type {olx.DeviceOptions|undefined}
     */
    olx.MapOptions.prototype.deviceOptions;

    /**
     * The ratio between physical pixels and device-independent pixels (dips) on the
     * device. If `undefined` then it gets set by using
     * {@link ol.BrowserFeature.DEVICE_PIXEL_RATIO}.
     * @type {number|undefined}
     */
    olx.MapOptions.prototype.pixelRatio;

    /**
     * Interactions that are initially added to the map.
     * @type {ol.Collection|Array.<ol.interaction.Interaction>|undefined}
     */
    olx.MapOptions.prototype.interactions;

    /**
     * The element to listen to keyboard events on. This determines when the
     * `KeyboardPan` and `KeyboardZoom` interactions trigger. For example, if this
     * option is set to `document` the keyboard interactions will always trigger. If
     * this option is not specified, the element the library listens to keyboard
     * events on is the map target (i.e. the user-provided div for the map). If this
     * is not `document` the target element needs to be focused for key events to be
     * emitted, requiring that the target element has a `tabindex` attribute.
     * @type {Element|Document|string|undefined}
     */
    olx.MapOptions.prototype.keyboardEventTarget;

    /**
     * Layers.
     * @type {Array.<ol.layer.Base>|ol.Collection|undefined}
     */
    olx.MapOptions.prototype.layers;

    /**
     * Show ol3 logo. Default is `true`.
     * @type {boolean|undefined}
     */
    olx.MapOptions.prototype.ol3Logo;

    /**
     * Overlays initially added to the map.
     * @type {ol.Collection|Array.<ol.Overlay>|undefined}
     */
    olx.MapOptions.prototype.overlays;

    /**
     * Renderer.
     * @type {ol.RendererType|Array.<ol.RendererType|string>|string|undefined}
     */
    olx.MapOptions.prototype.renderer;

    /**
     * The container for the map.
     * @type {Element|string|undefined}
     */
    olx.MapOptions.prototype.target;

    /**
     * The map's view.
     * @type {ol.IView|undefined}
     */
    olx.MapOptions.prototype.view;

    /**
     * Object literal with config options for the overlay.
     * @typedef {{element: (Element|undefined),
     *     position: (ol.Coordinate|undefined),
     *     positioning: (ol.OverlayPositioning|string|undefined),
     *     stopEvent: (boolean|undefined),
     *     insertFirst: (boolean|undefined),
     *     offsetX: (number|undefined),
     *     offsetY: (number|undefined)}}
     * @todo api
     */
    olx.OverlayOptions;

    /**
     * The overlay element.
     * @type {Element|undefined}
     */
    olx.OverlayOptions.prototype.element;

    /**
     * The overlay position in map projection.
     * @type {ol.Coordinate|undefined}
     */
    olx.OverlayOptions.prototype.position;

    /**
     * Positioning.
     * @type {ol.OverlayPositioning|string|undefined}
     */
    olx.OverlayOptions.prototype.positioning;

    /**
     * Whether event propagation to the map viewport should be stopped. Default is
     * `true`. If `true` the overlay is placed in the same container as that of the
     * controls (`ol-overlaycontainer-stopevent`).
     * @type {boolean|undefined}
     */
    olx.OverlayOptions.prototype.stopEvent;

    /**
     * Whether the overlay is inserted first in the overlay container, or appended.
     * Default is `true`. If the overlay is placed in the same container as that of
     * the controls (see the `stopEvent` option) you will probably set `insertFirst`
     * to `true` so the overlay is displayed below the controls.
     * @type {boolean|undefined}
     */
    olx.OverlayOptions.prototype.insertFirst;

    /**
     * Horizontal offset in pixels. A positive will shift the overlay right. Default
     * is `0`.
     * @type {number|undefined}
     */
    olx.OverlayOptions.prototype.offsetX;

    /**
     * Vertical offset in pixels. A positive will shift the overlay down. Default is
     * `0`.
     * @type {number|undefined}
     */
    olx.OverlayOptions.prototype.offsetY;

    /**
     * Object literal with config options for the Proj4js projection.
     * @typedef {{code: string,
     *     extent: (ol.Extent|undefined),
     *     global: (boolean|undefined)}}
     * @todo api
     */
    olx.Proj4jsProjectionOptions;

    /**
     * The SRS identifier code, e.g. `EPSG:31256`.
     * @type {string}
     */
    olx.Proj4jsProjectionOptions.prototype.code;

    /**
     * The validity extent for the SRS.
     * @type {ol.Extent|undefined}
     */
    olx.Proj4jsProjectionOptions.prototype.extent;

    /**
     * Whether the projection is valid for the whole globe. Default is `false`.
     * @type {boolean|undefined}
     */
    olx.Proj4jsProjectionOptions.prototype.global;

    /**
     * Object literal with config options for the projection.
     * @typedef {{code: string,
     *     units: (ol.proj.Units|string),
     *     extent: (ol.Extent|undefined),
     *     axisOrientation: (string|undefined),
     *     global: (boolean|undefined)}}
     * @todo api
     */
    olx.ProjectionOptions;

    /**
     * The SRS identifier code, e.g. `EPSG:4326`.
     * @type {string}
     */
    olx.ProjectionOptions.prototype.code;

    /**
     * Units.
     * @type {ol.proj.Units|string}
     */
    olx.ProjectionOptions.prototype.units;

    /**
     * The validity extent for the SRS.
     * @type {ol.Extent|undefined}
     */
    olx.ProjectionOptions.prototype.extent;

    /**
     * The axis orientation as specified in Proj4. The default is `enu`.
     * @type {string|undefined}
     */
    olx.ProjectionOptions.prototype.axisOrientation;

    /**
     * Whether the projection is valid for the whole globe. Default is `false`.
     * @type {boolean|undefined}
     */
    olx.ProjectionOptions.prototype.global;

    /**
     * Object literal with config options for the view.
     * @typedef {{center: (ol.Coordinate|undefined),
     *     constrainRotation: (boolean|number|undefined),
     *     enableRotation: (boolean|undefined),
     *     extent: (ol.Extent|undefined),
     *     minResolution: (number|undefined),
     *     maxResolution: (number|undefined),
     *     minZoom: (number|undefined),
     *     maxZoom: (number|undefined),
     *     projection: ol.proj.ProjectionLike,
     *     resolution: (number|undefined),
     *     resolutions: (Array.<number>|undefined),
     *     rotation: (number|undefined),
     *     zoom: (number|undefined),
     *     zoomFactor: (number|undefined)}}
     * @todo api
     */
    olx.View2DOptions;

    /**
     * The initial center for the view. The coordinate system for the center is
     * specified with the `projection` option. Default is `undefined`, and layer
     * sources will not be fetched if this is not set.
     * @type {ol.Coordinate|undefined}
     */
    olx.View2DOptions.prototype.center;

    /**
     * Rotation constraint. `false` means no constraint. `true` means no constraint,
     * but snap to zero near zero. A number constraints the rotation to that number
     * of values. For example, `4` will constrain the rotation to 0, 90, 180, and
     * 270 degrees. The default is `true`.
     * @type {boolean|number|undefined}
     */
    olx.View2DOptions.prototype.constrainRotation;

    /**
     * Enable rotation. Default is `true`.
     * @type {boolean|undefined}
     */
    olx.View2DOptions.prototype.enableRotation;

    /**
     * The extent that constrains the center, in other words, center cannot be set
     * outside this extent. Default is `undefined`.
     * @type {ol.Extent|undefined}
     */
    olx.View2DOptions.prototype.extent;

    /**
     * The maximum resolution used to determine the resolution constraint. It is
     * used together with `minResolution` (or `maxZoom`) and `zoomFactor`. If
     * unspecified it is calculated in such a way that the projection's validity
     * extent fits in a 256x256 px tile. If the projection is Spherical Mercator
     * (the default) then `maxResolution` defaults to `40075016.68557849 / 256 =
     * 156543.03392804097`.
     * @type {number|undefined}
     */
    olx.View2DOptions.prototype.maxResolution;

    /**
     * The minimum resolution used to determine the resolution constraint.  It is
     * used together with `maxResolution` (or `minZoom`) and `zoomFactor`.  If
     * unspecified it is calculated assuming 29 zoom levels (with a factor of 2).
     * If the projection is Spherical Mercator (the default) then `minResolution`
     * defaults to `40075016.68557849 / 256 / Math.pow(2, 28) =
     * 0.0005831682455839253`.
     * @type {number|undefined}
     */
    olx.View2DOptions.prototype.minResolution;

    /**
     * The maximum zoom level used to determine the resolution constraint. It is
     * used together with `minZoom` (or `maxResolution`) and `zoomFactor`. Default
     * is `28`.  Note that if `minResolution` is also provided, it is given
     * precedence over `maxZoom`.
     * @type {number|undefined}
     */
    olx.View2DOptions.prototype.maxZoom;

    /**
     * The minimum zoom level used to determine the resolution constraint. It is
     * used together with `maxZoom` (or `minResolution`) and `zoomFactor`. Default
     * is `0`. Note that if `maxResolution` is also provided, it is given
     * precedence over `minZoom`.
     * @type {number|undefined}
     */
    olx.View2DOptions.prototype.minZoom;

    /**
     * The projection. Default is `EPSG:3857` (Spherical Mercator).
     * @type {ol.proj.ProjectionLike}
     */
    olx.View2DOptions.prototype.projection;

    /**
     * The initial resolution for the view. The units are `projection` units per
     * pixel (e.g. meters per pixel). An alternative to setting this is to set
     * `zoom`. Default is `undefined`, and layer sources will not be fetched if
     * neither this nor `zoom` are defined.
     * @type {number|undefined}
     */
    olx.View2DOptions.prototype.resolution;

    /**
     * Resolutions to determine the resolution constraint. If set the
     * `maxResolution`, `minResolution`, `minZoom`, `maxZoom`, and `zoomFactor`
     * options are ignored.
     * @type {Array.<number>|undefined}
     */
    olx.View2DOptions.prototype.resolutions;

    /**
     * The initial rotation for the view in radians (positive rotation clockwise).
     * Default is `0`.
     * @type {number|undefined}
     */
    olx.View2DOptions.prototype.rotation;

    /**
     * Only used if `resolution` is not defined. Zoom level used to calculate the
     * initial resolution for the view. The initial resolution is determined using
     * the `ol.View2D#constrainResolution` method.
     * @type {number|undefined}
     */
    olx.View2DOptions.prototype.zoom;

    /**
     * The zoom factor used to determine the resolution constraint.  Default is `2`.
     * @type {number|undefined}
     */
    olx.View2DOptions.prototype.zoomFactor;

    /**
     * @typedef {{resolution: number,
     *     start: (number|undefined),
     *     duration: (number|undefined),
     *     easing: (function(number):number|undefined)}}
     * @todo api
     */
    olx.animation.BounceOptions;

    /**
     * The resolution to start the bounce from, typically
     * `map.getView().getResolution()`.
     * @type {number}
     */
    olx.animation.BounceOptions.prototype.resolution;

    /**
     * The start time of the animation. Default is immediately.
     * @type {number|undefined}
     */
    olx.animation.BounceOptions.prototype.start;

    /**
     * The duration of the animation in milliseconds. Default is `1000`.
     * @type {number|undefined}
     */
    olx.animation.BounceOptions.prototype.duration;

    /**
     * The easing function to use. Default is `ol.easing.upAndDown`
     * @type {function(number):number|undefined}
     */
    olx.animation.BounceOptions.prototype.easing;

    /**
     * @typedef {{source: ol.Coordinate,
     *     start: (number|undefined),
     *     duration: (number|undefined),
     *     easing: (function(number):number|undefined)}}
     * @todo api
     */
    olx.animation.PanOptions;

    /**
     * The location to start panning from, typically `map.getView().getCenter()`.
     * @type {ol.Coordinate}
     */
    olx.animation.PanOptions.prototype.source;

    /**
     * The start time of the animation. Default is immediately.
     * @type {number|undefined}
     */
    olx.animation.PanOptions.prototype.start;

    /**
     * The duration of the animation in milliseconds. Default is `1000`.
     * @type {number|undefined}
     */
    olx.animation.PanOptions.prototype.duration;

    /**
     * The easing function to use. Default is `ol.easing.inAndOut`
     * @type {function(number):number|undefined}
     */
    olx.animation.PanOptions.prototype.easing;

    /**
     * @typedef {{rotation: (number|undefined),
     *     anchor: (ol.Coordinate|undefined),
     *     start: (number|undefined),
     *     duration: (number|undefined),
     *     easing: (function(number):number|undefined)}}
     * @todo api
     */
    olx.animation.RotateOptions;

    /**
     * The rotation value (in radians) to begin rotating from, typically
     * `map.getView().getRotation()`. If `undefined` then `0` is assumed.
     * @type {number|undefined}
     */
    olx.animation.RotateOptions.prototype.rotation;

    /**
     * The rotation center/anchor. The map rotates around the center of the view
     * if unspecified.
     * @type {ol.Coordinate|undefined}
     */
    olx.animation.RotateOptions.prototype.anchor;

    /**
     * The start time of the animation. Default is immediately.
     * @type {number|undefined}
     */
    olx.animation.RotateOptions.prototype.start;

    /**
     * The duration of the animation in milliseconds. Default is `1000`.
     * @type {number|undefined}
     */
    olx.animation.RotateOptions.prototype.duration;

    /**
     * The easing function to use. Default is `ol.easing.inAndOut`
     * @type {function(number):number|undefined}
     */
    olx.animation.RotateOptions.prototype.easing;

    /**
     * @typedef {{resolution: number,
     *     start: (number|undefined),
     *     duration: (number|undefined),
     *     easing: (function(number):number|undefined)}}
     * @todo api
     */
    olx.animation.ZoomOptions;

    /**
     * number The resolution to begin zooming from, typically
     * `map.getView().getResolution()`.
     * @type {number}
     */
    olx.animation.ZoomOptions.prototype.resolution;

    /**
     * The start time of the animation. Default is immediately.
     * @type {number|undefined}
     */
    olx.animation.ZoomOptions.prototype.start;

    /**
     * The duration of the animation in milliseconds. Default is `1000`.
     * @type {number|undefined}
     */
    olx.animation.ZoomOptions.prototype.duration;

    /**
     * Easing function.
     * @type {function(number):number|undefined}
     */
    olx.animation.ZoomOptions.prototype.easing;

    /**
     * @typedef {{className: (string|undefined),
     *     target: (Element|undefined)}}
     * @todo api
     */
    olx.control.AttributionOptions;

    /**
     * CSS class name. Default is `ol-attribution`.
     * @type {string|undefined}
     */
    olx.control.AttributionOptions.prototype.className;

    /**
     * Target.
     * @type {Element|undefined}
     */
    olx.control.AttributionOptions.prototype.target;

    /**
     * @typedef {{element: (Element|undefined),
     *     target: (Element|string|undefined)}}
     * @todo api
     */
    olx.control.ControlOptions;

    /**
     * The element is the control's container element. This only needs to be
     * specified if you're developing a custom control.
     * @type {Element|undefined}
     */
    olx.control.ControlOptions.prototype.element;

    /**
     * Specify a target if you want the control to be rendered outside of the map's
     * viewport.
     * @type {Element|string|undefined}
     */
    olx.control.ControlOptions.prototype.target;

    /**
     * @typedef {{attribution: (boolean|undefined),
     *     attributionOptions: (olx.control.AttributionOptions|undefined),
     *     logo: (boolean|undefined),
     *     logoOptions: (olx.control.LogoOptions|undefined),
     *     zoom: (boolean|undefined),
     *     rotateOptions: (olx.control.RotateOptions|undefined),
     *     zoomOptions: (olx.control.ZoomOptions|undefined)}}
     * @todo api
     */
    olx.control.DefaultsOptions;

    /**
     * Attribution. Default is `true`.
     * @type {boolean|undefined}
     */
    olx.control.DefaultsOptions.prototype.attribution;

    /**
     * Attribution options.
     * @type {olx.control.AttributionOptions|undefined}
     */
    olx.control.DefaultsOptions.prototype.attributionOptions;

    /**
     * Logo. Default is `true`.
     * @type {boolean|undefined}
     */
    olx.control.DefaultsOptions.prototype.logo;

    /**
     * Logo options.
     * @type {olx.control.LogoOptions|undefined}
     */
    olx.control.DefaultsOptions.prototype.logoOptions;

    /**
     * Zoom. Default is `true`.
     * @type {boolean|undefined}
     */
    olx.control.DefaultsOptions.prototype.zoom;

    /**
     * Rotate options.
     * @type {olx.control.RotateOptions|undefined}
     */
    olx.control.DefaultsOptions.prototype.rotateOptions;

    /**
     * Zoom options.
     * @type {olx.control.ZoomOptions|undefined}
     */
    olx.control.DefaultsOptions.prototype.zoomOptions;

    /**
     * @typedef {{className: (string|undefined),
     *     tipLabel: (string|undefined),
     *     keys: (boolean|undefined),
     *     target: (Element|undefined)}}
     * @todo api
     */
    olx.control.FullScreenOptions;

    /**
     * CSS class name. Default is `ol-full-screen`.
     * @type {string|undefined}
     */
    olx.control.FullScreenOptions.prototype.className;

    /**
     * Text label to use for the button tip. Default is `Toggle full-screen`
     * @type {string|undefined}
     */
    olx.control.FullScreenOptions.prototype.tipLabel;

    /**
     * Full keyboard access.
     * @type {boolean|undefined}
     */
    olx.control.FullScreenOptions.prototype.keys;

    /**
     * Target.
     * @type {Element|undefined}
     */
    olx.control.FullScreenOptions.prototype.target;

    /**
     * @typedef {{className: (string|undefined),
     *     target: (Element|undefined)}}
     * @todo api
     */
    olx.control.LogoOptions;

    /**
     * CSS class name. Default is `ol-logo`.
     * @type {string|undefined}
     */
    olx.control.LogoOptions.prototype.className;

    /**
     * Target.
     * @type {Element|undefined}
     */
    olx.control.LogoOptions.prototype.target;

    /**
     * @typedef {{className: (string|undefined),
     *     coordinateFormat: (ol.CoordinateFormatType|undefined),
     *     projection: ol.proj.ProjectionLike,
     *     target: (Element|undefined),
     *     undefinedHTML: (string|undefined)}}
     * @todo api
     */
    olx.control.MousePositionOptions;

    /**
     * CSS class name. Default is `ol-mouse-position`.
     * @type {string|undefined}
     */
    olx.control.MousePositionOptions.prototype.className;

    /**
     * Coordinate format.
     * @type {ol.CoordinateFormatType|undefined}
     */
    olx.control.MousePositionOptions.prototype.coordinateFormat;

    /**
     * Projection.
     * @type {ol.proj.ProjectionLike}
     */
    olx.control.MousePositionOptions.prototype.projection;

    /**
     * Target.
     * @type {Element|undefined}
     */
    olx.control.MousePositionOptions.prototype.target;

    /**
     * Markup for undefined coordinates. Default is `` (empty string).
     * @type {string|undefined}
     */
    olx.control.MousePositionOptions.prototype.undefinedHTML;

    /**
     * @typedef {{className: (string|undefined),
     *     minWidth: (number|undefined),
     *     target: (Element|undefined),
     *     units: (ol.control.ScaleLineUnits|string|undefined)}}
     * @todo api
     */
    olx.control.ScaleLineOptions;

    /**
     * CSS Class name. Default is `ol-scale-line`.
     * @type {string|undefined}
     */
    olx.control.ScaleLineOptions.prototype.className;

    /**
     * Minimum width in pixels. Default is `64`.
     * @type {number|undefined}
     */
    olx.control.ScaleLineOptions.prototype.minWidth;

    /**
     * Target.
     * @type {Element|undefined}
     */
    olx.control.ScaleLineOptions.prototype.target;

    /**
     * Units. Default is `metric`.
     * @type {ol.control.ScaleLineUnits|string|undefined}
     */
    olx.control.ScaleLineOptions.prototype.units;

    /**
     * @typedef {{duration: (number|undefined),
     *     className: (string|undefined),
     *     label: (string|undefined),
     *     tipLabel: (string|undefined),
     *     target: (Element|undefined),
     *     autoHide: (boolean|undefined)}}
     * @todo api
     */
    olx.control.RotateOptions;

    /**
     * CSS class name. Default is `ol-rotate`.
     * @type {string|undefined}
     */
    olx.control.RotateOptions.prototype.className;

    /**
     * Text label to use for the rotate button. Default is `⇧`
     * @type {string|undefined}
     */
    olx.control.RotateOptions.prototype.label;

    /**
     * Text label to use for the rotate tip. Default is `Reset rotation`
     * @type {string|undefined}
     */
    olx.control.RotateOptions.prototype.tipLabel;

    /**
     * Animation duration in milliseconds. Default is `250`.
     * @type {number|undefined}
     */
    olx.control.RotateOptions.prototype.duration;

    /**
     * Hide the control when rotation is 0. Default is `true`.
     * @type {boolean|undefined}
     */
    olx.control.RotateOptions.prototype.autoHide;

    /**
     * Target.
     * @type {Element|undefined}
     */
    olx.control.RotateOptions.prototype.target;

    /**
     * @typedef {{duration: (number|undefined),
     *     className: (string|undefined),
     *     zoomInLabel: (string|undefined),
     *     zoomOutLabel: (string|undefined),
     *     zoomInTipLabel: (string|undefined),
     *     zoomOutTipLabel: (string|undefined),
     *     delta: (number|undefined),
     *     target: (Element|undefined)}}
     * @todo api
     */
    olx.control.ZoomOptions;

    /**
     * Animation duration in milliseconds. Default is `250`.
     * @type {number|undefined}
     */
    olx.control.ZoomOptions.prototype.duration;

    /**
     * CSS class name. Default is `ol-zoom`.
     * @type {string|undefined}
     */
    olx.control.ZoomOptions.prototype.className;

    /**
     * Text label to use for the zoom-in button. Default is `+`
     * @type {string|undefined}
     */
    olx.control.ZoomOptions.prototype.zoomInLabel;

    /**
     * Text label to use for the zoom-out button. Default is `-`
     * @type {string|undefined}
     */
    olx.control.ZoomOptions.prototype.zoomOutLabel;

    /**
     * Text label to use for the button tip. Default is `Zoom in`
     * @type {string|undefined}
     */
    olx.control.ZoomOptions.prototype.zoomInTipLabel;

    /**
     * Text label to use for the button tip. Default is `Zoom out`
     * @type {string|undefined}
     */
    olx.control.ZoomOptions.prototype.zoomOutTipLabel;

    /**
     * The zoom delta applied on each click.
     * @type {number|undefined}
     */
    olx.control.ZoomOptions.prototype.delta;

    /**
     * Target.
     * @type {Element|undefined}
     */
    olx.control.ZoomOptions.prototype.target;

    /**
     * @typedef {{className: (string|undefined),
     *     maxResolution: (number|undefined),
     *     minResolution: (number|undefined)}}
     * @todo api
     */
    olx.control.ZoomSliderOptions;

    /**
     * CSS class name.
     * @type {string|undefined}
     */
    olx.control.ZoomSliderOptions.prototype.className;

    /**
     * Maximum resolution.
     * @type {number|undefined}
     */
    olx.control.ZoomSliderOptions.prototype.maxResolution;

    /**
     * Minimum resolution.
     * @type {number|undefined}
     */
    olx.control.ZoomSliderOptions.prototype.minResolution;

    /**
     * @typedef {{className: (string|undefined),
     *     target: (Element|undefined),
     *     tipLabel: (string|undefined),
     *     extent: (ol.Extent|undefined)}}
     * @todo api
     */
    olx.control.ZoomToExtentOptions;

    /**
     * Class name. Default is `ol-zoom-extent`.
     * @type {string|undefined}
     */
    olx.control.ZoomToExtentOptions.prototype.className;

    /**
     * Target.
     * @type {Element|undefined}
     */
    olx.control.ZoomToExtentOptions.prototype.target;

    /**
     * Text label to use for the button tip. Default is `Zoom to extent`
     * @type {string|undefined}
     */
    olx.control.ZoomToExtentOptions.prototype.tipLabel;

    /**
     * The extent to zoom to. If undefined the validity extent of the view
     * projection is used.
     * @type {ol.Extent|undefined}
     */
    olx.control.ZoomToExtentOptions.prototype.extent;

    /**
     * @typedef {{defaultProjection: ol.proj.ProjectionLike,
     *     geometryName: (string|undefined)}}
     * @todo api
     */
    olx.format.GeoJSONOptions;

    /**
     * Default projection.
     * @type {ol.proj.ProjectionLike}
     */
    olx.format.GeoJSONOptions.prototype.defaultProjection;

    /**
     * Geometry name to use when creating features.
     * @type {string|undefined}
     */
    olx.format.GeoJSONOptions.prototype.geometryName;

    /**
     * @typedef {{defaultProjection: ol.proj.ProjectionLike}}
     * @todo api
     */
    olx.format.TopoJSONOptions;

    /**
     * Default projection.
     * @type {ol.proj.ProjectionLike}
     */
    olx.format.TopoJSONOptions.prototype.defaultProjection;

    /**
     * @typedef {{altitudeMode: (ol.format.IGCZ|undefined)}}
     * @todo api
     */
    olx.format.IGCOptions;

    /**
     * Altitude mode. Possible values are `barometric`, `gps`, and `none`. Default
     * is `none`.
     * @type {ol.format.IGCZ|undefined}
     */
    olx.format.IGCOptions.prototype.altitudeMode;

    /**
     * @typedef {{defaultStyle: (Array.<ol.style.Style>|undefined)}}
     * @todo api
     */
    olx.format.KMLOptions;

    /**
     * Default style. The default default style is the same as Google Earth.
     * @type {Array.<ol.style.Style>|undefined}
     */
    olx.format.KMLOptions.prototype.defaultStyle;

    /**
     * @typedef {{featureNS: string,
     *     featureType: string,
     *     srsName: string,
     *     surface: (boolean|undefined),
     *     curve: (boolean|undefined),
     *     multiCurve: (boolean|undefined),
     *     multiSurface: (boolean|undefined),
     *     schemaLocation: (string|undefined)}}
     * @todo api
     */
    olx.format.GMLOptions;

    /**
     * Feature namespace.
     * @type {string}
     */
    olx.format.GMLOptions.prototype.featureNS;

    /**
     * Feature type to parse.
     * @type {string}
     */
    olx.format.GMLOptions.prototype.featureType;

    /**
     * srsName to use when writing geometries.
     * @type {string}
     */
    olx.format.GMLOptions.prototype.srsName;

    /**
     * Write gml:Surface instead of gml:Polygon elements. This also affects the
     * elements in multi-part geometries. Default is `false`.
     * @type {boolean|undefined}
     */
    olx.format.GMLOptions.prototype.surface;

    /**
     * Write gml:Curve instead of gml:LineString elements. This also affects the
     * elements in multi-part geometries. Default is `false`.
     * @type {boolean|undefined}
     */
    olx.format.GMLOptions.prototype.curve;

    /**
     * Write gml:MultiCurve instead of gml:MultiLineString. Since the latter is
     * deprecated in GML 3, the default is `true`.
     * @type {boolean|undefined}
     */
    olx.format.GMLOptions.prototype.multiCurve;

    /**
     * Write gml:multiSurface instead of gml:MultiPolygon. Since the latter is
     * deprecated in GML 3, the default is `true`.
     * @type {boolean|undefined}
     */
    olx.format.GMLOptions.prototype.multiSurface;

    /**
     * Optional schemaLocation to use when writing out the GML, this will override
     * the default provided.
     * @type {string|undefined}
     */
    olx.format.GMLOptions.prototype.schemaLocation;

    /**
     * @typedef {{featureNS: string,
     *     featureType: string,
     *     schemaLocation: (string|undefined)}}
     * @todo api
     */
    olx.format.WFSOptions;

    /**
     * The namespace URI used for features.
     * @type {string}
     */
    olx.format.WFSOptions.prototype.featureNS;

    /**
     * The feature type to parse. Only used for read operations.
     * @type {string}
     */
    olx.format.WFSOptions.prototype.featureType;

    /**
     * Optional schemaLocation to use for serialization, this will override the
     * default.
     * @type {string|undefined}
     */
    olx.format.WFSOptions.prototype.schemaLocation;

    /**
     * @typedef {{featureNS: string,
     *     featurePrefix: string,
     *     featureTypes: Array.<string>,
     *     srsName: (string|undefined),
     *     handle: (string|undefined),
     *     outputFormat: (string|undefined),
     *     maxFeatures: (number|undefined),
     *     geometryName: (string|undefined),
     *     bbox: (ol.Extent|undefined)}}
     * @todo api
     */
    olx.format.WFSWriteGetFeatureOptions;

    /**
     * The namespace URI used for features.
     * @type {string}
     */
    olx.format.WFSWriteGetFeatureOptions.prototype.featureNS;

    /**
     * The prefix for the feature namespace.
     * @type {string}
     */
    olx.format.WFSWriteGetFeatureOptions.prototype.featurePrefix;

    /**
     * The feature type names.
     * @type {Array.<string>}
     */
    olx.format.WFSWriteGetFeatureOptions.prototype.featureTypes;

    /**
     * SRS name. No srsName attribute will be set on geometries when this is not
     * provided.
     * @type {string|undefined}
     */
    olx.format.WFSWriteGetFeatureOptions.prototype.srsName;

    /**
     * Handle.
     * @type {string|undefined}
     */
    olx.format.WFSWriteGetFeatureOptions.prototype.handle;

    /**
     * Output format.
     * @type {string|undefined}
     */
    olx.format.WFSWriteGetFeatureOptions.prototype.outputFormat;

    /**
     * Maximum number of features to fetch.
     * @type {number|undefined}
     */
    olx.format.WFSWriteGetFeatureOptions.prototype.maxFeatures;

    /**
     * Geometry name to use in a BBOX filter.
     * @type {string|undefined}
     */
    olx.format.WFSWriteGetFeatureOptions.prototype.geometryName;

    /**
     * Extent to use for the BBOX filter.
     * @type {ol.Extent|undefined}
     */
    olx.format.WFSWriteGetFeatureOptions.prototype.bbox;

    /**
     * @typedef {{featureNS: string,
     *     featurePrefix: string,
     *     featureType: string,
     *     srsName: (string|undefined),
     *     handle: (string|undefined),
     *     nativeElements: Array.<Object>,
     *     gmlOptions: (olx.format.GMLOptions|undefined)}}
     * @todo api
     */
    olx.format.WFSWriteTransactionOptions;

    /**
     * The namespace URI used for features.
     * @type {string}
     */
    olx.format.WFSWriteTransactionOptions.prototype.featureNS;

    /**
     * The prefix for the feature namespace.
     * @type {string}
     */
    olx.format.WFSWriteTransactionOptions.prototype.featurePrefix;

    /**
     * The feature type name.
     * @type {string}
     */
    olx.format.WFSWriteTransactionOptions.prototype.featureType;

    /**
     * SRS name. No srsName attribute will be set on geometries when this is not
     * provided.
     * @type {string|undefined}
     */
    olx.format.WFSWriteTransactionOptions.prototype.srsName;

    /**
     * Handle.
     * @type {string|undefined}
     */
    olx.format.WFSWriteTransactionOptions.prototype.handle;

    /**
     * Native elements. Currently not supported.
     * @type {Array.<Object>}
     */
    olx.format.WFSWriteTransactionOptions.prototype.nativeElements;

    /**
     * GML options for the WFS transaction writer.
     * @type {olx.format.GMLOptions|undefined}
     */
    olx.format.WFSWriteTransactionOptions.prototype.gmlOptions;

    /**
     * Interactions for the map. Default is `true` for all options.
     * @typedef {{altShiftDragRotate: (boolean|undefined),
     *     doubleClickZoom: (boolean|undefined),
     *     keyboard: (boolean|undefined),
     *     mouseWheelZoom: (boolean|undefined),
     *     shiftDragZoom: (boolean|undefined),
     *     dragPan: (boolean|undefined),
     *     pinchRotate: (boolean|undefined),
     *     pinchZoom: (boolean|undefined),
     *     zoomDelta: (number|undefined),
     *     zoomDuration: (number|undefined)}}
     * @todo api
     */
    olx.interaction.DefaultsOptions;

    /**
     * Whether Alt-Shift-drag rotate is desired. Default is `true`.
     * @type {boolean|undefined}
     */
    olx.interaction.DefaultsOptions.prototype.altShiftDragRotate;

    /**
     * Whether double click zoom is desired. Default is `true`.
     * @type {boolean|undefined}
     */
    olx.interaction.DefaultsOptions.prototype.doubleClickZoom;

    /**
     * Whether keyboard interaction is desired. Default is `true`.
     * @type {boolean|undefined}
     */
    olx.interaction.DefaultsOptions.prototype.keyboard;

    /**
     * Whether mousewheel zoom is desired. Default is `true`.
     * @type {boolean|undefined}
     */
    olx.interaction.DefaultsOptions.prototype.mouseWheelZoom;

    /**
     * Whether Shift-drag zoom is desired. Default is `true`.
     * @type {boolean|undefined}
     */
    olx.interaction.DefaultsOptions.prototype.shiftDragZoom;

    /**
     * Whether drag pan is desired. Default is `true`.
     * @type {boolean|undefined}
     */
    olx.interaction.DefaultsOptions.prototype.dragPan;

    /**
     * Whether pinch rotate is desired. Default is `true`.
     * @type {boolean|undefined}
     */
    olx.interaction.DefaultsOptions.prototype.pinchRotate;

    /**
     * Whether pinch zoom is desired. Default is `true`.
     * @type {boolean|undefined}
     */
    olx.interaction.DefaultsOptions.prototype.pinchZoom;

    /**
     * Zoom delta.
     * @type {number|undefined}
     */
    olx.interaction.DefaultsOptions.prototype.zoomDelta;

    /**
     * Zoom duration.
     * @type {number|undefined}
     */
    olx.interaction.DefaultsOptions.prototype.zoomDuration;

    /**
     * @typedef {{duration: (number|undefined),
     *     delta: (number|undefined)}}
     * @todo api
     */
    olx.interaction.DoubleClickZoomOptions;

    /**
     * Animation duration in milliseconds. Default is `250`.
     * @type {number|undefined}
     */
    olx.interaction.DoubleClickZoomOptions.prototype.duration;

    /**
     * The zoom delta applied on each double click, default is `1`.
     * @type {number|undefined}
     */
    olx.interaction.DoubleClickZoomOptions.prototype.delta;

    /**
     * @typedef {{formatConstructors: (Array.<function(new: ol.format.Feature)>|undefined),
     *     reprojectTo: ol.proj.ProjectionLike}}
     * @todo api
     */
    olx.interaction.DragAndDropOptions;

    /**
     * Format constructors.
     * @type {Array.<function(new: ol.format.Feature)>|undefined}
     */
    olx.interaction.DragAndDropOptions.prototype.formatConstructors;

    /**
     * Target projection. By default, the map's view's projection is used.
     * @type {ol.proj.ProjectionLike}
     */
    olx.interaction.DragAndDropOptions.prototype.reprojectTo;

    /**
     * @typedef {{condition: (ol.events.ConditionType|undefined),
     *     style: ol.style.Style}}
     * @todo api
     */
    olx.interaction.DragBoxOptions;

    /**
     * A conditional modifier (i.e. Shift key) that determines if the interaction is
     * active or not, default is always.
     * @type {ol.events.ConditionType|undefined}
     */
    olx.interaction.DragBoxOptions.prototype.condition;

    /**
     * Style for the box.
     * @type {ol.style.Style}
     */
    olx.interaction.DragBoxOptions.prototype.style;

    /**
     * @typedef {{kinetic: (ol.Kinetic|undefined)}}
     * @todo api
     */
    olx.interaction.DragPanOptions;

    /**
     * Kinetic inertia to apply to the pan.
     * @type {ol.Kinetic|undefined}
     */
    olx.interaction.DragPanOptions.prototype.kinetic;

    /**
     * @typedef {{condition: (ol.events.ConditionType|undefined)}}
     * @todo api
     */
    olx.interaction.DragRotateAndZoomOptions;

    /**
     * A conditional modifier (i.e. Shift key) that determines if the interaction is
     * active or not, default is shify key.
     * @type {ol.events.ConditionType|undefined}
     */
    olx.interaction.DragRotateAndZoomOptions.prototype.condition;

    /**
     * @typedef {{condition: (ol.events.ConditionType|undefined)}}
     * @todo api
     */
    olx.interaction.DragRotateOptions;

    /**
     * A conditional modifier (i.e. Shift key) that determines if the interaction is
     * active or not, default is both shift and alt keys.
     * @type {ol.events.ConditionType|undefined}
     */
    olx.interaction.DragRotateOptions.prototype.condition;

    /**
     * @typedef {{condition: (ol.events.ConditionType|undefined),
     *     style: ol.style.Style}}
     * @todo api
     */
    olx.interaction.DragZoomOptions;

    /**
     * A conditional modifier (i.e. Shift key) that determines if the interaction is
     * active or not, default is shift key.
     * @type {ol.events.ConditionType|undefined}
     */
    olx.interaction.DragZoomOptions.prototype.condition;

    /**
     * Style for the box.
     * @type {ol.style.Style}
     */
    olx.interaction.DragZoomOptions.prototype.style;

    /**
     * @typedef {{features: (ol.Collection|undefined),
     *     source: (ol.source.Vector|undefined),
     *     snapTolerance: (number|undefined),
     *     type: ol.geom.GeometryType,
     *     minPointsPerRing: (number|undefined),
     *     style: (ol.style.Style|Array.<ol.style.Style>|ol.feature.StyleFunction|undefined),
     *     geometryName: (string|undefined),
     *     condition: (ol.events.ConditionType|undefined)}}
     * @todo api
     */
    olx.interaction.DrawOptions;

    /**
     * Destination collection for the drawn features.
     * @type {ol.Collection|undefined}
     */
    olx.interaction.DrawOptions.prototype.features;

    /**
     * Destination source for the drawn features.
     * @type {ol.source.Vector|undefined}
     */
    olx.interaction.DrawOptions.prototype.source;

    /**
     * Pixel distance for snapping to the drawing finish (default is 12).
     * @type {number|undefined}
     */
    olx.interaction.DrawOptions.prototype.snapTolerance;

    /**
     * Drawing type ('Point', 'LineString', 'Polygon', 'MultiPoint',
     * 'MultiLineString', or 'MultiPolygon').
     * @type {ol.geom.GeometryType}
     */
    olx.interaction.DrawOptions.prototype.type;

    /**
     * The number of points that must be drawn before a polygon ring can be finished
     * (default is 3).
     * @type {number|undefined}
     */
    olx.interaction.DrawOptions.prototype.minPointsPerRing;

    /**
     * Style for sketch features.
     * @type {ol.style.Style|Array.<ol.style.Style>|ol.feature.StyleFunction|undefined}
     */
    olx.interaction.DrawOptions.prototype.style;

    /**
     * Geometry name to use for features created by the draw interaction.
     * @type {string|undefined}
     */
    olx.interaction.DrawOptions.prototype.geometryName;

    /**
     * A conditional modifier (e.g. shift key) that determines if the interaction is
     * active (i.e. a click adds a vertex) or not. By default, a click with no modifier
     * keys adds a vertex.
     * @type {ol.events.ConditionType|undefined}
     */
    olx.interaction.DrawOptions.prototype.condition;

    /**
     * @typedef {{condition: (ol.events.ConditionType|undefined),
     *     pixelDelta: (number|undefined)}}
     * @todo api
     */
    olx.interaction.KeyboardPanOptions;

    /**
     * A conditional modifier (i.e. Shift key) that determines if the interaction is
     * active or not, default is no modifiers.
     * @type {ol.events.ConditionType|undefined}
     */
    olx.interaction.KeyboardPanOptions.prototype.condition;

    /**
     * Pixel The amount to pan on each key press. Default is `128` pixels.
     * @type {number|undefined}
     */
    olx.interaction.KeyboardPanOptions.prototype.pixelDelta;

    /**
     * @typedef {{duration: (number|undefined),
     *     condition: (ol.events.ConditionType|undefined),
     *     delta: (number|undefined)}}
     * @todo api
     */
    olx.interaction.KeyboardZoomOptions;

    /**
     * Animation duration in milliseconds. Default is `100`.
     * @type {number|undefined}
     */
    olx.interaction.KeyboardZoomOptions.prototype.duration;

    /**
     * A conditional modifier (i.e. Shift key) that determines if the interaction is
     * active or not, default is no modifiers.
     * @type {ol.events.ConditionType|undefined}
     */
    olx.interaction.KeyboardZoomOptions.prototype.condition;

    /**
     * The amount to zoom on each key press. Default is `1`.
     * @type {number|undefined}
     */
    olx.interaction.KeyboardZoomOptions.prototype.delta;

    /**
     * @typedef {{deleteCondition: (ol.events.ConditionType|undefined),
     *     pixelTolerance: (number|undefined),
     *     style: (ol.style.Style|Array.<ol.style.Style>|ol.feature.StyleFunction|undefined),
     *     features: ol.Collection}}
     * @todo api
     */
    olx.interaction.ModifyOptions;

    /**
     * Condition that determines which event results in a vertex deletion. Default
     * is a `singleclick` event with no modifier keys.
     * @type {ol.events.ConditionType|undefined}
     */
    olx.interaction.ModifyOptions.prototype.deleteCondition;

    /**
     * Pixel tolerance for considering the pointer close enough to a segment or
     * vertex for editing. Default is 10 pixels.
     * @type {number|undefined}
     */
    olx.interaction.ModifyOptions.prototype.pixelTolerance;

    /**
     * FeatureOverlay style.
     * @type {ol.style.Style|Array.<ol.style.Style>|ol.feature.StyleFunction|undefined}
     */
    olx.interaction.ModifyOptions.prototype.style;

    /**
     * The features the interaction works on.
     * @type {ol.Collection}
     */
    olx.interaction.ModifyOptions.prototype.features;

    /**
     * @typedef {{duration: (number|undefined)}}
     * @todo api
     */
    olx.interaction.MouseWheelZoomOptions;

    /**
     * Animation duration in milliseconds. Default is `250`.
     * @type {number|undefined}
     */
    olx.interaction.MouseWheelZoomOptions.prototype.duration;

    /**
     * @typedef {{threshold: (number|undefined)}}
     * @todo api
     */
    olx.interaction.PinchRotateOptions;

    /**
     * Minimal angle in radians to start a rotation. Default is `0.3`.
     * @type {number|undefined}
     */
    olx.interaction.PinchRotateOptions.prototype.threshold;

    /**
     * @typedef {{duration: (number|undefined)}}
     * @todo api
     */
    olx.interaction.PinchZoomOptions;

    /**
     * Animation duration in milliseconds. Default is `400`.
     * @type {number|undefined}
     */
    olx.interaction.PinchZoomOptions.prototype.duration;

    /**
     * @typedef {{addCondition: (ol.events.ConditionType|undefined),
     *     condition: (ol.events.ConditionType|undefined),
     *     layers: (Array.<ol.layer.Layer>|function(ol.layer.Layer): boolean|undefined),
     *     style: (ol.style.Style|Array.<ol.style.Style>|ol.feature.StyleFunction|undefined),
     *     removeCondition: (ol.events.ConditionType|undefined),
     *     toggleCondition: (ol.events.ConditionType|undefined)}}
     * @todo api
     */
    olx.interaction.SelectOptions;

    /**
     * A conditional modifier (e.g. alt key) that determines if the feature is added
     * to the current selection. By default, this is never. Note that the default
     * toggle condition allows features to be added.
     * @type {ol.events.ConditionType|undefined}
     */
    olx.interaction.SelectOptions.prototype.addCondition;

    /**
     * A conditional modifier (e.g. shift key) that determines if the interaction is
     * active (i.e. selection occurs) or not. By default, a click with no modifier
     * keys toggles the selection.
     * @type {ol.events.ConditionType|undefined}
     */
    olx.interaction.SelectOptions.prototype.condition;

    /**
     * A list of layers from which features should be
     * selected. Alternatively, a filter function can be provided. The
     * function will be called for each layer in the map and should return
     * `true` for layers that you want to be selectable. If the option is
     * absent, all visible layers will be considered selectable.
     * @type {Array.<ol.layer.Layer>|function(ol.layer.Layer): boolean|undefined}
     */
    olx.interaction.SelectOptions.prototype.layers;

    /**
     * FeatureOverlay style.
     * @type {ol.style.Style|Array.<ol.style.Style>|ol.feature.StyleFunction|undefined}
     */
    olx.interaction.SelectOptions.prototype.style;

    /**
     * A conditional modifier (e.g. alt key) that determines if the feature is
     * removed from the current selection. By default, this is never.
     * @type {ol.events.ConditionType|undefined}
     */
    olx.interaction.SelectOptions.prototype.removeCondition;

    /**
     * A conditional modifier (e.g. shift key) that determines if the selection is
     * toggled in the current selection. By default, a shift-click toggles the
     * feature in the current selection.
     * @type {ol.events.ConditionType|undefined}
     */
    olx.interaction.SelectOptions.prototype.toggleCondition;

    /**
     * @typedef {{brightness: (number|undefined),
     *     contrast: (number|undefined),
     *     hue: (number|undefined),
     *     opacity: (number|undefined),
     *     saturation: (number|undefined),
     *     visible: (boolean|undefined),
     *     minResolution: (number|undefined),
     *     maxResolution: (number|undefined)}}
     * @todo api
     */
    olx.layer.BaseOptions;

    /**
     * Brightness. Default is `0`.
     * @type {number|undefined}
     */
    olx.layer.BaseOptions.prototype.brightness;

    /**
     * Contrast. Default is `1`.
     * @type {number|undefined}
     */
    olx.layer.BaseOptions.prototype.contrast;

    /**
     * Hue. Default is `0`.
     * @type {number|undefined}
     */
    olx.layer.BaseOptions.prototype.hue;

    /**
     * Opacity (0, 1). Default is `1`.
     * @type {number|undefined}
     */
    olx.layer.BaseOptions.prototype.opacity;

    /**
     * Saturation. Default is `1`.
     * @type {number|undefined}
     */
    olx.layer.BaseOptions.prototype.saturation;

    /**
     * Visibility. Default is `true`.
     * @type {boolean|undefined}
     */
    olx.layer.BaseOptions.prototype.visible;

    /**
     * The minimum resolution (inclusive) at which this layer will be visible.
     * @type {number|undefined}
     */
    olx.layer.BaseOptions.prototype.minResolution;

    /**
     * The maximum resolution (exclusive) below which this layer will be visible.
     * @type {number|undefined}
     */
    olx.layer.BaseOptions.prototype.maxResolution;

    /**
     * @typedef {{brightness: (number|undefined),
     *     contrast: (number|undefined),
     *     hue: (number|undefined),
     *     opacity: (number|undefined),
     *     saturation: (number|undefined),
     *     source: ol.source.Source,
     *     visible: (boolean|undefined),
     *     minResolution: (number|undefined),
     *     maxResolution: (number|undefined)}}
     * @todo api
     */
    olx.layer.LayerOptions;

    /**
     * Brightness. Default is `0`.
     * @type {number|undefined}
     */
    olx.layer.LayerOptions.prototype.brightness;

    /**
     * Contrast. Default is `1`.
     * @type {number|undefined}
     */
    olx.layer.LayerOptions.prototype.contrast;

    /**
     * Hue. Default is `0`.
     * @type {number|undefined}
     */
    olx.layer.LayerOptions.prototype.hue;

    /**
     * Opacity (0, 1). Default is `1`.
     * @type {number|undefined}
     */
    olx.layer.LayerOptions.prototype.opacity;

    /**
     * Saturation. Default is `1`.
     * @type {number|undefined}
     */
    olx.layer.LayerOptions.prototype.saturation;

    /**
     * Source for this layer.
     * @type {ol.source.Source}
     */
    olx.layer.LayerOptions.prototype.source;

    /**
     * Visibility. Default is `true` (visible).
     * @type {boolean|undefined}
     */
    olx.layer.LayerOptions.prototype.visible;

    /**
     * The minimum resolution (inclusive) at which this layer will be visible.
     * @type {number|undefined}
     */
    olx.layer.LayerOptions.prototype.minResolution;

    /**
     * The maximum resolution (exclusive) below which this layer will be visible.
     * @type {number|undefined}
     */
    olx.layer.LayerOptions.prototype.maxResolution;

    /**
     * @typedef {{brightness: (number|undefined),
     *     contrast: (number|undefined),
     *     hue: (number|undefined),
     *     opacity: (number|undefined),
     *     saturation: (number|undefined),
     *     visible: (boolean|undefined),
     *     minResolution: (number|undefined),
     *     maxResolution: (number|undefined),
     *     layers: (Array.<ol.layer.Base>|ol.Collection|undefined)}}
     * @todo api
     */
    olx.layer.GroupOptions;

    /**
     * Brightness. Default is `0`.
     * @type {number|undefined}
     */
    olx.layer.GroupOptions.prototype.brightness;

    /**
     * Contrast. Default is `1`.
     * @type {number|undefined}
     */
    olx.layer.GroupOptions.prototype.contrast;

    /**
     * Hue. Default is `0`.
     * @type {number|undefined}
     */
    olx.layer.GroupOptions.prototype.hue;

    /**
     * Opacity (0, 1). Default is `1`.
     * @type {number|undefined}
     */
    olx.layer.GroupOptions.prototype.opacity;

    /**
     * Saturation. Default is `1`.
     * @type {number|undefined}
     */
    olx.layer.GroupOptions.prototype.saturation;

    /**
     * Visibility. Default is `true`.
     * @type {boolean|undefined}
     */
    olx.layer.GroupOptions.prototype.visible;

    /**
     * The minimum resolution (inclusive) at which this layer will be visible.
     * @type {number|undefined}
     */
    olx.layer.GroupOptions.prototype.minResolution;

    /**
     * The maximum resolution (exclusive) below which this layer will be visible.
     * @type {number|undefined}
     */
    olx.layer.GroupOptions.prototype.maxResolution;

    /**
     * Child layers.
     * @type {Array.<ol.layer.Base>|ol.Collection|undefined}
     */
    olx.layer.GroupOptions.prototype.layers;

    /**
     * @typedef {{brightness: (number|undefined),
     *     contrast: (number|undefined),
     *     hue: (number|undefined),
     *     gradient: (Array.<string>|undefined),
     *     radius: (number|undefined),
     *     blur: (number|undefined),
     *     shadow: (number|undefined),
     *     weight: (string|function(ol.Feature):number|undefined),
     *     minResolution: (number|undefined),
     *     maxResolution: (number|undefined),
     *     opacity: (number|undefined),
     *     saturation: (number|undefined),
     *     source: ol.source.Vector,
     *     visible: (boolean|undefined)}}
     * @todo api
     */
    olx.layer.HeatmapOptions;

    /**
     * Brightness.
     * @type {number|undefined}
     */
    olx.layer.HeatmapOptions.prototype.brightness;

    /**
     * Contrast.
     * @type {number|undefined}
     */
    olx.layer.HeatmapOptions.prototype.contrast;

    /**
     * Hue.
     * @type {number|undefined}
     */
    olx.layer.HeatmapOptions.prototype.hue;

    /**
     * The color gradient of the heatmap, specified as an array of CSS color
     * strings. Default is `['#00f', '#0ff', '#0f0', '#ff0', '#f00']`.
     * @type {Array.<string>|undefined}
     */
    olx.layer.HeatmapOptions.prototype.gradient;

    /**
     * Radius size in pixels. Default is `8`.
     * @type {number|undefined}
     */
    olx.layer.HeatmapOptions.prototype.radius;

    /**
     * Blur size in pixels. Default is `15`.
     * @type {number|undefined}
     */
    olx.layer.HeatmapOptions.prototype.blur;

    /**
     * Shadow size in pixels. Default is `250`.
     * @type {number|undefined}
     */
    olx.layer.HeatmapOptions.prototype.shadow;

    /**
     * The feature attribute to use for the weight or a function that returns a
     * weight from a feature. Weight values should range from 0 to 1 (and values
     * outside will be clamped to that range). Default is `weight`.
     * @type {string|function(ol.Feature):number|undefined}
     */
    olx.layer.HeatmapOptions.prototype.weight;

    /**
     * The minimum resolution (inclusive) at which this layer will be visible.
     * @type {number|undefined}
     */
    olx.layer.HeatmapOptions.prototype.minResolution;

    /**
     * The maximum resolution (exclusive) below which this layer will be visible.
     * @type {number|undefined}
     */
    olx.layer.HeatmapOptions.prototype.maxResolution;

    /**
     * Opacity. 0-1. Default is `1`.
     * @type {number|undefined}
     */
    olx.layer.HeatmapOptions.prototype.opacity;

    /**
     * Saturation.
     * @type {number|undefined}
     */
    olx.layer.HeatmapOptions.prototype.saturation;

    /**
     * Source.
     * @type {ol.source.Vector}
     */
    olx.layer.HeatmapOptions.prototype.source;

    /**
     * Visibility. Default is `true` (visible).
     * @type {boolean|undefined}
     */
    olx.layer.HeatmapOptions.prototype.visible;

    /**
     * @typedef {{brightness: (number|undefined),
     *     contrast: (number|undefined),
     *     hue: (number|undefined),
     *     opacity: (number|undefined),
     *     preload: (number|undefined),
     *     saturation: (number|undefined),
     *     source: ol.source.Source,
     *     visible: (boolean|undefined),
     *     minResolution: (number|undefined),
     *     maxResolution: (number|undefined),
     *     useInterimTilesOnError: (boolean|undefined)}}
     * @todo api
     */
    olx.layer.TileOptions;

    /**
     * Brightness. Default is `0`.
     * @type {number|undefined}
     */
    olx.layer.TileOptions.prototype.brightness;

    /**
     * Contrast. Default is `1`.
     * @type {number|undefined}
     */
    olx.layer.TileOptions.prototype.contrast;

    /**
     * Hue. Default is `0`.
     * @type {number|undefined}
     */
    olx.layer.TileOptions.prototype.hue;

    /**
     * Opacity (0, 1). Default is `1`.
     * @type {number|undefined}
     */
    olx.layer.TileOptions.prototype.opacity;

    /**
     * Preload.
     * @type {number|undefined}
     */
    olx.layer.TileOptions.prototype.preload;

    /**
     * Saturation. Default is `1`.
     * @type {number|undefined}
     */
    olx.layer.TileOptions.prototype.saturation;

    /**
     * Source for this layer.
     * @type {ol.source.Source}
     */
    olx.layer.TileOptions.prototype.source;

    /**
     * Visibility. Default is `true` (visible).
     * @type {boolean|undefined}
     */
    olx.layer.TileOptions.prototype.visible;

    /**
     * The minimum resolution (inclusive) at which this layer will be visible.
     * @type {number|undefined}
     */
    olx.layer.TileOptions.prototype.minResolution;

    /**
     * The maximum resolution (exclusive) below which this layer will be visible.
     * @type {number|undefined}
     */
    olx.layer.TileOptions.prototype.maxResolution;

    /**
     * Use interim tiles on error. Default is `true`.
     * @type {boolean|undefined}
     */
    olx.layer.TileOptions.prototype.useInterimTilesOnError;

    /**
     * @typedef {{brightness: (number|undefined),
     *     contrast: (number|undefined),
     *     renderOrder: (function(ol.Feature, ol.Feature):number|null|undefined),
     *     hue: (number|undefined),
     *     minResolution: (number|undefined),
     *     maxResolution: (number|undefined),
     *     opacity: (number|undefined),
     *     saturation: (number|undefined),
     *     source: ol.source.Vector,
     *     style: (ol.style.Style|Array.<ol.style.Style>|ol.feature.StyleFunction|undefined),
     *     visible: (boolean|undefined)}}
     * @todo api
     */
    olx.layer.VectorOptions;

    /**
     * Brightness.
     * @type {number|undefined}
     */
    olx.layer.VectorOptions.prototype.brightness;

    /**
     * Contrast.
     * @type {number|undefined}
     */
    olx.layer.VectorOptions.prototype.contrast;

    /**
     * Render order. Function to be used when sorting features before rendering. By
     * default features are drawn in the order that they are created. Use `null` to
     * avoid the sort, but get an undefined draw order.
     * @type {function(ol.Feature, ol.Feature):number|null|undefined}
     */
    olx.layer.VectorOptions.prototype.renderOrder;

    /**
     * Hue.
     * @type {number|undefined}
     */
    olx.layer.VectorOptions.prototype.hue;

    /**
     * The minimum resolution (inclusive) at which this layer will be visible.
     * @type {number|undefined}
     */
    olx.layer.VectorOptions.prototype.minResolution;

    /**
     * The maximum resolution (exclusive) below which this layer will be visible.
     * @type {number|undefined}
     */
    olx.layer.VectorOptions.prototype.maxResolution;

    /**
     * Opacity. 0-1. Default is `1`.
     * @type {number|undefined}
     */
    olx.layer.VectorOptions.prototype.opacity;

    /**
     * Saturation.
     * @type {number|undefined}
     */
    olx.layer.VectorOptions.prototype.saturation;

    /**
     * Source.
     * @type {ol.source.Vector}
     */
    olx.layer.VectorOptions.prototype.source;

    /**
     * Layer style.
     * @type {ol.style.Style|Array.<ol.style.Style>|ol.feature.StyleFunction|undefined}
     */
    olx.layer.VectorOptions.prototype.style;

    /**
     * Visibility. Default is `true` (visible).
     * @type {boolean|undefined}
     */
    olx.layer.VectorOptions.prototype.visible;

    /**
     * @typedef {{features: (Array.<ol.Feature>|ol.Collection|undefined),
     *     map: (ol.Map|undefined),
     *     style: (ol.style.Style|Array.<ol.style.Style>|ol.feature.StyleFunction|undefined)}}
     * @todo api
     */
    olx.FeatureOverlayOptions;

    /**
     * Features.
     * @type {Array.<ol.Feature>|ol.Collection|undefined}
     */
    olx.FeatureOverlayOptions.prototype.features;

    /**
     * Map.
     * @type {ol.Map|undefined}
     */
    olx.FeatureOverlayOptions.prototype.map;

    /**
     * Feature style.
     * @type {ol.style.Style|Array.<ol.style.Style>|ol.feature.StyleFunction|undefined}
     */
    olx.FeatureOverlayOptions.prototype.style;

    /**
     * @typedef {{culture: (string|undefined),
     *     key: string,
     *     imagerySet: string,
     *     tileLoadFunction: (ol.TileLoadFunctionType|undefined)}}
     * @todo api
     */
    olx.source.BingMapsOptions;

    /**
     * Culture code. Default is `en-us`.
     * @type {string|undefined}
     */
    olx.source.BingMapsOptions.prototype.culture;

    /**
     * Bing Maps API key. Get yours at http://bingmapsportal.com/.
     * @type {string}
     */
    olx.source.BingMapsOptions.prototype.key;

    /**
     * Type of imagery.
     * @type {string}
     */
    olx.source.BingMapsOptions.prototype.imagerySet;

    /**
     * Optional function to load a tile given a URL.
     * @type {ol.TileLoadFunctionType|undefined}
     */
    olx.source.BingMapsOptions.prototype.tileLoadFunction;

    /**
     * @typedef {{attributions: (Array.<ol.Attribution>|undefined),
     *     extent: (ol.Extent|undefined),
     *     format: ol.format.Feature,
     *     logo: (string|undefined),
     *     projection: ol.proj.ProjectionLike}}
     * @todo api
     */
    olx.source.FormatVectorOptions;

    /**
     * Attributions.
     * @type {Array.<ol.Attribution>|undefined}
     */
    olx.source.FormatVectorOptions.prototype.attributions;

    /**
     * Extent.
     * @type {ol.Extent|undefined}
     */
    olx.source.FormatVectorOptions.prototype.extent;

    /**
     * Format.
     * @type {ol.format.Feature}
     */
    olx.source.FormatVectorOptions.prototype.format;

    /**
     * Logo.
     * @type {string|undefined}
     */
    olx.source.FormatVectorOptions.prototype.logo;

    /**
     * Projection.
     * @type {ol.proj.ProjectionLike}
     */
    olx.source.FormatVectorOptions.prototype.projection;

    /**
     * @typedef {{attributions: (Array.<ol.Attribution>|undefined),
     *     defaultProjection: ol.proj.ProjectionLike,
     *     extent: (ol.Extent|undefined),
     *     logo: (string|undefined),
     *     object: (GeoJSONObject|undefined),
     *     projection: ol.proj.ProjectionLike,
     *     text: (string|undefined),
     *     url: (string|undefined),
     *     urls: (Array.<string>|undefined)}}
     * @todo api
     */
    olx.source.GeoJSONOptions;

    /**
     * Attributions.
     * @type {Array.<ol.Attribution>|undefined}
     */
    olx.source.GeoJSONOptions.prototype.attributions;

    /**
     * Default projection.
     * @type {ol.proj.ProjectionLike}
     */
    olx.source.GeoJSONOptions.prototype.defaultProjection;

    /**
     * Extent.
     * @type {ol.Extent|undefined}
     */
    olx.source.GeoJSONOptions.prototype.extent;

    /**
     * Logo.
     * @type {string|undefined}
     */
    olx.source.GeoJSONOptions.prototype.logo;

    /**
     * Object.
     * @type {GeoJSONObject|undefined}
     */
    olx.source.GeoJSONOptions.prototype.object;

    /**
     * Destination projection. If provided, features will be transformed to this
     * projection. If not provided, features will not be transformed.
     * @type {ol.proj.ProjectionLike}
     */
    olx.source.GeoJSONOptions.prototype.projection;

    /**
     * Text.
     * @type {string|undefined}
     */
    olx.source.GeoJSONOptions.prototype.text;

    /**
     * URL.
     * @type {string|undefined}
     */
    olx.source.GeoJSONOptions.prototype.url;

    /**
     * URLs.
     * @type {Array.<string>|undefined}
     */
    olx.source.GeoJSONOptions.prototype.urls;

    /**
     * @typedef {{attributions: (Array.<ol.Attribution>|undefined),
     *     doc: (Document|undefined),
     *     extent: (ol.Extent|undefined),
     *     logo: (string|undefined),
     *     node: (Node|undefined),
     *     projection: ol.proj.ProjectionLike,
     *     text: (string|undefined),
     *     url: (string|undefined),
     *     urls: (Array.<string>|undefined)}}
     * @todo api
     */
    olx.source.GPXOptions;

    /**
     * Attributions.
     * @type {Array.<ol.Attribution>|undefined}
     */
    olx.source.GPXOptions.prototype.attributions;

    /**
     * Document.
     * @type {Document|undefined}
     */
    olx.source.GPXOptions.prototype.doc;

    /**
     * Extent.
     * @type {ol.Extent|undefined}
     */
    olx.source.GPXOptions.prototype.extent;

    /**
     * Logo.
     * @type {string|undefined}
     */
    olx.source.GPXOptions.prototype.logo;

    /**
     * Node.
     * @type {Node|undefined}
     */
    olx.source.GPXOptions.prototype.node;

    /**
     * Destination projection. If provided, features will be transformed to this
     * projection. If not provided, features will not be transformed.
     * @type {ol.proj.ProjectionLike}
     */
    olx.source.GPXOptions.prototype.projection;

    /**
     * Text.
     * @type {string|undefined}
     */
    olx.source.GPXOptions.prototype.text;

    /**
     * URL.
     * @type {string|undefined}
     */
    olx.source.GPXOptions.prototype.url;

    /**
     * URLs.
     * @type {Array.<string>|undefined}
     */
    olx.source.GPXOptions.prototype.urls;

    /**
     * @typedef {{attributions: (Array.<ol.Attribution>|undefined),
     *            crossOrigin: (null|string|undefined),
     *            extent: (ol.Extent|undefined),
     *            logo: (string|undefined),
     *            opaque: (boolean|undefined),
     *            pixelRatio: (number|undefined),
     *            projection: ol.proj.ProjectionLike,
     *            tileClass: (function(new: ol.ImageTile, ol.TileCoord,
     *                                 ol.TileState, string, ?string,
     *                                 ol.TileLoadFunctionType)|undefined),
     *            tileGrid: (ol.tilegrid.TileGrid|undefined),
     *            tileLoadFunction: (ol.TileLoadFunctionType|undefined),
     *            tileUrlFunction: (ol.TileUrlFunctionType|undefined)}}
     * @todo api
     */
    olx.source.TileImageOptions;

    /**
     * Attributions.
     * @type {Array.<ol.Attribution>|undefined}
     */
    olx.source.TileImageOptions.prototype.attributions;

    /**
     * crossOrigin setting for image requests. Default is `null`.
     * @type {null|string|undefined}
     */
    olx.source.TileImageOptions.prototype.crossOrigin;

    /**
     * Extent.
     * @type {ol.Extent|undefined}
     */
    olx.source.TileImageOptions.prototype.extent;

    /**
     * Logo.
     * @type {string|undefined}
     */
    olx.source.TileImageOptions.prototype.logo;

    /**
     * Whether the layer is opaque.
     * @type {boolean|undefined}
     */
    olx.source.TileImageOptions.prototype.opaque;

    /**
     * Tile size pixel ratio provided by the server.
     * @type {number|undefined}
     */
    olx.source.TileImageOptions.prototype.pixelRatio;

    /**
     * Projection.
     * @type {ol.proj.ProjectionLike}
     */
    olx.source.TileImageOptions.prototype.projection;

    /**
     * tile class
     * @type {function(new: ol.ImageTile, ol.TileCoord,
     *                 ol.TileState, string, ?string,
     *                 ol.TileLoadFunctionType)|undefined}
     */
    olx.source.TileImageOptions.prototype.tileClass;

    /**
     * Tile grid.
     * @type {ol.tilegrid.TileGrid|undefined}
     */
    olx.source.TileImageOptions.prototype.tileGrid;

    /**
     * Optional function to load a tile given a URL.
     * @type {ol.TileLoadFunctionType|undefined}
     */
    olx.source.TileImageOptions.prototype.tileLoadFunction;

    /**
     * Optional function to get tile URL given a tile coordinate and the projection.
     * @type {ol.TileUrlFunctionType|undefined}
     */
    olx.source.TileImageOptions.prototype.tileUrlFunction;

    /**
     * @typedef {{attributions: (Array.<ol.Attribution>|undefined),
     *     defaultProjection: ol.proj.ProjectionLike,
     *     extent: (ol.Extent|undefined),
     *     logo: (string|undefined),
     *     object: (GeoJSONObject|undefined),
     *     projection: ol.proj.ProjectionLike,
     *     tileGrid: ol.tilegrid.TileGrid,
     *     tileUrlFunction: (ol.TileUrlFunctionType|undefined),
     *     url: (string|undefined),
     *     urls: (Array.<string>|undefined)}}
     * @todo api
     */
    olx.source.TileVectorOptions;

    /**
     * Attributions.
     * @type {Array.<ol.Attribution>|undefined}
     */
    olx.source.TileVectorOptions.prototype.attributions;

    /**
     * Default projection.
     * @type {ol.proj.ProjectionLike}
     */
    olx.source.TileVectorOptions.prototype.defaultProjection;

    /**
     * Extent.
     * @type {ol.Extent|undefined}
     */
    olx.source.TileVectorOptions.prototype.extent;

    /**
     * Logo.
     * @type {string|undefined}
     */
    olx.source.TileVectorOptions.prototype.logo;

    /**
     * Object.
     * @type {GeoJSONObject|undefined}
     */
    olx.source.TileVectorOptions.prototype.object;

    /**
     * Destination projection. If provided, features will be transformed to this
     * projection. If not provided, features will not be transformed.
     * @type {ol.proj.ProjectionLike}
     */
    olx.source.TileVectorOptions.prototype.projection;

    /**
     * Tile grid.
     * @type {ol.tilegrid.TileGrid}
     */
    olx.source.TileVectorOptions.prototype.tileGrid;

    /**
     * Optional function to get tile URL given a tile coordinate and the projection.
     * Required if url or urls are not provided.
     * @type {ol.TileUrlFunctionType|undefined}
     */
    olx.source.TileVectorOptions.prototype.tileUrlFunction;

    /**
     * URL template. Must include `{x}`, `{y}` or `{-y}`, and `{z}` placeholders.
     * @type {string|undefined}
     */
    olx.source.TileVectorOptions.prototype.url;

    /**
     * An array of URL templates.
     * @type {Array.<string>|undefined}
     */
    olx.source.TileVectorOptions.prototype.urls;

    /**
     * @typedef {{attributions: (Array.<ol.Attribution>|undefined),
     *     defaultProjection: ol.proj.ProjectionLike,
     *     extent: (ol.Extent|undefined),
     *     logo: (string|undefined),
     *     object: (GeoJSONObject|undefined),
     *     projection: ol.proj.ProjectionLike,
     *     text: (string|undefined),
     *     url: (string|undefined)}}
     * @todo api
     */
    olx.source.TopoJSONOptions;

    /**
     * Attributions.
     * @type {Array.<ol.Attribution>|undefined}
     */
    olx.source.TopoJSONOptions.prototype.attributions;

    /**
     * Default projection.
     * @type {ol.proj.ProjectionLike}
     */
    olx.source.TopoJSONOptions.prototype.defaultProjection;

    /**
     * Extent.
     * @type {ol.Extent|undefined}
     */
    olx.source.TopoJSONOptions.prototype.extent;

    /**
     * Logo.
     * @type {string|undefined}
     */
    olx.source.TopoJSONOptions.prototype.logo;

    /**
     * Object.
     * @type {GeoJSONObject|undefined}
     */
    olx.source.TopoJSONOptions.prototype.object;

    /**
     * Destination projection. If provided, features will be transformed to this
     * projection. If not provided, features will not be transformed.
     * @type {ol.proj.ProjectionLike}
     */
    olx.source.TopoJSONOptions.prototype.projection;

    /**
     * Text.
     * @type {string|undefined}
     */
    olx.source.TopoJSONOptions.prototype.text;

    /**
     * URL.
     * @type {string|undefined}
     */
    olx.source.TopoJSONOptions.prototype.url;

    /**
     * @typedef {{altitudeMode: (ol.format.IGCZ|undefined),
     *     projection: ol.proj.ProjectionLike,
     *     text: (string|undefined),
     *     url: (string|undefined),
     *     urls: (Array.<string>|undefined)}}
     * @todo api
     */
    olx.source.IGCOptions;

    /**
     * Altitude mode. Possible values are `barometric`, `gps`, and `none`. Default
     * is `none`.
     * @type {ol.format.IGCZ|undefined}
     */
    olx.source.IGCOptions.prototype.altitudeMode;

    /**
     * Destination projection. If provided, features will be transformed to this
     * projection. If not provided, features will not be transformed.
     * @type {ol.proj.ProjectionLike}
     */
    olx.source.IGCOptions.prototype.projection;

    /**
     * Text.
     * @type {string|undefined}
     */
    olx.source.IGCOptions.prototype.text;

    /**
     * URL.
     * @type {string|undefined}
     */
    olx.source.IGCOptions.prototype.url;

    /**
     * URLs.
     * @type {Array.<string>|undefined}
     */
    olx.source.IGCOptions.prototype.urls;

    /**
     * @typedef {{url: (string|undefined),
     *     displayDpi: (number|undefined),
     *     metersPerUnit: (number|undefined),
     *     extent: (ol.Extent|undefined),
     *     hidpi: (boolean|undefined),
     *     useOverlay: (boolean|undefined),
     *     projection: ol.proj.ProjectionLike,
     *     ratio: (number|undefined),
     *     resolutions: (Array.<number>|undefined),
     *     params: (Object|undefined)}}
     * @todo api
     */
    olx.source.MapGuideOptions;

    /**
     * The mapagent url.
     * @type {string|undefined}
     */
    olx.source.MapGuideOptions.prototype.url;

    /**
     * The display resolution. Default is `96`.
     * @type {number|undefined}
     */
    olx.source.MapGuideOptions.prototype.displayDpi;

    /**
     * The meters-per-unit value. Default is `1`.
     * @type {number|undefined}
     */
    olx.source.MapGuideOptions.prototype.metersPerUnit;

    /**
     * Extent.
     * @type {ol.Extent|undefined}
     */
    olx.source.MapGuideOptions.prototype.extent;

    /**
     * Use the `ol.Map#pixelRatio` value when requesting the image from the remote
     * server. Default is `true`.
     * @type {boolean|undefined}
     */
    olx.source.MapGuideOptions.prototype.hidpi;

    /**
     * If `true`, will use `GETDYNAMICMAPOVERLAYIMAGE`.
     * @type {boolean|undefined}
     */
    olx.source.MapGuideOptions.prototype.useOverlay;

    /**
     * Projection.
     * @type {ol.proj.ProjectionLike}
     */
    olx.source.MapGuideOptions.prototype.projection;

    /**
     * Ratio. `1` means image requests are the size of the map viewport, `2` means
     * twice the size of the map viewport, and so on. Default is `1`.
     * @type {number|undefined}
     */
    olx.source.MapGuideOptions.prototype.ratio;

    /**
     * Resolutions. If specified, requests will be made for these resolutions only.
     * @type {Array.<number>|undefined}
     */
    olx.source.MapGuideOptions.prototype.resolutions;

    /**
     * Additional parameters.
     * @type {Object|undefined}
     */
    olx.source.MapGuideOptions.prototype.params;

    /**
     * @typedef {{attributions: (Array.<ol.Attribution>|undefined),
     *     defaultStyle: (Array.<ol.style.Style>|undefined),
     *     doc: (Document|undefined),
     *     extent: (ol.Extent|undefined),
     *     logo: (string|undefined),
     *     node: (Node|undefined),
     *     projection: ol.proj.ProjectionLike,
     *     text: (string|undefined),
     *     url: (string|undefined),
     *     urls: (Array.<string>|undefined)}}
     * @todo api
     */
    olx.source.KMLOptions;

    /**
     * Attributions.
     * @type {Array.<ol.Attribution>|undefined}
     */
    olx.source.KMLOptions.prototype.attributions;

    /**
     * Default style.
     * @type {Array.<ol.style.Style>|undefined}
     */
    olx.source.KMLOptions.prototype.defaultStyle;

    /**
     * Document.
     * @type {Document|undefined}
     */
    olx.source.KMLOptions.prototype.doc;

    /**
     * Extent.
     * @type {ol.Extent|undefined}
     */
    olx.source.KMLOptions.prototype.extent;

    /**
     * Logo.
     * @type {string|undefined}
     */
    olx.source.KMLOptions.prototype.logo;

    /**
     * Node.
     * @type {Node|undefined}
     */
    olx.source.KMLOptions.prototype.node;

    /**
     * Destination projection. If provided, features will be transformed to this
     * projection. If not provided, features will not be transformed.
     * @type {ol.proj.ProjectionLike}
     */
    olx.source.KMLOptions.prototype.projection;

    /**
     * Text.
     * @type {string|undefined}
     */
    olx.source.KMLOptions.prototype.text;

    /**
     * URL.
     * @type {string|undefined}
     */
    olx.source.KMLOptions.prototype.url;

    /**
     * URLs.
     * @type {Array.<string>|undefined}
     */
    olx.source.KMLOptions.prototype.urls;

    /**
     * @typedef {{layer: string,
     *     tileLoadFunction: (ol.TileLoadFunctionType|undefined)}}
     * @todo api
     */
    olx.source.MapQuestOptions;

    /**
     * Layer. Possible values are `osm`, `sat`, and `hyb`.
     * @type {string}
     */
    olx.source.MapQuestOptions.prototype.layer;

    /**
     * Optional function to load a tile given a URL.
     * @type {ol.TileLoadFunctionType|undefined}
     */
    olx.source.MapQuestOptions.prototype.tileLoadFunction;

    /**
     * @typedef {{extent: (ol.Extent|undefined),
     *     projection: ol.proj.ProjectionLike,
     *     tileGrid: (ol.tilegrid.TileGrid|undefined)}}
     * @todo api
     */
    olx.source.TileDebugOptions;

    /**
     * Extent.
     * @type {ol.Extent|undefined}
     */
    olx.source.TileDebugOptions.prototype.extent;

    /**
     * Projection.
     * @type {ol.proj.ProjectionLike}
     */
    olx.source.TileDebugOptions.prototype.projection;

    /**
     * Tile grid.
     * @type {ol.tilegrid.TileGrid|undefined}
     */
    olx.source.TileDebugOptions.prototype.tileGrid;

    /**
     * @typedef {{attributions: (Array.<ol.Attribution>|undefined),
     *     crossOrigin: (null|string|undefined),
     *     maxZoom: (number|undefined),
     *     tileLoadFunction: (ol.TileLoadFunctionType|undefined),
     *     url: (string|undefined)}}
     * @todo api
     */
    olx.source.OSMOptions;

    /**
     * Attributions.
     * @type {Array.<ol.Attribution>|undefined}
     */
    olx.source.OSMOptions.prototype.attributions;

    /**
     * crossOrigin setting for image requests. Default is `anonymous`.
     * @type {null|string|undefined}
     */
    olx.source.OSMOptions.prototype.crossOrigin;

    /**
     * Max zoom.
     * @type {number|undefined}
     */
    olx.source.OSMOptions.prototype.maxZoom;

    /**
     * Optional function to load a tile given a URL.
     * @type {ol.TileLoadFunctionType|undefined}
     */
    olx.source.OSMOptions.prototype.tileLoadFunction;

    /**
     * URL template. Must include `{x}`, `{y}` or `{-y}`, and `{z}` placeholders.
     * Default is `//{a-c}.tile.openstreetmap.org/{z}/{x}/{y}.png`.
     * @type {string|undefined}
     */
    olx.source.OSMOptions.prototype.url;

    /**
     * @typedef {{attributions: (Array.<ol.Attribution>|undefined),
     *     defaultStyle: (Array.<ol.style.Style>|undefined),
     *     doc: (Document|undefined),
     *     extent: (ol.Extent|undefined),
     *     logo: (string|undefined),
     *     node: (Node|undefined),
     *     projection: ol.proj.ProjectionLike,
     *     reprojectTo: ol.proj.ProjectionLike,
     *     text: (string|undefined),
     *     url: (string|undefined),
     *     urls: (Array.<string>|undefined)}}
     * @todo api
     */
    olx.source.OSMXMLOptions;

    /**
     * Attributions.
     * @type {Array.<ol.Attribution>|undefined}
     */
    olx.source.OSMXMLOptions.prototype.attributions;

    /**
     * Default style.
     * @type {Array.<ol.style.Style>|undefined}
     */
    olx.source.OSMXMLOptions.prototype.defaultStyle;

    /**
     * Document.
     * @type {Document|undefined}
     */
    olx.source.OSMXMLOptions.prototype.doc;

    /**
     * Extent.
     * @type {ol.Extent|undefined}
     */
    olx.source.OSMXMLOptions.prototype.extent;

    /**
     * Logo.
     * @type {string|undefined}
     */
    olx.source.OSMXMLOptions.prototype.logo;

    /**
     * Node.
     * @type {Node|undefined}
     */
    olx.source.OSMXMLOptions.prototype.node;

    /**
     * Projection.
     * @type {ol.proj.ProjectionLike}
     */
    olx.source.OSMXMLOptions.prototype.projection;

    /**
     * Re-project to.
     * @type {ol.proj.ProjectionLike}
     */
    olx.source.OSMXMLOptions.prototype.reprojectTo;

    /**
     * Text.
     * @type {string|undefined}
     */
    olx.source.OSMXMLOptions.prototype.text;

    /**
     * URL.
     * @type {string|undefined}
     */
    olx.source.OSMXMLOptions.prototype.url;

    /**
     * URLs.
     * @type {Array.<string>|undefined}
     */
    olx.source.OSMXMLOptions.prototype.urls;

    /**
     * @typedef {{attributions: (Array.<ol.Attribution>|undefined),
     *     canvasFunction: ol.CanvasFunctionType,
     *     extent: (ol.Extent|undefined),
     *     logo: (string|undefined),
     *     projection: ol.proj.ProjectionLike,
     *     ratio: (number|undefined),
     *     resolutions: (Array.<number>|undefined),
     *     state: (ol.source.State|string|undefined)}}
     * @todo api
     */
    olx.source.ImageCanvasOptions;

    /**
     * Attributions.
     * @type {Array.<ol.Attribution>|undefined}
     */
    olx.source.ImageCanvasOptions.prototype.attributions;

    /**
     * Canvas function. The function returning the canvas element used by the source
     * as an image. The arguments passed to the function are: `{ol.Extent}` the
     * image extent, `{number}` the image resolution, `{number}` the device pixel
     * ratio, `{ol.Size}` the image size, and `{ol.proj.Projection}` the image
     * projection. The canvas returned by this function is cached by the source. If
     * the value returned by the function is later changed then
     * `dispatchChangeEvent` should be called on the source for the source to
     * invalidate the current cached image.
     * @type {ol.CanvasFunctionType}
     */
    olx.source.ImageCanvasOptions.prototype.canvasFunction;

    /**
     * Extent.
     * @type {ol.Extent|undefined}
     */
    olx.source.ImageCanvasOptions.prototype.extent;

    /**
     * Logo.
     * @type {string|undefined}
     */
    olx.source.ImageCanvasOptions.prototype.logo;

    /**
     * Projection.
     * @type {ol.proj.ProjectionLike}
     */
    olx.source.ImageCanvasOptions.prototype.projection;

    /**
     * Ratio. 1 means canvases are the size of the map viewport, 2 means twice the
     * size of the map viewport, and so on. Default is `1.5`.
     * @type {number|undefined}
     */
    olx.source.ImageCanvasOptions.prototype.ratio;

    /**
     * Resolutions. If specified, new canvases will be created for these resolutions
     * only.
     * @type {Array.<number>|undefined}
     */
    olx.source.ImageCanvasOptions.prototype.resolutions;

    /**
     * Source state.
     * @type {ol.source.State|string|undefined}
     */
    olx.source.ImageCanvasOptions.prototype.state;

    /**
     * @typedef {{attributions: (Array.<ol.Attribution>|undefined),
     *     extent: (ol.Extent|undefined),
     *     logo: (string|undefined),
     *     projection: ol.proj.ProjectionLike,
     *     ratio: (number|undefined),
     *     resolutions: (Array.<number>|undefined),
     *     source: ol.source.Vector,
     *     style: (ol.style.Style|Array.<ol.style.Style>|ol.feature.StyleFunction|undefined)}}
     * @todo api
     */
    olx.source.ImageVectorOptions;

    /**
     * Attributions.
     * @type {Array.<ol.Attribution>|undefined}
     */
    olx.source.ImageVectorOptions.prototype.attributions;

    /**
     * Extent.
     * @type {ol.Extent|undefined}
     */
    olx.source.ImageVectorOptions.prototype.extent;

    /**
     * Logo.
     * @type {string|undefined}
     */
    olx.source.ImageVectorOptions.prototype.logo;

    /**
     * Projection.
     * @type {ol.proj.ProjectionLike}
     */
    olx.source.ImageVectorOptions.prototype.projection;

    /**
     * Ratio. 1 means canvases are the size of the map viewport, 2 means twice the
     * size of the map viewport, and so on. Default is `1.5`.
     * @type {number|undefined}
     */
    olx.source.ImageVectorOptions.prototype.ratio;

    /**
     * Resolutions. If specified, new canvases will be created for these resolutions
     * only.
     * @type {Array.<number>|undefined}
     */
    olx.source.ImageVectorOptions.prototype.resolutions;

    /**
     * The vector source from which the vector features drawn in canvas elements are
     * read.
     * @type {ol.source.Vector}
     */
    olx.source.ImageVectorOptions.prototype.source;

    /**
     * Style to use when rendering features to the canvas.
     * @type {ol.style.Style|Array.<ol.style.Style>|ol.feature.StyleFunction|undefined}
     */
    olx.source.ImageVectorOptions.prototype.style;

    /**
     * @typedef {{attributions: (Array.<ol.Attribution>|undefined),
     *     crossOrigin: (null|string|undefined),
     *     extent: (ol.Extent|undefined),
     *     hidpi: (boolean|undefined),
     *     serverType: (ol.source.wms.ServerType|string|undefined),
     *     logo: (string|undefined),
     *     params: Object.<string,*>,
     *     projection: ol.proj.ProjectionLike,
     *     ratio: (number|undefined),
     *     resolutions: (Array.<number>|undefined),
     *     url: (string|undefined)}}
     * @todo api
     */
    olx.source.ImageWMSOptions;

    /**
     * Attributions.
     * @type {Array.<ol.Attribution>|undefined}
     */
    olx.source.ImageWMSOptions.prototype.attributions;

    /**
     * crossOrigin setting for image requests.
     * @type {null|string|undefined}
     */
    olx.source.ImageWMSOptions.prototype.crossOrigin;

    /**
     * Extent.
     * @type {ol.Extent|undefined}
     */
    olx.source.ImageWMSOptions.prototype.extent;

    /**
     * Use the `ol.Map#pixelRatio` value when requesting the image from the remote
     * server. Default is `true`.
     * @type {boolean|undefined}
     */
    olx.source.ImageWMSOptions.prototype.hidpi;

    /**
     * The type of the remote WMS server: `mapserver`, `geoserver` or `qgis`. Only
     * needed if `hidpi` is `true`. Default is `undefined`.
     * @type {ol.source.wms.ServerType|string|undefined}
     */
    olx.source.ImageWMSOptions.prototype.serverType;

    /**
     * Logo.
     * @type {string|undefined}
     */
    olx.source.ImageWMSOptions.prototype.logo;

    /**
     * WMS request parameters. At least a `LAYERS` param is required. `STYLES` is
     * `''` by default. `VERSION` is `1.3.0` by default. `WIDTH`, `HEIGHT`, `BBOX`
     * and `CRS` (`SRS` for WMS version < 1.3.0) will be set dynamically.
     * @type {Object.<string,*>}
     */
    olx.source.ImageWMSOptions.prototype.params;

    /**
     * Projection.
     * @type {ol.proj.ProjectionLike}
     */
    olx.source.ImageWMSOptions.prototype.projection;

    /**
     * Ratio. `1` means image requests are the size of the map viewport, `2` means
     * twice the size of the map viewport, and so on. Default is `1.5`.
     * @type {number|undefined}
     */
    olx.source.ImageWMSOptions.prototype.ratio;

    /**
     * Resolutions. If specified, requests will be made for these resolutions only.
     * @type {Array.<number>|undefined}
     */
    olx.source.ImageWMSOptions.prototype.resolutions;

    /**
     * WMS service URL.
     * @type {string|undefined}
     */
    olx.source.ImageWMSOptions.prototype.url;

    /**
     * @typedef {{layer: string,
     *     minZoom: (number|undefined),
     *     maxZoom: (number|undefined),
     *     opaque: (boolean|undefined),
     *     tileLoadFunction: (ol.TileLoadFunctionType|undefined),
     *     url: (string|undefined)}}
     * @todo api
     */
    olx.source.StamenOptions;

    /**
     * Layer.
     * @type {string}
     */
    olx.source.StamenOptions.prototype.layer;

    /**
     * Minimum zoom.
     * @type {number|undefined}
     */
    olx.source.StamenOptions.prototype.minZoom;

    /**
     * Maximum zoom.
     * @type {number|undefined}
     */
    olx.source.StamenOptions.prototype.maxZoom;

    /**
     * Whether the layer is opaque.
     * @type {boolean|undefined}
     */
    olx.source.StamenOptions.prototype.opaque;

    /**
     * Optional function to load a tile given a URL.
     * @type {ol.TileLoadFunctionType|undefined}
     */
    olx.source.StamenOptions.prototype.tileLoadFunction;

    /**
     * URL template. Must include `{x}`, `{y}` or `{-y}`, and `{z}` placeholders.
     * @type {string|undefined}
     */
    olx.source.StamenOptions.prototype.url;

    /**
     * @typedef {{attributions: (Array.<ol.Attribution>|undefined),
     *     crossOrigin: (null|string|undefined),
     *     extent: (ol.Extent|undefined),
     *     imageExtent: (ol.Extent|undefined),
     *     imageSize: (ol.Size|undefined),
     *     logo: (string|undefined),
     *     projection: ol.proj.ProjectionLike,
     *     url: string}}
     * @todo api
     */
    olx.source.ImageStaticOptions;

    /**
     * Attributions.
     * @type {Array.<ol.Attribution>|undefined}
     */
    olx.source.ImageStaticOptions.prototype.attributions;

    /**
     * crossOrigin setting for image requests.
     * @type {null|string|undefined}
     */
    olx.source.ImageStaticOptions.prototype.crossOrigin;

    /**
     * Extent.
     * @type {ol.Extent|undefined}
     */
    olx.source.ImageStaticOptions.prototype.extent;

    /**
     * Extent of the image.
     * @type {ol.Extent|undefined}
     */
    olx.source.ImageStaticOptions.prototype.imageExtent;

    /**
     * Size of the image.
     * @type {ol.Size|undefined}
     */
    olx.source.ImageStaticOptions.prototype.imageSize;

    /**
     * Logo.
     * @type {string|undefined}
     */
    olx.source.ImageStaticOptions.prototype.logo;

    /**
     * Projection.
     * @type {ol.proj.ProjectionLike}
     */
    olx.source.ImageStaticOptions.prototype.projection;

    /**
     * Url.
     * @type {string}
     */
    olx.source.ImageStaticOptions.prototype.url;

    /**
     * @typedef {{attributions: (Array.<ol.Attribution>|undefined),
     *     extent: (ol.Extent|undefined),
     *     format: ol.format.Feature,
     *     loader: function(this: ol.source.ServerVector, ol.Extent, number, ol.proj.Projection),
     *     strategy: (function(ol.Extent, number): Array.<ol.Extent>|undefined),
     *     logo: (string|undefined),
     *     projection: ol.proj.ProjectionLike}}
     * @todo api
     */
    olx.source.ServerVectorOptions;

    /**
     * Attributions.
     * @type {Array.<ol.Attribution>|undefined}
     */
    olx.source.ServerVectorOptions.prototype.attributions;

    /**
     * Extent.
     * @type {ol.Extent|undefined}
     */
    olx.source.ServerVectorOptions.prototype.extent;

    /**
     * Format.
     * @type {ol.format.Feature}
     */
    olx.source.ServerVectorOptions.prototype.format;

    /**
     * Loading function.
     * @type {function(this: ol.source.ServerVector, ol.Extent, number, ol.proj.Projection)}
     */
    olx.source.ServerVectorOptions.prototype.loader;

    /**
     * Loading strategy. An {@link ol.loadingstrategy} or a custom function.
     * Default is {@link ol.loadingstrategy.bbox}.
     * @type {function(ol.Extent, number): Array.<ol.Extent>|undefined}
     */
    olx.source.ServerVectorOptions.prototype.strategy;

    /**
     * Logo.
     * @type {string|undefined}
     */
    olx.source.ServerVectorOptions.prototype.logo;

    /**
     * Projection.
     * @type {ol.proj.ProjectionLike}
     */
    olx.source.ServerVectorOptions.prototype.projection;

    /**
     * @typedef {{crossOrigin: (null|string|undefined),
     *     tileLoadFunction: (ol.TileLoadFunctionType|undefined),
     *     url: string}}
     * @todo api
     */
    olx.source.TileJSONOptions;

    /**
     * crossOrigin setting for image requests.
     * @type {null|string|undefined}
     */
    olx.source.TileJSONOptions.prototype.crossOrigin;

    /**
     * Optional function to load a tile given a URL.
     * @type {ol.TileLoadFunctionType|undefined}
     */
    olx.source.TileJSONOptions.prototype.tileLoadFunction;

    /**
     * URL to the TileJSON file.
     * @type {string}
     */
    olx.source.TileJSONOptions.prototype.url;

    /**
     * @typedef {{attributions: (Array.<ol.Attribution>|undefined),
     *     params: Object.<string,*>,
     *     crossOrigin: (null|string|undefined),
     *     extent: (ol.Extent|undefined),
     *     gutter: (number|undefined),
     *     hidpi: (boolean|undefined),
     *     logo: (string|undefined),
     *     tileGrid: (ol.tilegrid.TileGrid|undefined),
     *     maxZoom: (number|undefined),
     *     projection: ol.proj.ProjectionLike,
     *     serverType: (ol.source.wms.ServerType|string|undefined),
     *     tileLoadFunction: (ol.TileLoadFunctionType|undefined),
     *     url: (string|undefined),
     *     urls: (Array.<string>|undefined)}}
     * @todo api
     */
    olx.source.TileWMSOptions;

    /**
     * Attributions.
     * @type {Array.<ol.Attribution>|undefined}
     */
    olx.source.TileWMSOptions.prototype.attributions;

    /**
     * WMS request parameters. At least a `LAYERS` param is required. `STYLES` is
     * `''` by default. `VERSION` is `1.3.0` by default. `WIDTH`, `HEIGHT`, `BBOX`
     * and `CRS` (`SRS` for WMS version < 1.3.0) will be set dynamically.
     * @type {Object.<string,*>}
     */
    olx.source.TileWMSOptions.prototype.params;

    /**
     * crossOrigin setting for image requests.
     * @type {null|string|undefined}
     */
    olx.source.TileWMSOptions.prototype.crossOrigin;

    /**
     * Extent.
     * @type {ol.Extent|undefined}
     */
    olx.source.TileWMSOptions.prototype.extent;

    /**
     * The size in pixels of the gutter around image tiles to ignore. By setting
     * this property to a non-zero value, images will be requested that are wider
     * and taller than the tile size by a value of `2 x gutter`. Defaults to zero.
     * Using a non-zero value allows artifacts of rendering at tile edges to be
     * ignored. If you control the WMS service it is recommended to address
     * "artifacts at tile edges" issues by properly configuring the WMS service. For
     * example, MapServer has a `tile_map_edge_buffer` configuration parameter for
     * this. See http://mapserver.org/output/tile_mode.html.
     * @type {number|undefined}
     */
    olx.source.TileWMSOptions.prototype.gutter;

    /**
     * Use the `ol.Map#pixelRatio` value when requesting the image from the remote
     * server. Default is `true`.
     * @type {boolean|undefined}
     */
    olx.source.TileWMSOptions.prototype.hidpi;

    /**
     * Logo.
     * @type {string|undefined}
     */
    olx.source.TileWMSOptions.prototype.logo;

    /**
     * Tile grid.
     * @type {ol.tilegrid.TileGrid|undefined}
     */
    olx.source.TileWMSOptions.prototype.tileGrid;

    /**
     * Maximum zoom.
     * @type {number|undefined}
     */
    olx.source.TileWMSOptions.prototype.maxZoom;

    /**
     * Projection.
     * @type {ol.proj.ProjectionLike}
     */
    olx.source.TileWMSOptions.prototype.projection;

    /**
     * The type of the remote WMS server. Currently only used when `hidpi` is
     * `true`. Default is `undefined`.
     * @type {ol.source.wms.ServerType|string|undefined}
     */
    olx.source.TileWMSOptions.prototype.serverType;

    /**
     * Optional function to load a tile given a URL.
     * @type {ol.TileLoadFunctionType|undefined}
     */
    olx.source.TileWMSOptions.prototype.tileLoadFunction;

    /**
     * WMS service URL.
     * @type {string|undefined}
     */
    olx.source.TileWMSOptions.prototype.url;

    /**
     * WMS service urls. Use this instead of `url` when the WMS supports multiple
     * urls for GetMap requests.
     * @type {Array.<string>|undefined}
     */
    olx.source.TileWMSOptions.prototype.urls;

    /**
     * @typedef {{attributions: (Array.<ol.Attribution>|undefined),
     *     extent: (ol.Extent|undefined),
     *     features: (Array.<ol.Feature>|undefined),
     *     logo: (string|undefined),
     *     projection: ol.proj.ProjectionLike,
     *     state: (ol.source.State|string|undefined)}}
     * @todo api
     */
    olx.source.VectorOptions;

    /**
     * Attributions.
     * @type {Array.<ol.Attribution>|undefined}
     */
    olx.source.VectorOptions.prototype.attributions;

    /**
     * Extent.
     * @type {ol.Extent|undefined}
     */
    olx.source.VectorOptions.prototype.extent;

    /**
     * Features.
     * @type {Array.<ol.Feature>|undefined}
     */
    olx.source.VectorOptions.prototype.features;

    /**
     * Logo.
     * @type {string|undefined}
     */
    olx.source.VectorOptions.prototype.logo;

    /**
     * Projection.
     * @type {ol.proj.ProjectionLike}
     */
    olx.source.VectorOptions.prototype.projection;

    /**
     * State.
     * @type {ol.source.State|string|undefined}
     */
    olx.source.VectorOptions.prototype.state;

    /**
     * @typedef {{arrayBuffer: (ArrayBuffer|undefined),
     *     attributions: (Array.<ol.Attribution>|undefined),
     *     doc: (Document|undefined),
     *     extent: (ol.Extent|undefined),
     *     format: ol.format.Feature,
     *     logo: (string|undefined),
     *     node: (Node|undefined),
     *     object: (Object|undefined),
     *     projection: ol.proj.ProjectionLike,
     *     text: (string|undefined),
     *     url: (string|undefined),
     *     urls: (Array.<string>|undefined)}}
     * @todo api
     */
    olx.source.StaticVectorOptions;

    /**
     * Array buffer.
     * @type {ArrayBuffer|undefined}
     */
    olx.source.StaticVectorOptions.prototype.arrayBuffer;

    /**
     * Attributions.
     * @type {Array.<ol.Attribution>|undefined}
     */
    olx.source.StaticVectorOptions.prototype.attributions;

    /**
     * Document.
     * @type {Document|undefined}
     */
    olx.source.StaticVectorOptions.prototype.doc;

    /**
     * Extent.
     * @type {ol.Extent|undefined}
     */
    olx.source.StaticVectorOptions.prototype.extent;

    /**
     * Format.
     * @type {ol.format.Feature}
     */
    olx.source.StaticVectorOptions.prototype.format;

    /**
     * Logo.
     * @type {string|undefined}
     */
    olx.source.StaticVectorOptions.prototype.logo;

    /**
     * Node.
     * @type {Node|undefined}
     */
    olx.source.StaticVectorOptions.prototype.node;

    /**
     * Object.
     * @type {Object|undefined}
     */
    olx.source.StaticVectorOptions.prototype.object;

    /**
     * Projection.
     * @type {ol.proj.ProjectionLike}
     */
    olx.source.StaticVectorOptions.prototype.projection;

    /**
     * Text.
     * @type {string|undefined}
     */
    olx.source.StaticVectorOptions.prototype.text;

    /**
     * URL.
     * @type {string|undefined}
     */
    olx.source.StaticVectorOptions.prototype.url;

    /**
     * URLs.
     * @type {Array.<string>|undefined}
     */
    olx.source.StaticVectorOptions.prototype.urls;

    /**
     * @typedef {{attributions: (Array.<ol.Attribution>|undefined),
     *     crossOrigin: (string|null|undefined),
     *     extent: (ol.Extent|undefined),
     *     logo: (string|undefined),
     *     tileGrid: ol.tilegrid.WMTS,
     *     projection: ol.proj.ProjectionLike,
     *     requestEncoding: (ol.source.WMTSRequestEncoding|undefined),
     *     layer: string,
     *     style: string,
     *     version: (string|undefined),
     *     format: (string|undefined),
     *     matrixSet: string,
     *     dimensions: (Object|undefined),
     *     url: (string|undefined),
     *     pixelRatio: (number|undefined),
     *     maxZoom: (number|undefined),
     *     tileLoadFunction: (ol.TileLoadFunctionType|undefined),
     *     urls: (Array.<string>|undefined)}}
     * @todo api
     */
    olx.source.WMTSOptions;

    /**
     * Attributions.
     * @type {Array.<ol.Attribution>|undefined}
     */
    olx.source.WMTSOptions.prototype.attributions;

    /**
     * crossOrigin setting for image requests.
     * @type {string|null|undefined}
     */
    olx.source.WMTSOptions.prototype.crossOrigin;

    /**
     * Extent.
     * @type {ol.Extent|undefined}
     */
    olx.source.WMTSOptions.prototype.extent;

    /**
     * Logo.
     * @type {string|undefined}
     */
    olx.source.WMTSOptions.prototype.logo;

    /**
     * Device pixel ratio supported by the server.
     * @type {number|undefined}
     */
    olx.source.WMTSOptions.prototype.pixelRatio;

    /**
     * Tile grid.
     * @type {ol.tilegrid.WMTS}
     */
    olx.source.WMTSOptions.prototype.tileGrid;

    /**
     * Projection.
     * @type {ol.proj.ProjectionLike}
     */
    olx.source.WMTSOptions.prototype.projection;

    /**
     * Request encoding.
     * @type {ol.source.WMTSRequestEncoding|undefined}
     */
    olx.source.WMTSOptions.prototype.requestEncoding;

    /**
     * Layer.
     * @type {string}
     */
    olx.source.WMTSOptions.prototype.layer;

    /**
     * Style.
     * @type {string}
     */
    olx.source.WMTSOptions.prototype.style;

    /**
     * WMTS version. Default to `1.0.0`.
     * @type {string|undefined}
     */
    olx.source.WMTSOptions.prototype.version;

    /**
     * Format.
     * @type {string|undefined}
     */
    olx.source.WMTSOptions.prototype.format;

    /**
     * Matrix set.
     * @type {string}
     */
    olx.source.WMTSOptions.prototype.matrixSet;

    /**
     * Dimensions.
     * @type {Object|undefined}
     */
    olx.source.WMTSOptions.prototype.dimensions;

    /**
     * URL.
     * @type {string|undefined}
     */
    olx.source.WMTSOptions.prototype.url;

    /**
     * Maximum zoom.
     * @type {number|undefined}
     */
    olx.source.WMTSOptions.prototype.maxZoom;

    /**
     * Optional function to load a tile given a URL.
     * @type {ol.TileLoadFunctionType|undefined}
     */
    olx.source.WMTSOptions.prototype.tileLoadFunction;

    /**
     * Urls.
     * @type {Array.<string>|undefined}
     */
    olx.source.WMTSOptions.prototype.urls;

    /**
     * @typedef {{attributions: (Array.<ol.Attribution>|undefined),
     *     crossOrigin: (null|string|undefined),
     *     extent: (ol.Extent|undefined),
     *     logo: (string|undefined),
     *     projection: ol.proj.ProjectionLike,
     *     maxZoom: (number|undefined),
     *     minZoom: (number|undefined),
     *     tileLoadFunction: (ol.TileLoadFunctionType|undefined),
     *     tileUrlFunction: (ol.TileUrlFunctionType|undefined),
     *     url: (string|undefined),
     *     urls: (Array.<string>|undefined),
     *     wrapX: (boolean|undefined)}}
     * @todo api
     */
    olx.source.XYZOptions;

    /**
     * Attributions.
     * @type {Array.<ol.Attribution>|undefined}
     */
    olx.source.XYZOptions.prototype.attributions;

    /**
     * Cross origin setting for image requests.
     * @type {null|string|undefined}
     */
    olx.source.XYZOptions.prototype.crossOrigin;

    /**
     * Extent.
     * @type {ol.Extent|undefined}
     */
    olx.source.XYZOptions.prototype.extent;

    /**
     * Logo.
     * @type {string|undefined}
     */
    olx.source.XYZOptions.prototype.logo;

    /**
     * Projection. Default is `EPSG:3857`.
     * @type {ol.proj.ProjectionLike}
     */
    olx.source.XYZOptions.prototype.projection;

    /**
     * Optional max zoom level. Default is `18`.
     * @type {number|undefined}
     */
    olx.source.XYZOptions.prototype.maxZoom;

    /**
     * Unsupported (TODO: remove this).
     * @type {number|undefined}
     */
    olx.source.XYZOptions.prototype.minZoom;

    /**
     * Optional function to load a tile given a URL.
     * @type {ol.TileLoadFunctionType|undefined}
     */
    olx.source.XYZOptions.prototype.tileLoadFunction;

    /**
     * Optional function to get tile URL given a tile coordinate and the projection.
     * Required if url or urls are not provided.
     * @type {ol.TileUrlFunctionType|undefined}
     */
    olx.source.XYZOptions.prototype.tileUrlFunction;

    /**
     * URL template. Must include `{x}`, `{y}` or `{-y}`, and `{z}` placeholders.
     * @type {string|undefined}
     */
    olx.source.XYZOptions.prototype.url;

    /**
     * An array of URL templates.
     * @type {Array.<string>|undefined}
     */
    olx.source.XYZOptions.prototype.urls;

    /**
     * Whether to wrap the world horizontally. Default is `true`.
     * @type {boolean|undefined}
     */
    olx.source.XYZOptions.prototype.wrapX;

    /**
     * @typedef {{attributions: (Array.<ol.Attribution>|undefined),
     *     crossOrigin: (null|string|undefined),
     *     logo: (string|undefined),
     *     url: !string,
     *     tierSizeCalculation: (string|undefined),
     *     size: ol.Size}}
     * @todo api
     */
    olx.source.ZoomifyOptions;

    /**
     * Attributions.
     * @type {Array.<ol.Attribution>|undefined}
     */
    olx.source.ZoomifyOptions.prototype.attributions;

    /**
     * Cross origin setting for image requests.
     * @type {null|string|undefined}
     */
    olx.source.ZoomifyOptions.prototype.crossOrigin;

    /**
     * Logo.
     * @type {string|undefined}
     */
    olx.source.ZoomifyOptions.prototype.logo;

    /**
     * Prefix of URL template.
     * @type {!string}
     */
    olx.source.ZoomifyOptions.prototype.url;

    /**
     * Tier size calculation method: `default` or `truncated`.
     * @type {string|undefined}
     */
    olx.source.ZoomifyOptions.prototype.tierSizeCalculation;

    /**
     * Size of the image.
     * @type {ol.Size}
     */
    olx.source.ZoomifyOptions.prototype.size;

    /**
     * @typedef {{fill: (ol.style.Fill|undefined),
     *     radius: number,
     *     snapToPixel: (boolean|undefined),
     *     stroke: (ol.style.Stroke|undefined)}}
     * @todo api
     */
    olx.style.CircleOptions;

    /**
     * Fill style.
     * @type {ol.style.Fill|undefined}
     */
    olx.style.CircleOptions.prototype.fill;

    /**
     * Circle radius.
     * @type {number}
     */
    olx.style.CircleOptions.prototype.radius;

    /**
     * If `true` integral numbers of pixels are used as the X and Y pixel
     * coordinate when drawing the circle in the output canvas. If `false`
     * fractional numbers may be used. Using `true` allows for "sharp"
     * rendering (no blur), while using `false` allows for "accurate"
     * rendering. Note that accuracy is important if the circle's
     * position is animated. Without it, the circle may jitter noticeably.
     * Default value is `true`.
     * @type {boolean|undefined}
     */
    olx.style.CircleOptions.prototype.snapToPixel;

    /**
     * Stroke style.
     * @type {ol.style.Stroke|undefined}
     */
    olx.style.CircleOptions.prototype.stroke;

    /**
     * @typedef {{color: (ol.Color|string|undefined)}}
     * @todo api
     */
    olx.style.FillOptions;

    /**
     * Color.
     * @type {ol.Color|string|undefined}
     */
    olx.style.FillOptions.prototype.color;

    /**
     * @typedef {{anchor: (Array.<number>|undefined),
     *     anchorOrigin: (ol.style.IconOrigin|undefined),
     *     anchorXUnits: (ol.style.IconAnchorUnits|undefined),
     *     anchorYUnits: (ol.style.IconAnchorUnits|undefined),
     *     crossOrigin: (null|string|undefined),
     *     img: (Image|undefined),
     *     offset: (Array.<number>|undefined),
     *     offsetOrigin: (ol.style.IconOrigin|undefined),
     *     scale: (number|undefined),
     *     snapToPixel: (boolean|undefined),
     *     rotateWithView: (boolean|undefined),
     *     rotation: (number|undefined),
     *     size: (ol.Size|undefined),
     *     src: (string|undefined)}}
     * @todo api
     */
    olx.style.IconOptions;

    /**
     * Anchor. Default value is `[0.5, 0.5]` (icon center).
     * @type {Array.<number>|undefined}
     */
    olx.style.IconOptions.prototype.anchor;

    /**
     * Origin of the anchor: `bottom-left`, `bottom-right`, `top-left` or
     * `top-right`. Default is `top-left`.
     * @type {ol.style.IconOrigin|undefined}
     */
    olx.style.IconOptions.prototype.anchorOrigin;

    /**
     * Units in which the anchor x value is specified. A value of `'fraction'`
     * indicates the x value is a fraction of the icon. A value of `'pixels'`
     * indicates the x value in pixels. Default is `'fraction'`.
     * @type {ol.style.IconAnchorUnits|undefined}
     */
    olx.style.IconOptions.prototype.anchorXUnits;

    /**
     * Units in which the anchor y value is specified. A value of `'fraction'`
     * indicates the y value is a fraction of the icon. A value of `'pixels'`
     * indicates the y value in pixels. Default is `'fraction'`.
     * @type {ol.style.IconAnchorUnits|undefined}
     */
    olx.style.IconOptions.prototype.anchorYUnits;

    /**
     * crossOrigin setting for image.
     * @type {null|string|undefined}
     */
    olx.style.IconOptions.prototype.crossOrigin;

    /**
     * Image object for the icon. If the `src` option is not provided then the
     * provided image must already be loaded.
     * @type {Image|undefined}
     */
    olx.style.IconOptions.prototype.img;

    /**
     * Offset, which, together with the size and the offset origin,
     * define the sub-rectangle to use from the original icon image. Default value
     * is `[0, 0]`.
     * @type {Array.<number>|undefined}
     */
    olx.style.IconOptions.prototype.offset;

    /**
     * Origin of the offset: `bottom-left`, `bottom-right`, `top-left` or
     * `top-right`. Default is `top-left`.
     * @type {ol.style.IconOrigin|undefined}
     */
    olx.style.IconOptions.prototype.offsetOrigin;

    /**
     * Scale.
     * @type {number|undefined}
     */
    olx.style.IconOptions.prototype.scale;

    /**
     * If `true` integral numbers of pixels are used as the X and Y pixel
     * coordinate when drawing the icon in the output canvas. If `false`
     * fractional numbers may be used. Using `true` allows for "sharp"
     * rendering (no blur), while using `false` allows for "accurate"
     * rendering. Note that accuracy is important if the icon's position
     * is animated. Without it, the icon may jitter noticeably. Default
     * value is `true`.
     * @type {boolean|undefined}
     */
    olx.style.IconOptions.prototype.snapToPixel;

    /**
     * Whether to rotate the icon with the view. Default is `false`.
     * @type {boolean|undefined}
     */
    olx.style.IconOptions.prototype.rotateWithView;

    /**
     * Rotation.
     * @type {number|undefined}
     */
    olx.style.IconOptions.prototype.rotation;

    /**
     * Icon size in pixel.
     * @type {ol.Size|undefined}
     */
    olx.style.IconOptions.prototype.size;

    /**
     * Image source URI.
     * @type {string}
     */
    olx.style.IconOptions.prototype.src;

    /**
     * @typedef {{color: (ol.Color|string|undefined),
     *     lineCap: (string|undefined),
     *     lineJoin: (string|undefined),
     *     lineDash: (Array.<number>|undefined),
     *     miterLimit: (number|undefined),
     *     width: (number|undefined)}}
     * @todo api
     */
    olx.style.StrokeOptions;

    /**
     * Color.
     * @type {ol.Color|string|undefined}
     */
    olx.style.StrokeOptions.prototype.color;

    /**
     * Line cap style: `butt`, `round`, or `square`. Default is `round`.
     * @type {string|undefined}
     */
    olx.style.StrokeOptions.prototype.lineCap;

    /**
     * Line join style: `bevel`, `round`, or `miter`. Default is `round`.
     * @type {string|undefined}
     */
    olx.style.StrokeOptions.prototype.lineJoin;

    /**
     * Line dash pattern. Default is `undefined` (no dash).
     * @type {Array.<number>|undefined}
     */
    olx.style.StrokeOptions.prototype.lineDash;

    /**
     * Miter limit. Default is `10`.
     * @type {number|undefined}
     */
    olx.style.StrokeOptions.prototype.miterLimit;

    /**
     * Width.
     * @type {number|undefined}
     */
    olx.style.StrokeOptions.prototype.width;

    /**
     * @typedef {{font: (string|undefined),
     *     offsetX: (number|undefined),
     *     offsetY: (number|undefined),
     *     scale: (number|undefined),
     *     rotation: (number|undefined),
     *     text: (string|undefined),
     *     textAlign: (string|undefined),
     *     textBaseline: (string|undefined),
     *     fill: (ol.style.Fill|undefined),
     *     stroke: (ol.style.Stroke|undefined)}}
     * @todo api
     */
    olx.style.TextOptions;

    /**
     * Font.
     * @type {string|undefined}
     */
    olx.style.TextOptions.prototype.font;

    /**
     * Horizontal text offset in pixels. A positive will shift the text right.
     * Default is `0`.
     * @type {number|undefined}
     */
    olx.style.TextOptions.prototype.offsetX;

    /**
     * Vertical text offset in pixels. A positive will shift the text down. Default
     * is `0`.
     * @type {number|undefined}
     */
    olx.style.TextOptions.prototype.offsetY;

    /**
     * Scale.
     * @type {number|undefined}
     */
    olx.style.TextOptions.prototype.scale;

    /**
     * Rotation.
     * @type {number|undefined}
     */
    olx.style.TextOptions.prototype.rotation;

    /**
     * Text.
     * @type {string|undefined}
     */
    olx.style.TextOptions.prototype.text;

    /**
     * Text alignment.
     * @type {string|undefined}
     */
    olx.style.TextOptions.prototype.textAlign;

    /**
     * Text base line.
     * @type {string|undefined}
     */
    olx.style.TextOptions.prototype.textBaseline;

    /**
     * Fill style.
     * @type {ol.style.Fill|undefined}
     */
    olx.style.TextOptions.prototype.fill;

    /**
     * Stroke style.
     * @type {ol.style.Stroke|undefined}
     */
    olx.style.TextOptions.prototype.stroke;

    /**
     * @typedef {{fill: (ol.style.Fill|undefined),
     *     image: (ol.style.Image|undefined),
     *     stroke: (ol.style.Stroke|undefined),
     *     text: (ol.style.Text|undefined),
     *     zIndex: (number|undefined)}}
     * @todo api
     */
    olx.style.StyleOptions;

    /**
     * Fill style.
     * @type {ol.style.Fill|undefined}
     */
    olx.style.StyleOptions.prototype.fill;

    /**
     * Image style.
     * @type {ol.style.Image|undefined}
     */
    olx.style.StyleOptions.prototype.image;

    /**
     * Stroke style.
     * @type {ol.style.Stroke|undefined}
     */
    olx.style.StyleOptions.prototype.stroke;

    /**
     * Text style.
     * @type {ol.style.Text|undefined}
     */
    olx.style.StyleOptions.prototype.text;

    /**
     * Z index.
     * @type {number|undefined}
     */
    olx.style.StyleOptions.prototype.zIndex;

    /**
     * @typedef {{minZoom: (number|undefined),
     *     origin: (ol.Coordinate|undefined),
     *     origins: (Array.<ol.Coordinate>|undefined),
     *     resolutions: !Array.<number>,
     *     tileSize: (number|undefined),
     *     tileSizes: (Array.<number>|undefined)}}
     * @todo api
     */
    olx.tilegrid.TileGridOptions;

    /**
     * Minimum zoom.
     * @type {number|undefined}
     */
    olx.tilegrid.TileGridOptions.prototype.minZoom;

    /**
     * Origin.
     * @type {ol.Coordinate|undefined}
     */
    olx.tilegrid.TileGridOptions.prototype.origin;

    /**
     * Origins.
     * @type {Array.<ol.Coordinate>|undefined}
     */
    olx.tilegrid.TileGridOptions.prototype.origins;

    /**
     * Resolutions.
     * @type {!Array.<number>}
     */
    olx.tilegrid.TileGridOptions.prototype.resolutions;

    /**
     * Tile size.
     * @type {number|undefined}
     */
    olx.tilegrid.TileGridOptions.prototype.tileSize;

    /**
     * Tile sizes.
     * @type {Array.<number>|undefined}
     */
    olx.tilegrid.TileGridOptions.prototype.tileSizes;

    /**
     * @typedef {{origin: (ol.Coordinate|undefined),
     *     origins: (Array.<ol.Coordinate>|undefined),
     *     resolutions: !Array.<number>,
     *     matrixIds: !Array.<string>,
     *     tileSize: (number|undefined),
     *     tileSizes: (Array.<number>|undefined)}}
     * @todo api
     */
    olx.tilegrid.WMTSOptions;

    /**
     * Origin.
     * @type {ol.Coordinate|undefined}
     */
    olx.tilegrid.WMTSOptions.prototype.origin;

    /**
     * Origins.
     * @type {Array.<ol.Coordinate>|undefined}
     */
    olx.tilegrid.WMTSOptions.prototype.origins;

    /**
     * Resolutions.
     * @type {!Array.<number>}
     */
    olx.tilegrid.WMTSOptions.prototype.resolutions;

    /**
     * matrix IDs.
     * @type {!Array.<string>}
     */
    olx.tilegrid.WMTSOptions.prototype.matrixIds;

    /**
     * Tile size.
     * @type {number|undefined}
     */
    olx.tilegrid.WMTSOptions.prototype.tileSize;

    /**
     * Tile sizes.
     * @type {Array.<number>|undefined}
     */
    olx.tilegrid.WMTSOptions.prototype.tileSizes;

    /**
     * @typedef {{maxZoom: number}}
     * @todo api
     */
    olx.tilegrid.XYZOptions;

    /**
     * Maximum zoom.
     * @type {number}
     */
    olx.tilegrid.XYZOptions.prototype.maxZoom;

    /**
     * @typedef {{resolutions: !Array.<number>}}
     * @todo api
     */
    olx.tilegrid.ZoomifyOptions;

    /**
     * Resolutions.
     * @type {!Array.<number>}
     */
    olx.tilegrid.ZoomifyOptions.prototype.resolutions;

    /**
     * @typedef {{padding: !Array.<number>,
     *     constrainResolution: (boolean|undefined),
     *     nearest: (boolean|undefined),
     *     minResolution: (number|undefined)}}
     * @todo api
     */
    olx.View2D.fitGeometryOptions;

    /**
     * Padding (in pixels) to be cleared inside the view. Values in the array are
     * top, right, bottom and left padding. Default is `[0, 0, 0, 0]`.
     * @type {!Array.<number>}
     */
    olx.View2D.fitGeometryOptions.prototype.padding;

    /**
     * Constrain the resolution. Default is `true`.
     * @type {boolean|undefined}
     */
    olx.View2D.fitGeometryOptions.prototype.constrainResolution;

    /**
     * Get the nearest extent. Default is `false`.
     * @type {boolean|undefined}
     */
    olx.View2D.fitGeometryOptions.prototype.nearest;

    /**
     * Minimum resolution that we zoom to. Default is `0`.
     * @type {number|undefined}
     */
    olx.View2D.fitGeometryOptions.prototype.minResolution;

    /* typedefs for object literals exposed by the library */

    /**
     * @typedef {{animate: boolean,
     *     attributions: Object.<string, ol.Attribution>,
     *     coordinateToPixelMatrix: goog.vec.Mat4.Number,
     *     extent: (null|ol.Extent),
     *     focus: ol.Coordinate,
     *     index: number,
     *     layerStates: Object.<number, ol.layer.LayerState>,
     *     layerStatesArray: Array.<ol.layer.LayerState>,
     *     logos: Object.<string, string>,
     *     pixelRatio: number,
     *     pixelToCoordinateMatrix: goog.vec.Mat4.Number,
     *     postRenderFunctions: Array.<ol.PostRenderFunction>,
     *     size: ol.Size,
     *     skippedFeatureUids_: Object.<string, boolean>,
     *     tileQueue: ol.TileQueue,
     *     time: number,
     *     usedTiles: Object.<string, Object.<string, ol.TileRange>>,
     *     view2DState: olx.View2DState,
     *     viewHints: Array.<number>,
     *     wantedTiles: Object.<string, Object.<string, boolean>>}}
     * @todo api
     */
    olx.FrameState;

    /** @type {number} */
    olx.FrameState.prototype.pixelRatio;

    /** @type {number} */
    olx.FrameState.prototype.time;

    /** @type {olx.View2DState} */
    olx.FrameState.prototype.view2DState;

    /**
     * @typedef {{center: ol.Coordinate,
     *     projection: ol.proj.Projection,
     *     resolution: number,
     *     rotation: number}}
     * @todo api
     */
    olx.View2DState;

    /** @type {ol.Coordinate} */
    olx.View2DState.prototype.center;

    /** @type {number} */
    olx.View2DState.prototype.resolution;

    /** @type {number} */
    olx.View2DState.prototype.rotation;