From 633d626edbb517d9fd8fd80c2c4a45f2331eec95 Mon Sep 17 00:00:00 2001 From: AlexeyTokmakov Date: Fri, 7 Dec 2018 15:04:14 +0300 Subject: [PATCH] Update index.d.ts --- types/yandex-maps/index.d.ts | 4112 +++++++++++++++++----------------- 1 file changed, 2056 insertions(+), 2056 deletions(-) diff --git a/types/yandex-maps/index.d.ts b/types/yandex-maps/index.d.ts index 1986a5238c..e7078b4b28 100644 --- a/types/yandex-maps/index.d.ts +++ b/types/yandex-maps/index.d.ts @@ -5,3053 +5,3053 @@ // TypeScript Version: 2.4 declare namespace ymaps { - interface IClassConstructor { - new (): T; - } + interface IClassConstructor { + new(): T; + } - type ControlSingleKey = "fullscreenControl" | "geolocationControl" | "routeEditor" | "rulerControl" | "searchControl" | "trafficControl" | "typeSelector" | "zoomControl"; - type ControlSetKey = "smallMapDefaultSet" | "mediumMapDefaultSet" | "largeMapDefaultSet" | "default"; - type ControlKey = ControlSingleKey | ControlSetKey; + type ControlSingleKey = "fullscreenControl" | "geolocationControl" | "routeEditor" | "rulerControl" | "searchControl" | "trafficControl" | "typeSelector" | "zoomControl"; + type ControlSetKey = "smallMapDefaultSet" | "mediumMapDefaultSet" | "largeMapDefaultSet" | "default"; + type ControlKey = ControlSingleKey | ControlSetKey; - type OverlayKey = - "default#placemark" | "default#pin" | "default#circle" | "default#rectangle" | "default#polyline" | "default#polygon" | - "hotspot#placemark" | "hotspot#circle" | "hotspot#rectangle" | "hotspot#polyline" | "hotspot#polygon" | "html#balloon" | "html#hint" | - "html#placemark" | "html#rectangle" | - string | IClassConstructor | ((geometry: IPixelLineStringGeometry, - data: IDataManager | object, - options: object) => Promise>); - type InteractivityModelKey = "default#opaque" | "default#geoObject" | "default#layer" | "default#transparent" | "default#silent" | string; + type OverlayKey = + "default#placemark" | "default#pin" | "default#circle" | "default#rectangle" | "default#polyline" | "default#polygon" | + "hotspot#placemark" | "hotspot#circle" | "hotspot#rectangle" | "hotspot#polyline" | "hotspot#polygon" | "html#balloon" | "html#hint" | + "html#placemark" | "html#rectangle" | + string | IClassConstructor | ((geometry: IPixelLineStringGeometry, + data: IDataManager | object, + options: object) => Promise>); + type InteractivityModelKey = "default#opaque" | "default#geoObject" | "default#layer" | "default#transparent" | "default#silent" | string; - type PresetKey = string; //option.presetStorage - //[number, number] - //[[number, number], [number, number]] + type PresetKey = string; //option.presetStorage + //[number, number] + //[[number, number], [number, number]] - namespace behavior { - class DblClickZoom implements IBehavior { - constructor(options?: IDblClickZoomOptions); + namespace behavior { + class DblClickZoom implements IBehavior { + constructor(options?: IDblClickZoomOptions); - events: IEventManager; - options: IOptionManager; + events: IEventManager; + options: IOptionManager; - disable(): void; + disable(): void; - enable(): void; + enable(): void; - isEnabled(): boolean; + isEnabled(): boolean; - getParent(): IControlParent | null; + getParent(): IControlParent | null; - setParent(parent: IControlParent): this; - } + setParent(parent: IControlParent): this; + } - interface IDblClickZoomOptions extends IMapMarginOptions { - centering?: boolean; - duration?: number; - } + interface IDblClickZoomOptions extends IMapMarginOptions { + centering?: boolean; + duration?: number; + } - class Drag implements IBehavior { - constructor(options?: IDragOptions) + class Drag implements IBehavior { + constructor(options?: IDragOptions) - events: IEventManager; - options: IOptionManager; + events: IEventManager; + options: IOptionManager; - disable(): void; + disable(): void; - enable(): void; + enable(): void; - isEnabled(): boolean; + isEnabled(): boolean; - getParent(): null | IControlParent; + getParent(): null | IControlParent; - setParent(parent: IControlParent): this; - } + setParent(parent: IControlParent): this; + } - interface IDragOptions { - actionCursor?: string; - cursor?: string; - inertia?: boolean; - inertiaDuration?: number; - tremor?: number; - } + interface IDragOptions { + actionCursor?: string; + cursor?: string; + inertia?: boolean; + inertiaDuration?: number; + tremor?: number; + } - class LeftMouseButtonMagnifier implements IBehavior { - constructor(options?: ILeftMouseButtonMagnifierOptions) + class LeftMouseButtonMagnifier implements IBehavior { + constructor(options?: ILeftMouseButtonMagnifierOptions) - events: IEventManager; - options: IOptionManager; + events: IEventManager; + options: IOptionManager; - disable(): void; + disable(): void; - enable(): void; + enable(): void; - isEnabled(): boolean; + isEnabled(): boolean; - getParent(): null | IControlParent; + getParent(): null | IControlParent; - setParent(parent: IControlParent): this; - } + setParent(parent: IControlParent): this; + } - interface ILeftMouseButtonMagnifierOptions { - actionCursor?: string; - cursor?: string; - duration?: number; - } + interface ILeftMouseButtonMagnifierOptions { + actionCursor?: string; + cursor?: string; + duration?: number; + } - class MultiTouch implements IBehavior { - constructor(options?: IMultiTouchOptions) + class MultiTouch implements IBehavior { + constructor(options?: IMultiTouchOptions) - events: IEventManager; - options: IOptionManager; + events: IEventManager; + options: IOptionManager; - disable(): void; + disable(): void; - enable(): void; + enable(): void; - isEnabled(): boolean; + isEnabled(): boolean; - getParent(): null | IControlParent; + getParent(): null | IControlParent; - setParent(parent: IControlParent): this; - } + setParent(parent: IControlParent): this; + } - interface IMultiTouchOptions { - tremor?: number; - } + interface IMultiTouchOptions { + tremor?: number; + } - class RightMouseButtonMagnifier implements IBehavior { - constructor(options?: IRightMouseButtonMagnifierOptions) + class RightMouseButtonMagnifier implements IBehavior { + constructor(options?: IRightMouseButtonMagnifierOptions) - events: IEventManager; - options: IOptionManager; + events: IEventManager; + options: IOptionManager; - disable(): void; + disable(): void; - enable(): void; + enable(): void; - isEnabled(): boolean; + isEnabled(): boolean; - getParent(): null | IControlParent; + getParent(): null | IControlParent; - setParent(parent: IControlParent): this; - } + setParent(parent: IControlParent): this; + } - interface IRightMouseButtonMagnifierOptions { - actionCursor?: string; - duration?: number; - } + interface IRightMouseButtonMagnifierOptions { + actionCursor?: string; + duration?: number; + } - class RouteEditor implements IBehavior { - events: IEventManager; - options: IOptionManager; + class RouteEditor implements IBehavior { + events: IEventManager; + options: IOptionManager; - disable(): void; + disable(): void; - enable(): void; + enable(): void; - isEnabled(): boolean; + isEnabled(): boolean; - getParent(): null | IControlParent; + getParent(): null | IControlParent; - setParent(parent: IControlParent): this; + setParent(parent: IControlParent): this; - getRoute(): router.Route; + getRoute(): router.Route; - getState(): string; + getState(): string; - setState(state: string | null): void; - } + setState(state: string | null): void; + } - class Ruler implements IBehavior { - constructor(options?: IRulerOptions) + class Ruler implements IBehavior { + constructor(options?: IRulerOptions) - events: IEventManager; - options: IOptionManager; + events: IEventManager; + options: IOptionManager; - disable(): void; + disable(): void; - enable(): void; + enable(): void; - isEnabled(): boolean; + isEnabled(): boolean; - getParent(): null | IControlParent; + getParent(): null | IControlParent; - setParent(parent: IControlParent): this; + setParent(parent: IControlParent): this; - close(): boolean; + close(): boolean; - getState(): string; + getState(): string; - setState(state: string | null): void; - } + setState(state: string | null): void; + } - interface IRulerOptions { - balloonAutoPan?: boolean; - } + interface IRulerOptions { + balloonAutoPan?: boolean; + } - class ScrollZoom implements IBehavior { - constructor(options?: IScrollZoomOptions) + class ScrollZoom implements IBehavior { + constructor(options?: IScrollZoomOptions) - events: IEventManager; - options: IOptionManager; + events: IEventManager; + options: IOptionManager; - disable(): void; + disable(): void; - enable(): void; + enable(): void; - isEnabled(): boolean; + isEnabled(): boolean; - getParent(): null | IControlParent; + getParent(): null | IControlParent; - setParent(parent: IControlParent): this; - } + setParent(parent: IControlParent): this; + } - interface IScrollZoomOptions { - maximumDelta?: number; - speed?: number; - } + interface IScrollZoomOptions { + maximumDelta?: number; + speed?: number; + } - const storage: util.Storage; - } + const storage: util.Storage; + } - namespace clusterer { - class Balloon implements IBalloonManager { //tslint:disable-line no-shadowed-variable - constructor(clusterer: Clusterer); + namespace clusterer { + class Balloon implements IBalloonManager { //tslint:disable-line no-shadowed-variable + constructor(clusterer: Clusterer); - events: IEventManager; + events: IEventManager; - autoPan(): Promise; + autoPan(): Promise; - close(force?: boolean): Promise; + close(force?: boolean): Promise; - destroy(): void; + destroy(): void; - getData(): object | null; + getData(): object | null; - getOptions(): IOptionManager | null; + getOptions(): IOptionManager | null; - getOverlay(): Promise; + getOverlay(): Promise; - getOverlaySync(): IOverlay | null; + getOverlaySync(): IOverlay | null; - getPosition(): number[] | null; + getPosition(): number[] | null; - isOpen(): boolean; + isOpen(): boolean; - open(position?: number[], data?: object | string | HTMLElement, options?: object): Promise; + open(position?: number[], data?: object | string | HTMLElement, options?: object): Promise; - setData(data: object | string | HTMLElement): Promise; + setData(data: object | string | HTMLElement): Promise; - setOptions(options: object): Promise; + setOptions(options: object): Promise; - setPosition(position: number[]): Promise; - } + setPosition(position: number[]): Promise; + } - class Hint implements IHintManager { - constructor(clusterer: Clusterer); + class Hint implements IHintManager { + constructor(clusterer: Clusterer); - events: IEventManager; + events: IEventManager; - close(force?: boolean): Promise; + close(force?: boolean): Promise; - destroy(): void; + destroy(): void; - getData(): object | null; + getData(): object | null; - getOptions(): IOptionManager | null; + getOptions(): IOptionManager | null; - getOverlay(): Promise; + getOverlay(): Promise; - getOverlaySync(): IOverlay | null; + getOverlaySync(): IOverlay | null; - getPosition(): number[] | null; + getPosition(): number[] | null; - isOpen(): boolean; + isOpen(): boolean; - open(position?: number[], data?: object | string | HTMLElement, options?: object): Promise; + open(position?: number[], data?: object | string | HTMLElement, options?: object): Promise; - setData(data: object | string | HTMLElement): Promise; + setData(data: object | string | HTMLElement): Promise; - setOptions(options: object): Promise; + setOptions(options: object): Promise; - setPosition(position: number[]): Promise; - } - } + setPosition(position: number[]): Promise; + } + } - namespace collection { - class Item implements IChildOnMap, ICustomizable, IEventEmitter, IParentOnMap { - constructor(options?: object); + namespace collection { + class Item implements IChildOnMap, ICustomizable, IEventEmitter, IParentOnMap { + constructor(options?: object); - events: IEventManager; - options: IOptionManager; + events: IEventManager; + options: IOptionManager; - getParent(): null | IControlParent; + getParent(): null | IControlParent; - setParent(parent: IControlParent): this; + setParent(parent: IControlParent): this; - getMap(): Map; + getMap(): Map; - onAddToMap(map: Map): void; + onAddToMap(map: Map): void; - onRemoveFromMap(oldMap: Map): void; - } - } + onRemoveFromMap(oldMap: Map): void; + } + } - namespace control { - class Button implements ICustomizable, ISelectableControl { - constructor(parameters?: IButtonParameters | string); + namespace control { + class Button implements ICustomizable, ISelectableControl { + constructor(parameters?: IButtonParameters | string); - options: IOptionManager; - events: IEventManager; - data: data.Manager; - state: data.Manager; + options: IOptionManager; + events: IEventManager; + data: data.Manager; + state: data.Manager; - deselect(): void; + deselect(): void; - disable(): void; + disable(): void; - enable(): void; + enable(): void; - isEnabled(): boolean; + isEnabled(): boolean; - isSelected(): boolean; + isSelected(): boolean; - select(): void; + select(): void; - getParent(): null | IControlParent; + getParent(): null | IControlParent; - setParent(parent: IControlParent): this; - } + setParent(parent: IControlParent): this; + } - interface IBaseButtonParametersOptions { - adjustMapMargin?: boolean; - float?: "none" | "left" | "right"; - floatIndex?: number; - layout?: IClassConstructor | string; - maxWidth?: number[][] | number[] | number; - position?: { - bottom?: number | string; - left?: number | string; - right?: number | string; - top?: number | string; - }; - visible?: boolean; - } + interface IBaseButtonParametersOptions { + adjustMapMargin?: boolean; + float?: "none" | "left" | "right"; + floatIndex?: number; + layout?: IClassConstructor | string; + maxWidth?: number[][] | number[] | number; + position?: { + bottom?: number | string; + left?: number | string; + right?: number | string; + top?: number | string; + }; + visible?: boolean; + } - interface IButtonParameters { - data?: { - content?: string; - image?: string; - title?: string; - }; - options?: IBaseButtonParametersOptions & { - selectOnClick?: boolean; - size?: "auto" | "small" | "medium" | "large"; - }; - state?: { - enabled?: boolean; - selected?: boolean; - }; - } + interface IButtonParameters { + data?: { + content?: string; + image?: string; + title?: string; + }; + options?: IBaseButtonParametersOptions & { + selectOnClick?: boolean; + size?: "auto" | "small" | "medium" | "large"; + }; + state?: { + enabled?: boolean; + selected?: boolean; + }; + } - class FullscreenControl extends Button { - constructor(parameters?: IFullscreenControlParameters); + class FullscreenControl extends Button { + constructor(parameters?: IFullscreenControlParameters); - enterFullscreen(): void; + enterFullscreen(): void; - exitFullscreen(): void; - } + exitFullscreen(): void; + } - interface IFullscreenControlParameters { - data?: { - title?: string; - }; - options?: IBaseButtonParametersOptions & { - collapseOnBlur?: boolean; - expandOnClick?: boolean; - popupFloat?: "left" | "right"; - }; - state?: { - expanded?: boolean; - }; - } + interface IFullscreenControlParameters { + data?: { + title?: string; + }; + options?: IBaseButtonParametersOptions & { + collapseOnBlur?: boolean; + expandOnClick?: boolean; + popupFloat?: "left" | "right"; + }; + state?: { + expanded?: boolean; + }; + } - class GeolocationControl extends Button { - constructor(parameters?: IGeolocationControlParameters); - } + class GeolocationControl extends Button { + constructor(parameters?: IGeolocationControlParameters); + } - interface IGeolocationControlParameters extends IButtonParameters { - data?: { - image?: string; - title?: string; - }; - options?: IBaseButtonParametersOptions; - } + interface IGeolocationControlParameters extends IButtonParameters { + data?: { + image?: string; + title?: string; + }; + options?: IBaseButtonParametersOptions; + } - class ListBox implements ICollection, IControl, ICustomizable { - constructor(parameters?: IListBoxParameters); + class ListBox implements ICollection, IControl, ICustomizable { + constructor(parameters?: IListBoxParameters); - events: IEventManager; - options: IOptionManager; - data: data.Manager; - state: data.Manager; + events: IEventManager; + options: IOptionManager; + data: data.Manager; + state: data.Manager; - add(object: object): this; + add(object: object): this; - getIterator(): IIterator; + getIterator(): IIterator; - remove(object: object): this; + remove(object: object): this; - getParent(): null | IControlParent; + getParent(): null | IControlParent; - setParent(parent: IControlParent): this; - } + setParent(parent: IControlParent): this; + } - interface IListBoxParameters extends IButtonParameters { - options?: IBaseButtonParametersOptions & { - noPlacemark?: boolean; - }; - } - - class ListBoxItem implements ICustomizable, ISelectableControl { - constructor(parameters?: IListBoxItemParameters); - - options: IOptionManager; - events: IEventManager; - data: data.Manager; - state: data.Manager; - - deselect(): void; - - disable(): void; - - enable(): void; - - isEnabled(): boolean; - - isSelected(): boolean; - - select(): void; - - getParent(): null | IControlParent; - - setParent(parent: IControlParent): this; - - getMap(): Map; - } - - interface IListBoxItemParameters { - data?: { - content?: string; - }; - options?: { - layout?: string | IClassConstructor; - selectableLayout?: string | IClassConstructor; - selectOnClick?: boolean; - separatorLayout?: string | IClassConstructor; - type?: "selectable" | "separator"; - visible?: boolean; - }; - state?: { - selected?: boolean; - }; - } - - class Manager { - constructor(map: Map, controls?: Array, options?: IManagerOptions); - - events: event.Manager; - options: option.Manager; - state: data.Manager; - - add(control: IControl | ControlKey, options?: IManagerControlOptions): this; - - each(callback: (control: IControl) => void, context: object): this; - - get(index: number | string): IControl | null; - - getChildElement(control: IControl): Promise; - - getContainer(): HTMLElement; - - getMap(): Map; - - indexOf(childToFind: IControl | string): number; - - remove(control: IControl | string): this; - } - - interface IManagerOptions { - margin?: number; - pane?: IPane; - states?: string[]; - } + interface IListBoxParameters extends IButtonParameters { + options?: IBaseButtonParametersOptions & { + noPlacemark?: boolean; + }; + } + + class ListBoxItem implements ICustomizable, ISelectableControl { + constructor(parameters?: IListBoxItemParameters); + + options: IOptionManager; + events: IEventManager; + data: data.Manager; + state: data.Manager; + + deselect(): void; + + disable(): void; + + enable(): void; + + isEnabled(): boolean; + + isSelected(): boolean; + + select(): void; + + getParent(): null | IControlParent; + + setParent(parent: IControlParent): this; + + getMap(): Map; + } + + interface IListBoxItemParameters { + data?: { + content?: string; + }; + options?: { + layout?: string | IClassConstructor; + selectableLayout?: string | IClassConstructor; + selectOnClick?: boolean; + separatorLayout?: string | IClassConstructor; + type?: "selectable" | "separator"; + visible?: boolean; + }; + state?: { + selected?: boolean; + }; + } + + class Manager { + constructor(map: Map, controls?: Array, options?: IManagerOptions); + + events: event.Manager; + options: option.Manager; + state: data.Manager; + + add(control: IControl | ControlKey, options?: IManagerControlOptions): this; + + each(callback: (control: IControl) => void, context: object): this; + + get(index: number | string): IControl | null; + + getChildElement(control: IControl): Promise; + + getContainer(): HTMLElement; + + getMap(): Map; + + indexOf(childToFind: IControl | string): number; + + remove(control: IControl | string): this; + } + + interface IManagerOptions { + margin?: number; + pane?: IPane; + states?: string[]; + } - interface IManagerControlOptions { - float?: "none" | "left" | "right"; - floatIndex?: number; - position?: { - bottom?: number | string; - left?: number | string; - right?: number | string; - top?: number | string; - }; - } + interface IManagerControlOptions { + float?: "none" | "left" | "right"; + floatIndex?: number; + position?: { + bottom?: number | string; + left?: number | string; + right?: number | string; + top?: number | string; + }; + } - class RouteButton implements IControl, ICustomizable { - constructor(parameters?: IRouteButtonParameters); + class RouteButton implements IControl, ICustomizable { + constructor(parameters?: IRouteButtonParameters); - events: IEventManager; - options: IOptionManager; - routePanel: IRoutePanel; + events: IEventManager; + options: IOptionManager; + routePanel: IRoutePanel; - getParent(): null | IControlParent; + getParent(): null | IControlParent; - setParent(parent: IControlParent): this; - } + setParent(parent: IControlParent): this; + } - interface IRouteButtonParameters { - options?: { - adjustMapMargin?: boolean; - collapseOnBlur?: boolean; - float?: "none" | "left" | "right"; - floatIndex?: number; - popupAnimate?: boolean; - popupFloat?: "auto" | "left" | "right"; - popupWidth?: string; - position?: { - bottom?: number | string; - left?: number | string; - right?: number | string; - top?: number | string; - }; - size?: "auto" | "small" | "medium" | "large"; - visible?: boolean; - }; - state?: { - expanded?: boolean; - }; - } - - class RouteEditor extends Button { - constructor(parameters?: IRouteEditorParameters); - - getRoute(): router.Route; - } - - interface IRouteEditorParameters { - data?: { - image?: string; - title?: string; - }; - options?: IBaseButtonParametersOptions; - state?: {}; - } - - class RulerControl extends Button { - constructor(parameters?: IRulerControlParameters); - } - - interface IRulerControlParameters { - data?: {}; - options?: { - adjustMapMargin?: boolean; - position?: { - bottom?: number | string; - left?: number | string; - right?: number | string; - top?: number | string; - }; - scaleLine?: boolean; - visible?: boolean; - }; - state?: {}; - } - - class SearchControl implements IControl, ICustomizable { - constructor(parameters?: ISearchControlParameters); - - events: IEventManager; - options: IOptionManager; - state: data.Manager; - - getParent(): null | IControlParent; - - setParent(parent: IControlParent): this; - - clear(): void; - - getMap(): Map; - - getRequestString(): string; - - getResponseMetaData(): object; - - getResult(index: number): Promise; - - getResultsArray(): object[]; - - getResultsCount(): number; + interface IRouteButtonParameters { + options?: { + adjustMapMargin?: boolean; + collapseOnBlur?: boolean; + float?: "none" | "left" | "right"; + floatIndex?: number; + popupAnimate?: boolean; + popupFloat?: "auto" | "left" | "right"; + popupWidth?: string; + position?: { + bottom?: number | string; + left?: number | string; + right?: number | string; + top?: number | string; + }; + size?: "auto" | "small" | "medium" | "large"; + visible?: boolean; + }; + state?: { + expanded?: boolean; + }; + } + + class RouteEditor extends Button { + constructor(parameters?: IRouteEditorParameters); + + getRoute(): router.Route; + } + + interface IRouteEditorParameters { + data?: { + image?: string; + title?: string; + }; + options?: IBaseButtonParametersOptions; + state?: {}; + } + + class RulerControl extends Button { + constructor(parameters?: IRulerControlParameters); + } + + interface IRulerControlParameters { + data?: {}; + options?: { + adjustMapMargin?: boolean; + position?: { + bottom?: number | string; + left?: number | string; + right?: number | string; + top?: number | string; + }; + scaleLine?: boolean; + visible?: boolean; + }; + state?: {}; + } + + class SearchControl implements IControl, ICustomizable { + constructor(parameters?: ISearchControlParameters); + + events: IEventManager; + options: IOptionManager; + state: data.Manager; + + getParent(): null | IControlParent; + + setParent(parent: IControlParent): this; + + clear(): void; + + getMap(): Map; + + getRequestString(): string; + + getResponseMetaData(): object; + + getResult(index: number): Promise; + + getResultsArray(): object[]; + + getResultsCount(): number; - getSelectedIndex(): number; + getSelectedIndex(): number; - hideResult(): void; + hideResult(): void; - search(request: string): Promise; + search(request: string): Promise; - showResult(index: number): this; - } + showResult(index: number): this; + } - interface ISearchControlParameters { - data?: {}; - options?: { - adjustMapMargin?: boolean; - boundedBy?: number[][]; - fitMaxWidth?: boolean; - float?: "none" | "left" | "right"; - floatIndex?: number; - formLayout?: string | IClassConstructor; - kind?: "house" | "street" | "metro" | "district" | "locality"; - layout?: string | IClassConstructor; - maxWidth?: number[][] | number[] | number; - noCentering?: boolean; - noPlacemark?: boolean; - noPopup?: boolean; - noSelect?: boolean; - noSuggestPanel?: boolean; - placeholderContent?: string; - popupItemLayout?: string | IClassConstructor; - popupLayout?: string | IClassConstructor; - position?: { - bottom?: number | string; - left?: number | string; - right?: number | string; - top?: number | string; - }; - provider?: IGeocodeProvider | "yandex#map" | "yandex#search"; - searchCoordOrder?: "latlong" | "longlat"; - size?: "auto" | "small" | "medium" | "large"; - strictBounds?: boolean; - suppressYandexSearch?: boolean; - useMapBounds?: boolean; - zoomMargin?: number; - visible?: boolean; - }; - state?: {}; - } - } + interface ISearchControlParameters { + data?: {}; + options?: { + adjustMapMargin?: boolean; + boundedBy?: number[][]; + fitMaxWidth?: boolean; + float?: "none" | "left" | "right"; + floatIndex?: number; + formLayout?: string | IClassConstructor; + kind?: "house" | "street" | "metro" | "district" | "locality"; + layout?: string | IClassConstructor; + maxWidth?: number[][] | number[] | number; + noCentering?: boolean; + noPlacemark?: boolean; + noPopup?: boolean; + noSelect?: boolean; + noSuggestPanel?: boolean; + placeholderContent?: string; + popupItemLayout?: string | IClassConstructor; + popupLayout?: string | IClassConstructor; + position?: { + bottom?: number | string; + left?: number | string; + right?: number | string; + top?: number | string; + }; + provider?: IGeocodeProvider | "yandex#map" | "yandex#search"; + searchCoordOrder?: "latlong" | "longlat"; + size?: "auto" | "small" | "medium" | "large"; + strictBounds?: boolean; + suppressYandexSearch?: boolean; + useMapBounds?: boolean; + zoomMargin?: number; + visible?: boolean; + }; + state?: {}; + } + } - namespace data { - class Manager implements IDataManager, IFreezable { - constructor(data?: object); + namespace data { + class Manager implements IDataManager, IFreezable { + constructor(data?: object); - events: IEventManager; + events: IEventManager; - get(path: string, defaultValue: object): object; + get(path: string, defaultValue: object): object; - getAll(): object; + getAll(): object; - set(path: object | string, value: object): this; + set(path: object | string, value: object): this; - setAll(): this; + setAll(): this; - unset(path: object | string): this; + unset(path: object | string): this; - unsetAll(): this; + unsetAll(): this; - freeze(): IFreezable; + freeze(): IFreezable; - isFrozen(): boolean; + isFrozen(): boolean; - unfreeze(): IFreezable; + unfreeze(): IFreezable; - add(types: string[][] | string[] | string, callback: (event: (object | IEvent)) => void, context?: object, priority?: number): this; + add(types: string[][] | string[] | string, callback: (event: (object | IEvent)) => void, context?: object, priority?: number): this; - getParent(): IEventManager | null; + getParent(): IEventManager | null; - group(): IEventGroup; + group(): IEventGroup; - remove(types: string[][] | string[] | string, callback: (event: (object | IEvent)) => void, context?: object, priority?: number): this; + remove(types: string[][] | string[] | string, callback: (event: (object | IEvent)) => void, context?: object, priority?: number): this; - setParent(parent: IEventManager | null): this; + setParent(parent: IEventManager | null): this; - fire(type: string, eventobject: object | IEvent): this; - } - } + fire(type: string, eventobject: object | IEvent): this; + } + } - namespace event { - class Manager implements IEventManager { - constructor(params?: { context?: object; controllers?: IEventWorkflowController[]; parent?: IEventManager }); + namespace event { + class Manager implements IEventManager { + constructor(params?: { context?: object; controllers?: IEventWorkflowController[]; parent?: IEventManager }); - add(types: string[][] | string[] | string, callback: (event: (object | IEvent)) => void, context?: object, priority?: number): this; + add(types: string[][] | string[] | string, callback: (event: (object | IEvent)) => void, context?: object, priority?: number): this; - getParent(): IEventManager | null; + getParent(): IEventManager | null; - group(): IEventGroup; + group(): IEventGroup; - remove(types: string[][] | string[] | string, callback: (event: (object | IEvent)) => void, context?: object, priority?: number): this; + remove(types: string[][] | string[] | string, callback: (event: (object | IEvent)) => void, context?: object, priority?: number): this; - setParent(parent: IEventManager | null): this; + setParent(parent: IEventManager | null): this; - fire(type: string, eventobject: object | IEvent): this; + fire(type: string, eventobject: object | IEvent): this; - createEventobject(type: string, event: object, target: object): Event; + createEventobject(type: string, event: object, target: object): Event; - once(types: string[][] | string[] | string, callback: (event: IEvent) => any, context?: object, priority?: number): this; - } - } + once(types: string[][] | string[] | string, callback: (event: IEvent) => any, context?: object, priority?: number): this; + } + } - namespace geometry { - namespace base { - class LineString implements IBaseLineStringGeometry { //tslint:disable-line no-shadowed-variable - static fromEncodedCoordinates(encodedCoordinates: string): geometry.LineString; //tslint:disable-line function-name + namespace geometry { + namespace base { + class LineString implements IBaseLineStringGeometry { //tslint:disable-line no-shadowed-variable + static fromEncodedCoordinates(encodedCoordinates: string): geometry.LineString; //tslint:disable-line function-name - static toEncodedCoordinates(geometry: geometry.LineString): string; //tslint:disable-line function-name + static toEncodedCoordinates(geometry: geometry.LineString): string; //tslint:disable-line function-name - events: IEventManager; + events: IEventManager; - getBounds(): number[][] | null; + getBounds(): number[][] | null; - getType(): string; + getType(): string; - get(index: number): number[]; + get(index: number): number[]; - getChildGeometry(index: number): IPointGeometryAccess; + getChildGeometry(index: number): IPointGeometryAccess; - getClosest(anchorPosition: number[]): object; + getClosest(anchorPosition: number[]): object; - getCoordinates(): number[][]; + getCoordinates(): number[][]; - getLength(): number; + getLength(): number; - insert(index: number, coordinates: number[][]): ILineStringGeometryAccess; + insert(index: number, coordinates: number[][]): ILineStringGeometryAccess; - remove(index: number): number[]; + remove(index: number): number[]; - remove(types: string[][] | string[] | string, callback: (event: (object | IEvent)) => void, context?: object, priority?: number): this; + remove(types: string[][] | string[] | string, callback: (event: (object | IEvent)) => void, context?: object, priority?: number): this; - set(index: number, coordinates: number[]): ILineStringGeometryAccess; + set(index: number, coordinates: number[]): ILineStringGeometryAccess; - setCoordinates(coordinates: number[]): ILineStringGeometryAccess; + setCoordinates(coordinates: number[]): ILineStringGeometryAccess; - splice(index: number, length: number): number[][]; + splice(index: number, length: number): number[][]; - freeze(): IFreezable; + freeze(): IFreezable; - isFrozen(): boolean; + isFrozen(): boolean; - unfreeze(): IFreezable; + unfreeze(): IFreezable; - add(types: string[][] | string[] | string, callback: (event: (object | IEvent)) => void, context?: object, priority?: number): this; + add(types: string[][] | string[] | string, callback: (event: (object | IEvent)) => void, context?: object, priority?: number): this; - getParent(): object | null; + getParent(): object | null; - group(): IEventGroup; + group(): IEventGroup; - setParent(parent: IEventManager | null): this; + setParent(parent: IEventManager | null): this; - fire(type: string, eventobject: object | IEvent): this; - } + fire(type: string, eventobject: object | IEvent): this; + } - class Point implements IBasePointGeometry { //tslint:disable-line no-shadowed-variable - events: IEventManager; + class Point implements IBasePointGeometry { //tslint:disable-line no-shadowed-variable + events: IEventManager; - getBounds(): number[][] | null; + getBounds(): number[][] | null; - getType(): string; + getType(): string; - getCoordinates(): number[] | null; + getCoordinates(): number[] | null; - setCoordinates(coordinates: number[] | null): this; - } - } + setCoordinates(coordinates: number[] | null): this; + } + } - class LineString implements ILineStringGeometry { - constructor(coordinates?: number[][], options?: { - coordRendering?: "shortestPath" | "straightPath"; - geodesic?: boolean; - pixelRendering?: "jumpy" | "static"; - projection?: IProjection; - simplification?: boolean; - }); + class LineString implements ILineStringGeometry { + constructor(coordinates?: number[][], options?: { + coordRendering?: "shortestPath" | "straightPath"; + geodesic?: boolean; + pixelRendering?: "jumpy" | "static"; + projection?: IProjection; + simplification?: boolean; + }); - static fromEncodedCoordinates(encodedCoordinates: string): LineString; //tslint:disable-line function-name + static fromEncodedCoordinates(encodedCoordinates: string): LineString; //tslint:disable-line function-name - static toEncodedCoordinates(geometry: LineString): string; //tslint:disable-line function-name + static toEncodedCoordinates(geometry: LineString): string; //tslint:disable-line function-name - events: IEventManager; - options: IOptionManager; + events: IEventManager; + options: IOptionManager; - getMap(): Map | null; + getMap(): Map | null; - getPixelGeometry(options?: object): IPixelGeometry; + getPixelGeometry(options?: object): IPixelGeometry; - setMap(map: Map): void; + setMap(map: Map): void; - getBounds(): number[][] | null; + getBounds(): number[][] | null; - getType(): string; + getType(): string; - get(index: number): number[]; + get(index: number): number[]; - getChildGeometry(index: number): IPointGeometryAccess; + getChildGeometry(index: number): IPointGeometryAccess; - getClosest(anchorPosition: number[]): object; + getClosest(anchorPosition: number[]): object; - getCoordinates(): number[][]; + getCoordinates(): number[][]; - getLength(): number; + getLength(): number; - insert(index: number, coordinates: number[][]): ILineStringGeometryAccess; + insert(index: number, coordinates: number[][]): ILineStringGeometryAccess; - remove(index: number): number[]; + remove(index: number): number[]; - remove(types: string[][] | string[] | string, callback: (event: (object | IEvent)) => void, context?: object, priority?: number): this; + remove(types: string[][] | string[] | string, callback: (event: (object | IEvent)) => void, context?: object, priority?: number): this; - set(index: number, coordinates: number[]): ILineStringGeometryAccess; + set(index: number, coordinates: number[]): ILineStringGeometryAccess; - setCoordinates(coordinates: number[]): ILineStringGeometryAccess; + setCoordinates(coordinates: number[]): ILineStringGeometryAccess; - splice(index: number, length: number): number[][]; + splice(index: number, length: number): number[][]; - freeze(): IFreezable; + freeze(): IFreezable; - isFrozen(): boolean; + isFrozen(): boolean; - unfreeze(): IFreezable; + unfreeze(): IFreezable; - add(types: string[][] | string[] | string, callback: (event: (object | IEvent)) => void, context?: object, priority?: number): this; + add(types: string[][] | string[] | string, callback: (event: (object | IEvent)) => void, context?: object, priority?: number): this; - getParent(): object | null; + getParent(): object | null; - group(): IEventGroup; + group(): IEventGroup; - setParent(parent: IEventManager | null): this; + setParent(parent: IEventManager | null): this; - fire(type: string, eventobject: object | IEvent): this; - } + fire(type: string, eventobject: object | IEvent): this; + } - class Point implements IPointGeometry { - constructor(coordinates?: number[] | null); + class Point implements IPointGeometry { + constructor(coordinates?: number[] | null); - options: IOptionManager; - events: IEventManager; + options: IOptionManager; + events: IEventManager; - getMap(): Map | null; + getMap(): Map | null; - getPixelGeometry(options?: object): IPixelGeometry; + getPixelGeometry(options?: object): IPixelGeometry; - setMap(map: Map): void; + setMap(map: Map): void; - getBounds(): number[][] | null; + getBounds(): number[][] | null; - getType(): string; + getType(): string; - getCoordinates(): number[] | null; + getCoordinates(): number[] | null; - setCoordinates(coordinates: number[] | null): this; - } - } + setCoordinates(coordinates: number[] | null): this; + } + } - namespace geoObject { - class Balloon implements IBalloonManager { //tslint:disable-line no-shadowed-variable - constructor(geoObject: GeoObject); + namespace geoObject { + class Balloon implements IBalloonManager { //tslint:disable-line no-shadowed-variable + constructor(geoObject: GeoObject); - events: IEventManager; + events: IEventManager; - autoPan(): Promise; + autoPan(): Promise; - close(force?: boolean): Promise; + close(force?: boolean): Promise; - destroy(): void; + destroy(): void; - getData(): object | null; + getData(): object | null; - getOptions(): IOptionManager | null; + getOptions(): IOptionManager | null; - getOverlay(): Promise; + getOverlay(): Promise; - getOverlaySync(): IOverlay | null; + getOverlaySync(): IOverlay | null; - getPosition(): number[] | null; + getPosition(): number[] | null; - isOpen(): boolean; + isOpen(): boolean; - open(position?: number[], data?: object | string | HTMLElement, options?: object): Promise; + open(position?: number[], data?: object | string | HTMLElement, options?: object): Promise; - setData(data: object | string | HTMLElement): Promise; + setData(data: object | string | HTMLElement): Promise; - setOptions(options: object): Promise; + setOptions(options: object): Promise; - setPosition(position: number[]): Promise; - } + setPosition(position: number[]): Promise; + } - class Hint implements IHintManager { - constructor(geoObject: GeoObject); + class Hint implements IHintManager { + constructor(geoObject: GeoObject); - events: IEventManager; + events: IEventManager; - close(force?: boolean): Promise; + close(force?: boolean): Promise; - destroy(): void; + destroy(): void; - getData(): object | null; + getData(): object | null; - getOptions(): IOptionManager | null; + getOptions(): IOptionManager | null; - getOverlay(): Promise; + getOverlay(): Promise; - getOverlaySync(): IOverlay | null; + getOverlaySync(): IOverlay | null; - getPosition(): number[] | null; + getPosition(): number[] | null; - isOpen(): boolean; + isOpen(): boolean; - open(position?: number[], data?: object | string | HTMLElement, options?: object): Promise; + open(position?: number[], data?: object | string | HTMLElement, options?: object): Promise; - setData(data: object | string | HTMLElement): Promise; + setData(data: object | string | HTMLElement): Promise; - setOptions(options: object): Promise; + setOptions(options: object): Promise; - setPosition(position: number[]): Promise; - } + setPosition(position: number[]): Promise; + } - class Sequence implements IGeoObject, IGeoObjectSequence { - constructor(geoObject: GeoObject); + class Sequence implements IGeoObject, IGeoObjectSequence { + constructor(geoObject: GeoObject); - geometry: IGeometry | null; - properties: IDataManager; - state: IDataManager; - events: IEventManager; - options: IOptionManager; + geometry: IGeometry | null; + properties: IDataManager; + state: IDataManager; + events: IEventManager; + options: IOptionManager; - getOverlay(): Promise; + getOverlay(): Promise; - getOverlaySync(): IOverlay | null; + getOverlaySync(): IOverlay | null; - getParent(): null | IControlParent; + getParent(): null | IControlParent; - setParent(parent: IControlParent): this; + setParent(parent: IControlParent): this; - getMap(): Map; + getMap(): Map; - each(callback: (geoObject: IGeoObject) => void, context?: object): void; + each(callback: (geoObject: IGeoObject) => void, context?: object): void; - get(index: number): IGeoObject; + get(index: number): IGeoObject; - getBounds(): number[][] | null; + getBounds(): number[][] | null; - getIterator(): IIterator; + getIterator(): IIterator; - getLength(): number; + getLength(): number; - getPixelBounds(): number[][] | null; + getPixelBounds(): number[][] | null; - indexOf(geoObject: IGeoObject): number; - } - } + indexOf(geoObject: IGeoObject): number; + } + } - namespace layout { - namespace templateBased { - class Base implements ILayout { - constructor(data: object); + namespace layout { + namespace templateBased { + class Base implements ILayout { + constructor(data: object); - events: IEventManager; + events: IEventManager; - destroy(): void; + destroy(): void; - getData(): object; + getData(): object; - getParentElement(): HTMLElement; + getParentElement(): HTMLElement; - getShape(): IShape | null; + getShape(): IShape | null; - isEmpty(): boolean; + isEmpty(): boolean; - setData(data: object): void; + setData(data: object): void; - setParentElement(parent: HTMLElement | null): this; + setParentElement(parent: HTMLElement | null): this; - build(): void; + build(): void; - clear(): void; + clear(): void; - onSublayoutSizeChange(sublayoutInfo: object, nodeSizeByContent: object): void; + onSublayoutSizeChange(sublayoutInfo: object, nodeSizeByContent: object): void; - rebuild(): void; - } - } - } + rebuild(): void; + } + } + } - namespace map { - namespace action { - class Manager implements IEventEmitter { - constructor(map: Map); + namespace map { + namespace action { + class Manager implements IEventEmitter { + constructor(map: Map); - events: IEventManager; + events: IEventManager; - breakTick(): void; + breakTick(): void; - execute(action: IMapAction): void; + execute(action: IMapAction): void; - getCurrentState(): object; + getCurrentState(): object; - getMap(): Map; + getMap(): Map; - setCorrection(userFunction: () => void): void; + setCorrection(userFunction: () => void): void; - stop(): void; - } - } + stop(): void; + } + } - namespace behavior { // tslint:disable-line no-shadowed-variable - class Manager implements ICustomizable, IEventEmitter, IParentOnMap { - constructor(map: Map, behaviors?: string[][] | string[], options?: object); + namespace behavior { // tslint:disable-line no-shadowed-variable + class Manager implements ICustomizable, IEventEmitter, IParentOnMap { + constructor(map: Map, behaviors?: string[][] | string[], options?: object); - options: IOptionManager; - events: IEventManager; + options: IOptionManager; + events: IEventManager; - getMap(): Map; + getMap(): Map; - disable(behaviors: string[][] | string[] | string): this; + disable(behaviors: string[][] | string[] | string): this; - enable(behaviors: string[][] | string[] | string): this; + enable(behaviors: string[][] | string[] | string): this; - get(behaviorName: string): IBehavior; + get(behaviorName: string): IBehavior; - isEnabled(behaviorName: string): boolean; - } - } + isEnabled(behaviorName: string): boolean; + } + } - namespace layer { - class Manager implements ILayer, IMapObjectCollection { - constructor(map: Map, options?: { - trafficImageZIndex?: number; - trafficInfoZIndex?: number; - trafficJamZIndex?: number; - }); + namespace layer { + class Manager implements ILayer, IMapObjectCollection { + constructor(map: Map, options?: { + trafficImageZIndex?: number; + trafficInfoZIndex?: number; + trafficJamZIndex?: number; + }); - events: IEventManager; - options: IOptionManager; + events: IEventManager; + options: IOptionManager; - getParent(): null | IControlParent; + getParent(): null | IControlParent; - setParent(parent: IControlParent): this; + setParent(parent: IControlParent): this; - add(object: object): this; + add(object: object): this; - getIterator(): IIterator; + getIterator(): IIterator; - remove(object: object): this; + remove(object: object): this; - getMap(): Map; - } - } + getMap(): Map; + } + } - namespace margin { - class Accessor { - constructor(screenArea: object); + namespace margin { + class Accessor { + constructor(screenArea: object); - getArea(): object; + getArea(): object; - remove(): this; + remove(): this; - setArea(screenArea: object): this; - } + setArea(screenArea: object): this; + } - class Manager { - constructor(map: Map); + class Manager { + constructor(map: Map); - addArea(screenArea: object): Accessor; + addArea(screenArea: object): Accessor; - destroy(): this; + destroy(): this; - getMargin(): number[]; + getMargin(): number[]; - getOffset(): number[]; + getOffset(): number[]; - setDefaultMargin(margin: number[][] | number[] | number): void; - } - } + setDefaultMargin(margin: number[][] | number[] | number): void; + } + } - namespace pane { - class Manager { - constructor(map: Map); + namespace pane { + class Manager { + constructor(map: Map); - append(key: string, pane: IPane): void; + append(key: string, pane: IPane): void; - destroy(): void; + destroy(): void; - get(key: string): IPane | null; + get(key: string): IPane | null; - getLower(): string; + getLower(): string; - getUpper(): string; + getUpper(): string; - insertBefore(key: string, pane: IPane, referenceKey: string): void; + insertBefore(key: string, pane: IPane, referenceKey: string): void; - remove(pane: IPane): void; - } - } + remove(pane: IPane): void; + } + } - class Balloon implements IBalloonManager/*, IBalloonSharingManager*/ { //tslint:disable-line no-shadowed-variable - constructor(map: Map); + class Balloon implements IBalloonManager/*, IBalloonSharingManager*/ { //tslint:disable-line no-shadowed-variable + constructor(map: Map); - events: IEventManager; + events: IEventManager; - autoPan(): Promise; + autoPan(): Promise; - close(force?: boolean): Promise; + close(force?: boolean): Promise; - destroy(): void; + destroy(): void; - getData(): object | null; + getData(): object | null; - getOptions(): IOptionManager | null; + getOptions(): IOptionManager | null; - getOverlay(): Promise; + getOverlay(): Promise; - getOverlaySync(): IOverlay | null; + getOverlaySync(): IOverlay | null; - getPosition(): number[] | null; + getPosition(): number[] | null; - isOpen(): boolean; + isOpen(): boolean; - open(position?: number[], data?: object | string | HTMLElement, options?: object): Promise; + open(position?: number[], data?: object | string | HTMLElement, options?: object): Promise; - setData(data: object | string | HTMLElement): Promise; + setData(data: object | string | HTMLElement): Promise; - setOptions(options: object): Promise; + setOptions(options: object): Promise; - setPosition(position: number[]): Promise; - } + setPosition(position: number[]): Promise; + } - class Container implements IDomEventEmitter { - constructor(parentElement: string | HTMLElement); + class Container implements IDomEventEmitter { + constructor(parentElement: string | HTMLElement); - events: IEventManager; + events: IEventManager; - enterFullscreen(): void; + enterFullscreen(): void; - exitFullscreen(): void; + exitFullscreen(): void; - fitToViewport(preservePixelPosition?: boolean): void; + fitToViewport(preservePixelPosition?: boolean): void; - getElement(): HTMLElement; + getElement(): HTMLElement; - getOffset(): number[]; + getOffset(): number[]; - getParentElement(): HTMLElement; + getParentElement(): HTMLElement; - getSize(): number[]; + getSize(): number[]; - isFullscreen(): boolean; - } + isFullscreen(): boolean; + } - class Converter { - constructor(map: Map); + class Converter { + constructor(map: Map); - globalToPage(globalPixelPoint: number[]): number[]; + globalToPage(globalPixelPoint: number[]): number[]; - pageToGlobal(pagePixelPoint: number[]): number[]; - } + pageToGlobal(pagePixelPoint: number[]): number[]; + } - class Copyrights { - constructor(map: Map); + class Copyrights { + constructor(map: Map); - add(customCopyrights: string | HTMLElement | Array): ICopyrightsAccessor; + add(customCopyrights: string | HTMLElement | Array): ICopyrightsAccessor; - addProvider(provider: ICopyrightsProvider): this; + addProvider(provider: ICopyrightsProvider): this; - get(point?: number[], zoom?: number): Promise>; + get(point?: number[], zoom?: number): Promise>; - getPromoLink(): string; + getPromoLink(): string; - removeProvider(provider: ICopyrightsProvider): this; - } + removeProvider(provider: ICopyrightsProvider): this; + } - class GeoObjects implements IGeoObjectCollection { - constructor(map: Map, options?: object); + class GeoObjects implements IGeoObjectCollection { + constructor(map: Map, options?: object); - options: IOptionManager; - events: IEventManager; + options: IOptionManager; + events: IEventManager; - add(child: IGeoObject, index?: number): this; + add(child: IGeoObject, index?: number): this; - each(callback: (object: IGeoObject) => void, context: object): void; + each(callback: (object: IGeoObject) => void, context: object): void; - get(index: number): IGeoObject; + get(index: number): IGeoObject; - getBounds(): number[][] | null; + getBounds(): number[][] | null; - getIterator(): IIterator; + getIterator(): IIterator; - getLength(): number; + getLength(): number; - getPixelBounds(): number[][] | null; + getPixelBounds(): number[][] | null; - indexOf(object: IGeoObject): number; + indexOf(object: IGeoObject): number; - remove(child: IGeoObject): this; + remove(child: IGeoObject): this; - removeAll(): this; + removeAll(): this; - set(index: number, child: IGeoObject): this; + set(index: number, child: IGeoObject): this; - splice(index: number, length: number): this; + splice(index: number, length: number): this; - getMap(): Map; - } + getMap(): Map; + } - class Hint implements IHintManager/*, IHintSharingManager*/ { - constructor(map: Map); + class Hint implements IHintManager/*, IHintSharingManager*/ { + constructor(map: Map); - events: IEventManager; + events: IEventManager; - close(force?: boolean): Promise; + close(force?: boolean): Promise; - destroy(): void; + destroy(): void; - getData(): object | null; + getData(): object | null; - getOptions(): IOptionManager | null; + getOptions(): IOptionManager | null; - getOverlay(): Promise; + getOverlay(): Promise; - getOverlaySync(): IOverlay | null; + getOverlaySync(): IOverlay | null; - getPosition(): number[] | null; + getPosition(): number[] | null; - isOpen(): boolean; + isOpen(): boolean; - open(position?: number[], data?: object | string | HTMLElement, options?: object): Promise; + open(position?: number[], data?: object | string | HTMLElement, options?: object): Promise; - setData(data: object | string | HTMLElement): Promise; + setData(data: object | string | HTMLElement): Promise; - setOptions(options: object): Promise; + setOptions(options: object): Promise; - setPosition(position: number[]): Promise; - } + setPosition(position: number[]): Promise; + } - class ZoomRange implements IEventEmitter { - constructor(map: Map, constraints: number[]); + class ZoomRange implements IEventEmitter { + constructor(map: Map, constraints: number[]); - events: IEventManager; + events: IEventManager; - get(coords?: number[]): Promise; + get(coords?: number[]): Promise; - getCurrent(): number[]; - } - } + getCurrent(): number[]; + } + } - namespace multiRouter { - namespace driving { - class Path implements IGeoObject { - geometry: IGeometry | null; - properties: data.Manager; - state: IDataManager; - model: PathModel; - events: IEventManager; - options: IOptionManager; + namespace multiRouter { + namespace driving { + class Path implements IGeoObject { + geometry: IGeometry | null; + properties: data.Manager; + state: IDataManager; + model: PathModel; + events: IEventManager; + options: IOptionManager; - getOverlay(): Promise; + getOverlay(): Promise; - getOverlaySync(): IOverlay | null; + getOverlaySync(): IOverlay | null; - getParent(): object | null; + getParent(): object | null; - setParent(parent: object): this; + setParent(parent: object): this; - getMap(): Map; + getMap(): Map; - getSegments(): GeoObjectCollection; - } + getSegments(): GeoObjectCollection; + } - class PathModel implements IEventEmitter { - events: IEventManager; - properties: data.Manager; - route: RouteModel; + class PathModel implements IEventEmitter { + events: IEventManager; + properties: data.Manager; + route: RouteModel; - destroy(): void; + destroy(): void; - getSegments(): SegmentModel[]; + getSegments(): SegmentModel[]; - getType(): string; + getType(): string; - update(pathJson: object): void; - } + update(pathJson: object): void; + } - class Route implements IGeoObject { - geometry: IGeometry | null; - properties: IDataManager; - state: IDataManager; - events: IEventManager; - options: IOptionManager; + class Route implements IGeoObject { + geometry: IGeometry | null; + properties: IDataManager; + state: IDataManager; + events: IEventManager; + options: IOptionManager; - getOverlay(): Promise; + getOverlay(): Promise; - getOverlaySync(): IOverlay | null; + getOverlaySync(): IOverlay | null; - getParent(): object | null; + getParent(): object | null; - setParent(parent: object): this; + setParent(parent: object): this; - getMap(): Map; + getMap(): Map; - getPaths(): GeoObjectCollection; - } + getPaths(): GeoObjectCollection; + } - class RouteModel implements IEventEmitter { - events: IEventManager; - multiRoute: MultiRouteModel; - properties: data.Manager; + class RouteModel implements IEventEmitter { + events: IEventManager; + multiRoute: MultiRouteModel; + properties: data.Manager; - destroy(): void; + destroy(): void; - getPaths(): PathModel[]; + getPaths(): PathModel[]; - update(routeJson: object): void; + update(routeJson: object): void; - getType(): string; - } + getType(): string; + } - class Segment implements IGeoObject { - geometry: IGeometry | null; - properties: data.Manager; - state: IDataManager; - events: IEventManager; - options: IOptionManager; + class Segment implements IGeoObject { + geometry: IGeometry | null; + properties: data.Manager; + state: IDataManager; + events: IEventManager; + options: IOptionManager; - getOverlay(): Promise; + getOverlay(): Promise; - getOverlaySync(): IOverlay | null; + getOverlaySync(): IOverlay | null; - getParent(): object | null; + getParent(): object | null; - setParent(parent: object): this; + setParent(parent: object): this; - getMap(): Map; - } + getMap(): Map; + } - class SegmentModel implements IEventEmitter { - events: IEventManager; - geometry: geometry.base.LineString; - path: PathModel; + class SegmentModel implements IEventEmitter { + events: IEventManager; + geometry: geometry.base.LineString; + path: PathModel; - destroy(): void; + destroy(): void; - getType(): string; + getType(): string; - getViaPoints(): ViaPointModel[]; + getViaPoints(): ViaPointModel[]; - update(segmentJson: object): void; - } - } + update(segmentJson: object): void; + } + } - namespace masstransit { - class Path implements IGeoObject { - geometry: IGeometry | null; - properties: data.Manager; - state: IDataManager; - events: IEventManager; - options: IOptionManager; - model: PathModel; + namespace masstransit { + class Path implements IGeoObject { + geometry: IGeometry | null; + properties: data.Manager; + state: IDataManager; + events: IEventManager; + options: IOptionManager; + model: PathModel; - getOverlay(): Promise; + getOverlay(): Promise; - getOverlaySync(): IOverlay | null; + getOverlaySync(): IOverlay | null; - getParent(): object | null; + getParent(): object | null; - setParent(parent: object): this; + setParent(parent: object): this; - getMap(): Map; + getMap(): Map; - getSegmentMarkers(): GeoObjectCollection; + getSegmentMarkers(): GeoObjectCollection; - getSegments(): GeoObjectCollection; - } + getSegments(): GeoObjectCollection; + } - class PathModel implements IEventEmitter { - events: IEventManager; - properties: data.Manager; - route: RouteModel; + class PathModel implements IEventEmitter { + events: IEventManager; + properties: data.Manager; + route: RouteModel; - destroy(): void; + destroy(): void; - getSegments(): Array; + getSegments(): Array; - getType(): string; + getType(): string; - update(pathJson: object): void; - } + update(pathJson: object): void; + } - class Route implements IGeoObject { - geometry: IGeometry | null; - properties: data.Manager; - model: RouteModel; - state: IDataManager; - events: IEventManager; - options: IOptionManager; + class Route implements IGeoObject { + geometry: IGeometry | null; + properties: data.Manager; + model: RouteModel; + state: IDataManager; + events: IEventManager; + options: IOptionManager; - getOverlay(): Promise; + getOverlay(): Promise; - getOverlaySync(): IOverlay | null; + getOverlaySync(): IOverlay | null; - getParent(): object | null; + getParent(): object | null; - setParent(parent: object): this; + setParent(parent: object): this; - getMap(): Map; + getMap(): Map; - getPaths(): GeoObjectCollection; - } + getPaths(): GeoObjectCollection; + } - class RouteModel implements IEventEmitter { - events: IEventManager; - multiRoute: MultiRouteModel; - properties: data.Manager; + class RouteModel implements IEventEmitter { + events: IEventManager; + multiRoute: MultiRouteModel; + properties: data.Manager; - destroy(): void; + destroy(): void; - getPaths(): PathModel[]; + getPaths(): PathModel[]; - getType(): string; + getType(): string; - update(routeJson: object): void; - } + update(routeJson: object): void; + } - class StopModel implements IEventEmitter { - events: IEventManager; - geometry: geometry.base.Point; - properties: data.Manager; - segment: TransportSegmentModel; + class StopModel implements IEventEmitter { + events: IEventManager; + geometry: geometry.base.Point; + properties: data.Manager; + segment: TransportSegmentModel; - update(stopJson: object): void; - } + update(stopJson: object): void; + } - class TransferSegment implements IGeoObject { - geometry: IGeometry | null; - properties: data.Manager; - state: IDataManager; - events: IEventManager; - options: IOptionManager; - model: TransferSegmentModel; + class TransferSegment implements IGeoObject { + geometry: IGeometry | null; + properties: data.Manager; + state: IDataManager; + events: IEventManager; + options: IOptionManager; + model: TransferSegmentModel; - getOverlay(): Promise; + getOverlay(): Promise; - getOverlaySync(): IOverlay | null; + getOverlaySync(): IOverlay | null; - getParent(): object | null; + getParent(): object | null; - setParent(parent: object): this; + setParent(parent: object): this; - getMap(): Map; - } + getMap(): Map; + } - class TransferSegmentModel implements IEventEmitter { - events: IEventManager; - geometry: geometry.base.LineString; - path: PathModel; - properties: data.Manager; + class TransferSegmentModel implements IEventEmitter { + events: IEventManager; + geometry: geometry.base.LineString; + path: PathModel; + properties: data.Manager; - destroy(segmentJson: object): void; + destroy(segmentJson: object): void; - getType(): string; - } + getType(): string; + } - class TransportSegment implements IGeoObject { - geometry: IGeometry | null; - properties: data.Manager; - state: IDataManager; - events: IEventManager; - options: IOptionManager; - model: TransportSegmentModel; + class TransportSegment implements IGeoObject { + geometry: IGeometry | null; + properties: data.Manager; + state: IDataManager; + events: IEventManager; + options: IOptionManager; + model: TransportSegmentModel; - getOverlay(): Promise; + getOverlay(): Promise; - getOverlaySync(): IOverlay | null; + getOverlaySync(): IOverlay | null; - getParent(): object | null; + getParent(): object | null; - setParent(parent: object): this; + setParent(parent: object): this; - getMap(): Map; - } + getMap(): Map; + } - class TransportSegmentModel implements IEventEmitter { - events: IEventManager; - geometry: geometry.base.LineString; - path: PathModel; - properties: data.Manager; + class TransportSegmentModel implements IEventEmitter { + events: IEventManager; + geometry: geometry.base.LineString; + path: PathModel; + properties: data.Manager; - destroy(): void; + destroy(): void; - getStops(): StopModel[]; + getStops(): StopModel[]; - getType(): string; + getType(): string; - update(segmentJson: object): void; - } + update(segmentJson: object): void; + } - class WalkSegment implements IGeoObject { - geometry: IGeometry | null; - properties: data.Manager; - state: IDataManager; - events: IEventManager; - options: IOptionManager; - model: WalkSegmentModel; + class WalkSegment implements IGeoObject { + geometry: IGeometry | null; + properties: data.Manager; + state: IDataManager; + events: IEventManager; + options: IOptionManager; + model: WalkSegmentModel; - getOverlay(): Promise; + getOverlay(): Promise; - getOverlaySync(): IOverlay | null; + getOverlaySync(): IOverlay | null; - getParent(): object | null; + getParent(): object | null; - setParent(parent: object): this; + setParent(parent: object): this; - getMap(): Map; - } + getMap(): Map; + } - class WalkSegmentModel implements IEventEmitter { - events: IEventManager; - geometry: geometry.base.LineString; - path: PathModel; - properties: data.Manager; + class WalkSegmentModel implements IEventEmitter { + events: IEventManager; + geometry: geometry.base.LineString; + path: PathModel; + properties: data.Manager; - destroy(): void; + destroy(): void; - getType(): string; - } - } + getType(): string; + } + } - class EditorAddon implements ICustomizable, IEventEmitter { - options: IOptionManager; - events: IEventManager; - state: data.Manager; + class EditorAddon implements ICustomizable, IEventEmitter { + options: IOptionManager; + events: IEventManager; + state: data.Manager; - isActive(): boolean; + isActive(): boolean; - start(state: object): void; + start(state: object): void; - stop(): void; - } + stop(): void; + } - class MultiRoute implements IGeoObject { - constructor(model: MultiRouteModel | IMultiRouteModelJson, options?: { - activeRouteAutoSelection?: boolean; - boundsAutoApply?: boolean; - dragUpdateInterval?: string | number; - preventDragUpdate?: boolean; - useMapMargin?: boolean; - zoomMargin?: number[][] | number[] | number; - [index: string]: any; - }); + class MultiRoute implements IGeoObject { + constructor(model: MultiRouteModel | IMultiRouteModelJson, options?: { + activeRouteAutoSelection?: boolean; + boundsAutoApply?: boolean; + dragUpdateInterval?: string | number; + preventDragUpdate?: boolean; + useMapMargin?: boolean; + zoomMargin?: number[][] | number[] | number; + [index: string]: any; + }); - editor: EditorAddon; - model: MultiRouteModel; - geometry: IGeometry | null; - properties: IDataManager; - state: IDataManager; - events: IEventManager; - options: IOptionManager; + editor: EditorAddon; + model: MultiRouteModel; + geometry: IGeometry | null; + properties: IDataManager; + state: IDataManager; + events: IEventManager; + options: IOptionManager; - getOverlay(): Promise; + getOverlay(): Promise; - getOverlaySync(): IOverlay | null; + getOverlaySync(): IOverlay | null; - getParent(): object | null; + getParent(): object | null; - setParent(parent: object): this; + setParent(parent: object): this; - getMap(): Map; + getMap(): Map; - getActiveRoute(): driving.Route | masstransit.Route | null; + getActiveRoute(): driving.Route | masstransit.Route | null; - getBounds(): number[][] | null; + getBounds(): number[][] | null; - getPixelBounds(): number[][] | null; + getPixelBounds(): number[][] | null; - getRoutes(): GeoObjectCollection; + getRoutes(): GeoObjectCollection; - getViaPoints(): GeoObjectCollection; + getViaPoints(): GeoObjectCollection; - getWayPoints(): GeoObjectCollection; + getWayPoints(): GeoObjectCollection; - setActiveRoute(route: driving.Route | masstransit.Route | null): void; - } + setActiveRoute(route: driving.Route | masstransit.Route | null): void; + } - class MultiRouteModel implements IEventEmitter { - constructor(referencePoints: IMultiRouteReferencePoint[], params?: IMultiRouteParams); + class MultiRouteModel implements IEventEmitter { + constructor(referencePoints: IMultiRouteReferencePoint[], params?: IMultiRouteParams); - events: IEventManager; - properties: data.Manager; + events: IEventManager; + properties: data.Manager; - destroy(): void; + destroy(): void; - getAllPoints(): Array; + getAllPoints(): Array; - getJson(): object; + getJson(): object; - getParams(): IMultiRouteParams; + getParams(): IMultiRouteParams; - getPoints(): Array; + getPoints(): Array; - getReferencePointIndexes(): object; + getReferencePointIndexes(): object; - getReferencePoints(): IMultiRouteReferencePoint[]; + getReferencePoints(): IMultiRouteReferencePoint[]; - getRoutes(): driving.RouteModel[] | masstransit.RouteModel[]; + getRoutes(): driving.RouteModel[] | masstransit.RouteModel[]; - getViaPoints(): ViaPointModel[]; + getViaPoints(): ViaPointModel[]; - getWayPoints(): WayPointModel[]; + getWayPoints(): WayPointModel[]; - setParams(params: IMultiRouteParams, extend?: boolean, clearRequests?: boolean): void; + setParams(params: IMultiRouteParams, extend?: boolean, clearRequests?: boolean): void; - setReferencePoints(referencePoints: IMultiRouteReferencePoint[], viaIndexes?: number[], clearRequests?: boolean): void; - } + setReferencePoints(referencePoints: IMultiRouteReferencePoint[], viaIndexes?: number[], clearRequests?: boolean): void; + } - class ViaPoint implements IGeoObject { - geometry: IGeometry | null; - properties: data.Manager; - state: IDataManager; - events: IEventManager; - options: IOptionManager; + class ViaPoint implements IGeoObject { + geometry: IGeometry | null; + properties: data.Manager; + state: IDataManager; + events: IEventManager; + options: IOptionManager; - getOverlay(): Promise; + getOverlay(): Promise; - getOverlaySync(): IOverlay | null; + getOverlaySync(): IOverlay | null; - getParent(): object | null; + getParent(): object | null; - setParent(parent: object): this; + setParent(parent: object): this; - getMap(): Map; - } + getMap(): Map; + } - class ViaPointModel implements IEventEmitter { - events: IEventManager; - geometry: geometry.base.Point; - multiRoute: MultiRouteModel; - properties: data.Manager; + class ViaPointModel implements IEventEmitter { + events: IEventManager; + geometry: geometry.base.Point; + multiRoute: MultiRouteModel; + properties: data.Manager; - destroy(): void; + destroy(): void; - getReferencePoint(): object; + getReferencePoint(): object; - getReferencePointIndex(): number; + getReferencePointIndex(): number; - setReferencePoint(referencePoint: object): void; + setReferencePoint(referencePoint: object): void; - update(viaPointJson: object): void; - } + update(viaPointJson: object): void; + } - class WayPoint implements IGeoObject { - geometry: IGeometry | null; - properties: data.Manager; - state: IDataManager; - events: IEventManager; - options: IOptionManager; - model: WayPointModel; + class WayPoint implements IGeoObject { + geometry: IGeometry | null; + properties: data.Manager; + state: IDataManager; + events: IEventManager; + options: IOptionManager; + model: WayPointModel; - getOverlay(): Promise; + getOverlay(): Promise; - getOverlaySync(): IOverlay | null; + getOverlaySync(): IOverlay | null; - getParent(): object | null; + getParent(): object | null; - setParent(parent: object): this; + setParent(parent: object): this; - getMap(): Map; - } + getMap(): Map; + } - class WayPointModel implements IEventEmitter { - events: IEventManager; - geometry: geometry.base.Point; - multiRoute: MultiRouteModel; - properties: data.Manager; + class WayPointModel implements IEventEmitter { + events: IEventManager; + geometry: geometry.base.Point; + multiRoute: MultiRouteModel; + properties: data.Manager; - destroy(): void; + destroy(): void; - getReferencePoint(): object; + getReferencePoint(): object; - getReferencePointIndex(): number; + getReferencePointIndex(): number; - setReferencePoint(referencePoint: object): void; + setReferencePoint(referencePoint: object): void; - update(wayPointJson: object): void; - } - } + update(wayPointJson: object): void; + } + } - namespace option { - class Manager implements IOptionManager { - constructor(options?: object, parent?: IOptionManager, name?: string); + namespace option { + class Manager implements IOptionManager { + constructor(options?: object, parent?: IOptionManager, name?: string); - events: IEventManager; + events: IEventManager; - get(key: string, defaultValue: object): object; + get(key: string, defaultValue: object): object; - getAll(): object; + getAll(): object; - getName(): string; + getName(): string; - getNative(key: string): object; + getNative(key: string): object; - resolve(key: string, name?: string): object; + resolve(key: string, name?: string): object; - set(key: object | string, value?: object): this; + set(key: object | string, value?: object): this; - unset(keys: string[][] | string[] | string): this; + unset(keys: string[][] | string[] | string): this; - unsetAll(): this; + unsetAll(): this; - setName(name: string): void; + setName(name: string): void; - getParent(): null | IOptionManager; + getParent(): null | IOptionManager; - setParent(parent: IOptionManager): this; + setParent(parent: IOptionManager): this; - freeze(): IFreezable; + freeze(): IFreezable; - isFrozen(): boolean; + isFrozen(): boolean; - unfreeze(): IFreezable; + unfreeze(): IFreezable; - add(types: string[][] | string[] | string, callback: (event: (object | IEvent)) => void, context?: object, priority?: number): this; + add(types: string[][] | string[] | string, callback: (event: (object | IEvent)) => void, context?: object, priority?: number): this; - group(): IEventGroup; + group(): IEventGroup; - remove(types: string[][] | string[] | string, callback: (event: (object | IEvent)) => void, context?: object, priority?: number): this; + remove(types: string[][] | string[] | string, callback: (event: (object | IEvent)) => void, context?: object, priority?: number): this; - fire(type: string, eventobject: object | IEvent): this; - } - } + fire(type: string, eventobject: object | IEvent): this; + } + } - namespace panorama { - class Manager implements IEventEmitter { - events: IEventManager; + namespace panorama { + class Manager implements IEventEmitter { + events: IEventManager; - closePlayer(): void; + closePlayer(): void; - disableLookup(): void; + disableLookup(): void; - enableLookup(): void; + enableLookup(): void; - getPlayer(): Player; + getPlayer(): Player; - isLookupEnabled(): boolean; + isLookupEnabled(): boolean; - openPlayer(panorama: IPanorama[] | number): Promise; - } + openPlayer(panorama: IPanorama[] | number): Promise; + } - class Player implements IEventEmitter { - constructor(element: HTMLElement | string, panorama: IPanorama, options?: { - autoFitToViewport?: "none" | "ifNull" | "always"; - controls?: string[]; - direction?: number[] | string; - hotkeysEnabled?: boolean; - scrollZoomBehavior?: boolean; - span?: number[] | string; - suppressMapOpenBlock?: boolean; - }) + class Player implements IEventEmitter { + constructor(element: HTMLElement | string, panorama: IPanorama, options?: { + autoFitToViewport?: "none" | "ifNull" | "always"; + controls?: string[]; + direction?: number[] | string; + hotkeysEnabled?: boolean; + scrollZoomBehavior?: boolean; + span?: number[] | string; + suppressMapOpenBlock?: boolean; + }) - events: IEventManager; + events: IEventManager; - destroy(): void; + destroy(): void; - fitToViewport(): void; + fitToViewport(): void; - getDirection(): number[]; + getDirection(): number[]; - getPanorama(): IPanorama; + getPanorama(): IPanorama; - getSpan(): number[]; + getSpan(): number[]; - lookAt(point: number[]): this; + lookAt(point: number[]): this; - moveTo(point: number[], options?: { - direction?: number[] | string; - layer?: "yandex#panorama" | "yandex#airPanorama"; - span?: number[] | string; - }): Promise; + moveTo(point: number[], options?: { + direction?: number[] | string; + layer?: "yandex#panorama" | "yandex#airPanorama"; + span?: number[] | string; + }): Promise; - setDirection(direction: number[] | string): this; + setDirection(direction: number[] | string): this; - setPanorama(panorama: IPanorama): this; + setPanorama(panorama: IPanorama): this; - setSpan(span: number[] | string): this; - } - } + setSpan(span: number[] | string): this; + } + } - namespace router { - class Editor implements ICustomizable, IEventEmitter { - options: IOptionManager; - events: IEventManager; + namespace router { + class Editor implements ICustomizable, IEventEmitter { + options: IOptionManager; + events: IEventManager; - start(options?: { - addViaPoints?: boolean; - addWayPoints?: boolean; - editViaPoints?: boolean; - editWayPoints?: boolean; - removeViaPoints?: boolean; - removeWayPoints?: boolean; - }): void; + start(options?: { + addViaPoints?: boolean; + addWayPoints?: boolean; + editViaPoints?: boolean; + editWayPoints?: boolean; + removeViaPoints?: boolean; + removeWayPoints?: boolean; + }): void; - stop(): void; - } + stop(): void; + } - abstract class Route implements IGeoObject { - geometry: IGeometry | null; - properties: IDataManager; - state: IDataManager; - events: IEventManager; - options: IOptionManager; - editor: Editor; + abstract class Route implements IGeoObject { + geometry: IGeometry | null; + properties: IDataManager; + state: IDataManager; + events: IEventManager; + options: IOptionManager; + editor: Editor; - getOverlay(): Promise; + getOverlay(): Promise; - getOverlaySync(): IOverlay | null; + getOverlaySync(): IOverlay | null; - getParent(): null | IControlParent; + getParent(): null | IControlParent; - setParent(parent: IControlParent): this; + setParent(parent: IControlParent): this; - getMap(): Map; + getMap(): Map; - getHumanJamsTime(): string; + getHumanJamsTime(): string; - getHumanLength(): string; + getHumanLength(): string; - getHumanTime(): string; + getHumanTime(): string; - getJamsTime(): number; + getJamsTime(): number; - getLength(): number; + getLength(): number; - getPaths(): GeoObjectCollection; + getPaths(): GeoObjectCollection; - getTime(): number; + getTime(): number; - getViaPoints(): GeoObjectCollection; + getViaPoints(): GeoObjectCollection; - getWayPoints(): GeoObjectCollection; - } - } + getWayPoints(): GeoObjectCollection; + } + } - class Balloon extends Popup implements IBaloon { - constructor(map: Map, options?: IBalloonOptions); + class Balloon extends Popup implements IBaloon { + constructor(map: Map, options?: IBalloonOptions); - getData(): object; + getData(): object; - close(force?: boolean): Promise; + close(force?: boolean): Promise; - getParent(): Balloon | null; + getParent(): Balloon | null; - setParent(parent: Balloon): this; + setParent(parent: Balloon): this; - autoPan(): Promise; + autoPan(): Promise; - freeze(): IFreezable; + freeze(): IFreezable; - isFrozen(): boolean; + isFrozen(): boolean; - unfreeze(): IFreezable; + unfreeze(): IFreezable; - add(types: string[][] | string[] | string, callback: (event: (object | IEvent)) => void, context?: object, priority?: number): this; + add(types: string[][] | string[] | string, callback: (event: (object | IEvent)) => void, context?: object, priority?: number): this; - group(): IEventGroup; + group(): IEventGroup; - remove(types: string[][] | string[] | string, callback: (event: (object | IEvent)) => void, context?: object, priority?: number): this; + remove(types: string[][] | string[] | string, callback: (event: (object | IEvent)) => void, context?: object, priority?: number): this; - fire(type: string, eventobject: object | IEvent): this; - } + fire(type: string, eventobject: object | IEvent): this; + } - interface IBalloonOptions { - autoPan?: boolean; - autoPanCheckZoomRange?: boolean; - autoPanDuration?: number; - autoPanMargin?: number[][] | number[] | number; - autoPanUseMapMargin?: boolean; - closeButton?: boolean; - contentLayout?: IClassConstructor | string; - layout?: IClassConstructor | string; - maxHeight?: number; - maxWidth?: number; - minHeight?: number; - minWidth?: number; - offset?: number[]; - pane?: string; - panelContentLayout?: IClassConstructor | string; - panelMaxHeightRatio?: number; - panelMaxMapArea?: number; - shadow?: boolean; - shadowLayout?: IClassConstructor | string; - shadowOffset?: number[]; - } - - class Circle implements GeoObject { - constructor(geometry: ICircleGeometry[][][][] | number[][] | object, properties?: object | IDataManager, options?: ICircleOptions) - - balloon: geoObject.Balloon; - editor: IGeometryEditor; - hint: geoObject.Hint; - events: event.Manager; - options: option.Manager; - properties: data.Manager; - state: data.Manager; + interface IBalloonOptions { + autoPan?: boolean; + autoPanCheckZoomRange?: boolean; + autoPanDuration?: number; + autoPanMargin?: number[][] | number[] | number; + autoPanUseMapMargin?: boolean; + closeButton?: boolean; + contentLayout?: IClassConstructor | string; + layout?: IClassConstructor | string; + maxHeight?: number; + maxWidth?: number; + minHeight?: number; + minWidth?: number; + offset?: number[]; + pane?: string; + panelContentLayout?: IClassConstructor | string; + panelMaxHeightRatio?: number; + panelMaxMapArea?: number; + shadow?: boolean; + shadowLayout?: IClassConstructor | string; + shadowOffset?: number[]; + } + + class Circle implements GeoObject { + constructor(geometry: ICircleGeometry[][][][] | number[][] | object, properties?: object | IDataManager, options?: ICircleOptions) + + balloon: geoObject.Balloon; + editor: IGeometryEditor; + hint: geoObject.Hint; + events: event.Manager; + options: option.Manager; + properties: data.Manager; + state: data.Manager; - geometry: IGeometry | null; - indices: ArrayBuffer; - vertices: ArrayBuffer; + geometry: IGeometry | null; + indices: ArrayBuffer; + vertices: ArrayBuffer; - getOverlay(): Promise; + getOverlay(): Promise; - getOverlaySync(): IOverlay | null; + getOverlaySync(): IOverlay | null; - getParent(): null | IControlParent; + getParent(): null | IControlParent; - setParent(parent: IControlParent): this; + setParent(parent: IControlParent): this; - getMap(): Map; - } + getMap(): Map; + } - interface ICircleOptions { - circleOverlay?: string | ((geometry: IPixelCircleGeometry, data: object, options: object) => Promise); - cursor?: string; - draggable?: boolean; - fill?: boolean; - fillColor?: string; - fillImageHref?: string; - fillMethod?: "stretch" | "tile"; - fillOpacity?: number; - hasBalloon?: boolean; - hasHint?: boolean; - hideIconOnBalloonOpen?: boolean; - interactiveZIndex?: boolean; - interactivityModel?: InteractivityModelKey; - opacity?: number; - openBalloonOnClick?: boolean; - openEmptyBalloon?: boolean; - openEmptyHint?: boolean; - openHintOnHover?: boolean; - outline?: boolean; - pane?: string; - strokeColor?: string[][] | string[] | string; - strokeOpacity?: number[][] | number[] | number; - strokeStyle?: string[][][] | object[][] | string[] | object[] | string | object; - strokeWidth?: number[][] | number[] | number; - syncOverlayInit?: boolean; - useMapMarginInDragging?: boolean; - visible?: boolean; - zIndex?: number; - zIndexActive?: number; - zIndexDrag?: number; - zIndexHover?: number; - } - - class Clusterer implements IChildOnMap, ICustomizable, IEventEmitter, IParentOnMap { - constructor(options?: IClustererOptions); - - events: IEventManager; - options: IOptionManager; - balloon: clusterer.Balloon; - // balloonopen: - hint: clusterer.Hint; - - getParent(): null | IControlParent; - - setParent(parent: IControlParent): this; - - // balloonclose: - - getMap(): Map; - } - - interface IClustererOptions { - gridSize?: number; - groupByCoordinates?: boolean; - hasBalloon?: boolean; - hasHint?: boolean; - margin?: number[][] | number[] | number; - maxZoom?: number[] | number; - minClusterSize?: number; - preset?: PresetKey; - showInAlphabeticalOrder?: boolean; - useMapMargin?: boolean; - viewportMargin?: number[][] | number[] | number; - zoomMargin?: number[][] | number[] | number; - } - - class ClusterPlacemark implements IGeoObject, collection.Item { - constructor(geometry: number[] | object | IPointGeometry, properties: IClusterPlacemarkProperties, options?: IClusterPlacemarkOptions); + interface ICircleOptions { + circleOverlay?: string | ((geometry: IPixelCircleGeometry, data: object, options: object) => Promise); + cursor?: string; + draggable?: boolean; + fill?: boolean; + fillColor?: string; + fillImageHref?: string; + fillMethod?: "stretch" | "tile"; + fillOpacity?: number; + hasBalloon?: boolean; + hasHint?: boolean; + hideIconOnBalloonOpen?: boolean; + interactiveZIndex?: boolean; + interactivityModel?: InteractivityModelKey; + opacity?: number; + openBalloonOnClick?: boolean; + openEmptyBalloon?: boolean; + openEmptyHint?: boolean; + openHintOnHover?: boolean; + outline?: boolean; + pane?: string; + strokeColor?: string[][] | string[] | string; + strokeOpacity?: number[][] | number[] | number; + strokeStyle?: string[][][] | object[][] | string[] | object[] | string | object; + strokeWidth?: number[][] | number[] | number; + syncOverlayInit?: boolean; + useMapMarginInDragging?: boolean; + visible?: boolean; + zIndex?: number; + zIndexActive?: number; + zIndexDrag?: number; + zIndexHover?: number; + } + + class Clusterer implements IChildOnMap, ICustomizable, IEventEmitter, IParentOnMap { + constructor(options?: IClustererOptions); + + events: IEventManager; + options: IOptionManager; + balloon: clusterer.Balloon; + // balloonopen: + hint: clusterer.Hint; + + getParent(): null | IControlParent; + + setParent(parent: IControlParent): this; + + // balloonclose: + + getMap(): Map; + } + + interface IClustererOptions { + gridSize?: number; + groupByCoordinates?: boolean; + hasBalloon?: boolean; + hasHint?: boolean; + margin?: number[][] | number[] | number; + maxZoom?: number[] | number; + minClusterSize?: number; + preset?: PresetKey; + showInAlphabeticalOrder?: boolean; + useMapMargin?: boolean; + viewportMargin?: number[][] | number[] | number; + zoomMargin?: number[][] | number[] | number; + } + + class ClusterPlacemark implements IGeoObject, collection.Item { + constructor(geometry: number[] | object | IPointGeometry, properties: IClusterPlacemarkProperties, options?: IClusterPlacemarkOptions); - geometry: IGeometry | null; - properties: IDataManager; - events: IEventManager; - options: IOptionManager; - state: data.Manager; + geometry: IGeometry | null; + properties: IDataManager; + events: IEventManager; + options: IOptionManager; + state: data.Manager; - getOverlay(): Promise; + getOverlay(): Promise; - getOverlaySync(): IOverlay | null; + getOverlaySync(): IOverlay | null; - getParent(): null | IControlParent; + getParent(): null | IControlParent; - setParent(parent: IControlParent): this; + setParent(parent: IControlParent): this; - getMap(): Map; + getMap(): Map; - onAddToMap(map: Map): void; + onAddToMap(map: Map): void; - onRemoveFromMap(oldMap: Map): void; + onRemoveFromMap(oldMap: Map): void; - getBounds(): number[][] | null; + getBounds(): number[][] | null; - getGeoObjects(): IGeoObject[]; - } + getGeoObjects(): IGeoObject[]; + } - interface IClusterPlacemarkProperties extends IDataManager { - geoObjects: IGeoObject[]; - } + interface IClusterPlacemarkProperties extends IDataManager { + geoObjects: IGeoObject[]; + } - interface IClusterPlacemarkOptions { - balloonContentLayout?: "cluster#balloonTwoColumns" | "cluster#balloonCarousel" | "cluster#balloonAccordion" | string | IClassConstructor; - balloonContentLayoutHeight?: number; - balloonContentLayoutWidth?: number; - balloonItemContentLayout?: ILayout | string; - balloonPanelContentLayout?: string | IClassConstructor; - cursor?: string; - disableClickZoom?: boolean; - hideIconOnBalloonOpen?: boolean; - iconColor?: string; - iconContentLayout?: string | IClassConstructor; - iconLayout?: string | IClassConstructor; - icons?: Array<{ - href: string; - size: number[]; - ooffset: number[]; - shape?: IShape | IGeometryJson; - }>; - iconShape?: IGeometryJson; - interactivityModel?: InteractivityModelKey; - numbers?: number[]; - openBalloonOnClick?: boolean; - openEmptyHint?: boolean; - openHintOnHover?: boolean; - zIndexHover?: number; - } + interface IClusterPlacemarkOptions { + balloonContentLayout?: "cluster#balloonTwoColumns" | "cluster#balloonCarousel" | "cluster#balloonAccordion" | string | IClassConstructor; + balloonContentLayoutHeight?: number; + balloonContentLayoutWidth?: number; + balloonItemContentLayout?: ILayout | string; + balloonPanelContentLayout?: string | IClassConstructor; + cursor?: string; + disableClickZoom?: boolean; + hideIconOnBalloonOpen?: boolean; + iconColor?: string; + iconContentLayout?: string | IClassConstructor; + iconLayout?: string | IClassConstructor; + icons?: Array<{ + href: string; + size: number[]; + ooffset: number[]; + shape?: IShape | IGeometryJson; + }>; + iconShape?: IGeometryJson; + interactivityModel?: InteractivityModelKey; + numbers?: number[]; + openBalloonOnClick?: boolean; + openEmptyHint?: boolean; + openHintOnHover?: boolean; + zIndexHover?: number; + } - class Collection implements ICollection, collection.Item { - constructor(options?: object); + class Collection implements ICollection, collection.Item { + constructor(options?: object); - events: IEventManager; - options: IOptionManager; + events: IEventManager; + options: IOptionManager; - add(object: object): this; + add(object: object): this; - getIterator(): IIterator; + getIterator(): IIterator; - remove(object: object): this; + remove(object: object): this; - getParent(): null | IControlParent; + getParent(): null | IControlParent; - setParent(parent: IControlParent): this; + setParent(parent: IControlParent): this; - getMap(): Map; + getMap(): Map; - onAddToMap(map: Map): void; + onAddToMap(map: Map): void; - onRemoveFromMap(oldMap: Map): void; + onRemoveFromMap(oldMap: Map): void; - filter(filterFunction: (object: object) => boolean): object[]; + filter(filterFunction: (object: object) => boolean): object[]; - get(index: number): object; + get(index: number): object; - getAll(): object[]; + getAll(): object[]; - getLength(): number; + getLength(): number; - indexOf(childToFind: object): number; + indexOf(childToFind: object): number; - removeAll(): this; - } + removeAll(): this; + } - class Event implements IEvent { - constructor(originalEvent: object, sourceEvent: IEvent); + class Event implements IEvent { + constructor(originalEvent: object, sourceEvent: IEvent); - allowMapEvent(): void; + allowMapEvent(): void; - callMethod(name: string): void; + callMethod(name: string): void; - get(name: string): object; + get(name: string): object; - getSourceEvent(): IEvent | null; + getSourceEvent(): IEvent | null; - isDefaultPrevented(): boolean; + isDefaultPrevented(): boolean; - isImmediatePropagationStopped(): boolean; + isImmediatePropagationStopped(): boolean; - isMapEventAllowed(): boolean; + isMapEventAllowed(): boolean; - isPropagationStopped(): boolean; + isPropagationStopped(): boolean; - preventDefault(): boolean; + preventDefault(): boolean; - stopImmediatePropagation(): boolean; + stopImmediatePropagation(): boolean; - stopPropagation(): boolean; - } + stopPropagation(): boolean; + } - class GeoObject implements IGeoObject { - constructor(feature?: IGeoObjectFeature, options?: IGeoObjectOptions); + class GeoObject implements IGeoObject { + constructor(feature?: IGeoObjectFeature, options?: IGeoObjectOptions); - geometry: IGeometry | null; - balloon: geoObject.Balloon; - editor: IGeometryEditor; - hint: geoObject.Hint; - events: event.Manager; - options: option.Manager; - properties: data.Manager; - state: data.Manager; + geometry: IGeometry | null; + balloon: geoObject.Balloon; + editor: IGeometryEditor; + hint: geoObject.Hint; + events: event.Manager; + options: option.Manager; + properties: data.Manager; + state: data.Manager; - getOverlay(): Promise; + getOverlay(): Promise; - getOverlaySync(): IOverlay | null; + getOverlaySync(): IOverlay | null; - getParent(): null | IControlParent; + getParent(): null | IControlParent; - setParent(parent: IControlParent): this; + setParent(parent: IControlParent): this; - getMap(): Map; - } + getMap(): Map; + } - interface IGeoObjectFeature { - geometry?: IGeometry | IGeometryJson | object; - properties?: IDataManager | object; - } + interface IGeoObjectFeature { + geometry?: IGeometry | IGeometryJson | object; + properties?: IDataManager | object; + } - interface IGeoObjectOptions extends ICircleOptions { - iconCaptionMaxWidth?: number; - iconColor?: string; - iconContentLayout?: string | IClassConstructor; - iconContentOffset?: number[]; - iconContentPadding?: number[]; - iconContentSize?: number[]; - iconImageClipRect?: number[][]; - iconImageHref?: string; - iconImageOffset?: number[]; - iconImageShape?: IShape | null; - iconImageSize?: number[]; - iconLayout?: string | IClassConstructor; - iconMaxHeight?: number; - iconMaxWidth?: number; - iconOffset?: number[]; - iconShadow?: boolean; - iconShadowImageClipRect?: number[][]; - iconShadowImageHref?: string; - iconShadowImageOffset?: number[]; - iconShadowImageSize?: number[]; - iconShadowLayout?: string | IClassConstructor; - iconShadowOffset?: number[]; - lineStringOverlay?: OverlayKey; - pointOverlay?: OverlayKey; - polygonOverlay?: OverlayKey; - preset?: string; - rectangleOverlay?: OverlayKey; - setMapCursorInDragging?: boolean; - } + interface IGeoObjectOptions extends ICircleOptions { + iconCaptionMaxWidth?: number; + iconColor?: string; + iconContentLayout?: string | IClassConstructor; + iconContentOffset?: number[]; + iconContentPadding?: number[]; + iconContentSize?: number[]; + iconImageClipRect?: number[][]; + iconImageHref?: string; + iconImageOffset?: number[]; + iconImageShape?: IShape | null; + iconImageSize?: number[]; + iconLayout?: string | IClassConstructor; + iconMaxHeight?: number; + iconMaxWidth?: number; + iconOffset?: number[]; + iconShadow?: boolean; + iconShadowImageClipRect?: number[][]; + iconShadowImageHref?: string; + iconShadowImageOffset?: number[]; + iconShadowImageSize?: number[]; + iconShadowLayout?: string | IClassConstructor; + iconShadowOffset?: number[]; + lineStringOverlay?: OverlayKey; + pointOverlay?: OverlayKey; + polygonOverlay?: OverlayKey; + preset?: string; + rectangleOverlay?: OverlayKey; + setMapCursorInDragging?: boolean; + } - class GeoObjectCollection implements IGeoObject, IGeoObjectCollection { - constructor(feature?: { - children?: IGeoObject[]; - geometry?: IGeometry | object; - properties?: IDataManager | object; - }, options?: object); + class GeoObjectCollection implements IGeoObject, IGeoObjectCollection { + constructor(feature?: { + children?: IGeoObject[]; + geometry?: IGeometry | object; + properties?: IDataManager | object; + }, options?: object); - geometry: IGeometry | null; - properties: IDataManager; - state: IDataManager; - events: IEventManager; - options: IOptionManager; + geometry: IGeometry | null; + properties: IDataManager; + state: IDataManager; + events: IEventManager; + options: IOptionManager; - getOverlay(): Promise; + getOverlay(): Promise; - getOverlaySync(): IOverlay | null; + getOverlaySync(): IOverlay | null; - getParent(): null | IControlParent; + getParent(): null | IControlParent; - setParent(parent: IControlParent): this; + setParent(parent: IControlParent): this; - getMap(): Map; + getMap(): Map; - add(child: IGeoObject, index?: number): this; + add(child: IGeoObject, index?: number): this; - each(callback: (object: IGeoObject) => void, context: object): void; + each(callback: (object: IGeoObject) => void, context: object): void; - get(index: number): IGeoObject; + get(index: number): IGeoObject; - getBounds(): number[][] | null; + getBounds(): number[][] | null; - getIterator(): IIterator; + getIterator(): IIterator; - getLength(): number; + getLength(): number; - getPixelBounds(): number[][] | null; + getPixelBounds(): number[][] | null; - indexOf(object: IGeoObject): number; + indexOf(object: IGeoObject): number; - remove(child: IGeoObject): this; + remove(child: IGeoObject): this; - removeAll(): this; + removeAll(): this; - set(index: number, child: IGeoObject): this; + set(index: number, child: IGeoObject): this; - splice(index: number, length: number): this; + splice(index: number, length: number): this; - toArray(): IGeoObject[]; - } + toArray(): IGeoObject[]; + } - class Layer implements ILayer, IParentOnMap, IPositioningContext { - constructor(tileUrlTemplate: string | ((tileNumber: number[], tileZoom: number) => string)); + class Layer implements ILayer, IParentOnMap, IPositioningContext { + constructor(tileUrlTemplate: string | ((tileNumber: number[], tileZoom: number) => string)); - events: IEventManager; - options: IOptionManager; + events: IEventManager; + options: IOptionManager; - fromClientPixels(clientPixelPoint: number[]): number[]; + fromClientPixels(clientPixelPoint: number[]): number[]; - getZoom(): number; + getZoom(): number; - toClientPixels(globalPixelPoint: number[]): number[]; + toClientPixels(globalPixelPoint: number[]): number[]; - getParent(): null | IControlParent; + getParent(): null | IControlParent; - setParent(parent: IControlParent): this; + setParent(parent: IControlParent): this; - getMap(): Map; - } + getMap(): Map; + } - class Map implements IDomEventEmitter { - constructor(parentElement: HTMLElement | string, state: IMapState, options?: IMapOptions) + class Map implements IDomEventEmitter { + constructor(parentElement: HTMLElement | string, state: IMapState, options?: IMapOptions) - action: map.action.Manager; - balloon: map.Balloon; - behaviors: map.behavior.Manager; - container: map.Container; - controls: control.Manager; - converter: map.Converter; - copyrights: map.Copyrights; - cursors: util.cursor.Manager; - events: event.Manager; - geoObjects: map.GeoObjects; - hint: map.Hint; - layers: map.layer.Manager; - margin: map.margin.Manager; - options: option.Manager; - panes: map.pane.Manager; - zoomRange: map.ZoomRange; + action: map.action.Manager; + balloon: map.Balloon; + behaviors: map.behavior.Manager; + container: map.Container; + controls: control.Manager; + converter: map.Converter; + copyrights: map.Copyrights; + cursors: util.cursor.Manager; + events: event.Manager; + geoObjects: map.GeoObjects; + hint: map.Hint; + layers: map.layer.Manager; + margin: map.margin.Manager; + options: option.Manager; + panes: map.pane.Manager; + zoomRange: map.ZoomRange; - destroy(): void; + destroy(): void; - getBounds(options?: IMapMarginOptions): number[][]; + getBounds(options?: IMapMarginOptions): number[][]; - getCenter(options?: IMapMarginOptions): number[]; + getCenter(options?: IMapMarginOptions): number[]; - getGlobalPixelCenter(options?: IMapMarginOptions): number[]; + getGlobalPixelCenter(options?: IMapMarginOptions): number[]; - getPanoramaManager(): Promise; + getPanoramaManager(): Promise; - getType(): string | MapType; + getType(): string | MapType; - getZoom(): number; + getZoom(): number; - panTo(center: number[] | object[], options?: IMapPanOptions): Promise; + panTo(center: number[] | object[], options?: IMapPanOptions): Promise; - setBounds(bounds: number[][], options?: IMapBoundsOptions): Promise; + setBounds(bounds: number[][], options?: IMapBoundsOptions): Promise; - setCenter(center: number[], zoom?: number, options?: IMapPositionOptions): Promise; + setCenter(center: number[], zoom?: number, options?: IMapPositionOptions): Promise; - setGlobalPixelCenter(globalPixelCenter: number[], zoom?: number, options?: IMapPositionOptions): Promise; + setGlobalPixelCenter(globalPixelCenter: number[], zoom?: number, options?: IMapPositionOptions): Promise; - setType(type: string | MapType, options?: IMapCheckZoomRangeOptions): Promise; + setType(type: string | MapType, options?: IMapCheckZoomRangeOptions): Promise; - setZoom(zoom: number, options?: IMapZoomOptions): Promise; - } + setZoom(zoom: number, options?: IMapZoomOptions): Promise; + } - interface IMapMarginOptions { - useMapMargin?: boolean; - } + interface IMapMarginOptions { + useMapMargin?: boolean; + } - interface IMapCheckZoomRangeOptions { - checkZoomRange?: boolean; - } + interface IMapCheckZoomRangeOptions { + checkZoomRange?: boolean; + } - interface IMapZoomOptions extends IMapMarginOptions, IMapCheckZoomRangeOptions { - duration?: number; - } + interface IMapZoomOptions extends IMapMarginOptions, IMapCheckZoomRangeOptions { + duration?: number; + } - interface IMapPositionOptions extends IMapZoomOptions { - timingFunction?: string; - } + interface IMapPositionOptions extends IMapZoomOptions { + timingFunction?: string; + } - interface IMapBoundsOptions extends IMapPositionOptions { - preciseZoom?: boolean; - zoomMargin?: number[][] | number[]; - } + interface IMapBoundsOptions extends IMapPositionOptions { + preciseZoom?: boolean; + zoomMargin?: number[][] | number[]; + } - interface IMapPanOptions extends IMapPositionOptions { - delay?: number; - flying?: boolean; - safe?: boolean; - } + interface IMapPanOptions extends IMapPositionOptions { + delay?: number; + flying?: boolean; + safe?: boolean; + } - class MapType { - constructor(name: string, layers: Array | string>) - } + class MapType { + constructor(name: string, layers: Array | string>) + } - interface IMapState { - behaviors?: string[]; - bounds?: number[][]; - center?: number[]; - controls?: string[]; - margin?: number[][] | number[]; - type?: "yandex#map" | "yandex#satellite" | "yandex#hybrid"; - zoom?: number; - } + interface IMapState { + behaviors?: string[]; + bounds?: number[][]; + center?: number[]; + controls?: string[]; + margin?: number[][] | number[]; + type?: "yandex#map" | "yandex#satellite" | "yandex#hybrid"; + zoom?: number; + } - interface IMapOptions { - autoFitToViewport?: "none" | "ifNull" | "always"; - avoidFractionalZoom?: boolean; - exitFullscreenByEsc?: boolean; - fullscreenZIndex?: number; - mapAutoFocus?: boolean; - maxAnimationZoomDifference?: number; - maxZoom?: number; - minZoom?: number; - nativeFullscreen?: boolean; - projection?: IProjection; - restrictMapArea?: boolean; - suppressMapOpenBlock?: boolean; - suppressObsoleteBrowserNotifier?: boolean; - yandexMapAutoSwitch?: boolean; - yandexMapDisablePoiInteractivity?: boolean; - } + interface IMapOptions { + autoFitToViewport?: "none" | "ifNull" | "always"; + avoidFractionalZoom?: boolean; + exitFullscreenByEsc?: boolean; + fullscreenZIndex?: number; + mapAutoFocus?: boolean; + maxAnimationZoomDifference?: number; + maxZoom?: number; + minZoom?: number; + nativeFullscreen?: boolean; + projection?: IProjection; + restrictMapArea?: boolean; + suppressMapOpenBlock?: boolean; + suppressObsoleteBrowserNotifier?: boolean; + yandexMapAutoSwitch?: boolean; + yandexMapDisablePoiInteractivity?: boolean; + } - class Placemark extends GeoObject { - constructor(geometry: number[] | object | IPointGeometry, properties: object | IDataManager, options?: IPlacemarkOptions) - } + class Placemark extends GeoObject { + constructor(geometry: number[] | object | IPointGeometry, properties: object | IDataManager, options?: IPlacemarkOptions) + } - interface IPlacemarkOptions { - cursor?: string; - draggable?: boolean; + interface IPlacemarkOptions { + cursor?: string; + draggable?: boolean; - [index: string]: any; - } + [index: string]: any; + } - class Popup implements IPopup { - constructor(map: Map, options?: IPopupOptions); + class Popup implements IPopup { + constructor(map: Map, options?: IPopupOptions); - options: IOptionManager; - events: IEventManager; + options: IOptionManager; + events: IEventManager; - close(force?: boolean): Promise; + close(force?: boolean): Promise; - getData(): object; + getData(): object; - getOverlay(): Promise; + getOverlay(): Promise; - getOverlaySync(): IOverlay; + getOverlaySync(): IOverlay; - getPosition(): number[]; + getPosition(): number[]; - isOpen(): boolean; + isOpen(): boolean; - open(position: number[], data: object | string | HTMLElement): Promise; + open(position: number[], data: object | string | HTMLElement): Promise; - setData(data: object | string | HTMLElement): Promise; + setData(data: object | string | HTMLElement): Promise; - setPosition(position: number[]): Promise; - } + setPosition(position: number[]): Promise; + } - interface IPopupOptions { - closeTimeout?: number; - interactivityModel?: InteractivityModelKey; - openTimeout?: number; - pane?: IPane | string; - projection?: IProjection; - zIndex?: number; - } + interface IPopupOptions { + closeTimeout?: number; + interactivityModel?: InteractivityModelKey; + openTimeout?: number; + pane?: IPane | string; + projection?: IProjection; + zIndex?: number; + } - function ready(successCallback?: () => any | IReadyobject, errorCallback?: () => any, context?: object): Promise; + function ready(successCallback?: () => any | IReadyobject, errorCallback?: () => any, context?: object): Promise; - interface IReadyobject { - require?: string[]; - context?: object; + interface IReadyobject { + require?: string[]; + context?: object; - successCallback?(): void; + successCallback?(): void; - errorCallback?(): void; - } + errorCallback?(): void; + } - namespace templateLayoutFactory { - function createClass(template: string, overrides?: object, staticMethods?: object): IClassConstructor; - } + namespace templateLayoutFactory { + function createClass(template: string, overrides?: object, staticMethods?: object): IClassConstructor; + } - namespace util { - namespace cursor { - class Accessor { - constructor(key: string); + namespace util { + namespace cursor { + class Accessor { + constructor(key: string); - getKey(): string; + getKey(): string; - remove(): void; + remove(): void; - setKey(): void; - } + setKey(): void; + } - class Manager { - constructor(element: HTMLElement); + class Manager { + constructor(element: HTMLElement); - push(key: string): Accessor; - } - } + push(key: string): Accessor; + } + } - class Storage { - add(key: string, object: object): this; + class Storage { + add(key: string, object: object): this; - get(key: string | object): object | string; + get(key: string | object): object | string; - remove(key: string): object; - } - } + remove(key: string): object; + } + } - /*Interfaces*/ + /*Interfaces*/ - interface IBaloon extends IPopup, ICustomizable, IChild, IFreezable { - autoPan(): Promise; - } + interface IBaloon extends IPopup, ICustomizable, IChild, IFreezable { + autoPan(): Promise; + } - interface IBalloonManager extends IPopupManager { - autoPan(): Promise; - } + interface IBalloonManager extends IPopupManager { + autoPan(): Promise; + } - interface IBaseGeometry extends IEventEmitter { - getBounds(): number[][] | null; + interface IBaseGeometry extends IEventEmitter { + getBounds(): number[][] | null; - getType(): string; - } + getType(): string; + } - interface IBaseLineStringGeometry extends IBaseGeometry, ILineStringGeometryAccess {//tslint:disable-line no-empty-interface no-empty-interfaces - } + interface IBaseLineStringGeometry extends IBaseGeometry, ILineStringGeometryAccess {//tslint:disable-line no-empty-interface no-empty-interfaces + } - interface IBasePointGeometry extends IBaseGeometry, IPointGeometryAccess {//tslint:disable-line no-empty-interface no-empty-interfaces - } + interface IBasePointGeometry extends IBaseGeometry, IPointGeometryAccess {//tslint:disable-line no-empty-interface no-empty-interfaces + } - interface IBehavior extends IChildOnMap, ICustomizable { - disable(): void; + interface IBehavior extends IChildOnMap, ICustomizable { + disable(): void; - enable(): void; + enable(): void; - isEnabled(): boolean; - } + isEnabled(): boolean; + } - interface IChild extends IEventEmitter { - getParent(): object | null; + interface IChild extends IEventEmitter { + getParent(): object | null; - setParent(parent: object | null): this; - } + setParent(parent: object | null): this; + } - interface IChildOnMap extends IChild { //tslint:disable-line no-empty-interface no-empty-interfaces - } + interface IChildOnMap extends IChild { //tslint:disable-line no-empty-interface no-empty-interfaces + } - interface ICircleGeometry extends ICircleGeometryAccess, IGeometry { //tslint:disable-line no-empty-interface no-empty-interfaces - } + interface ICircleGeometry extends ICircleGeometryAccess, IGeometry { //tslint:disable-line no-empty-interface no-empty-interfaces + } - interface ICircleGeometryAccess extends IFreezable { - contains(position: number[]): boolean; + interface ICircleGeometryAccess extends IFreezable { + contains(position: number[]): boolean; - getClosest(anchorPosition: number[]): object; + getClosest(anchorPosition: number[]): object; - getCoordinates(): number[] | null; + getCoordinates(): number[] | null; - getRadius(): number; + getRadius(): number; - setCoordinates(coordinates: number[] | null): this; + setCoordinates(coordinates: number[] | null): this; - setRadius(radius: number): this; - } + setRadius(radius: number): this; + } - interface ICollection extends IEventEmitter { - add(object: object): this; + interface ICollection extends IEventEmitter { + add(object: object): this; - getIterator(): IIterator; + getIterator(): IIterator; - remove(object: object): this; - } + remove(object: object): this; + } - interface IControl extends IChildOnMap { //tslint:disable-line no-empty-interface no-empty-interfaces - // new (options?: object); - } + interface IControl extends IChildOnMap { //tslint:disable-line no-empty-interface no-empty-interfaces + // new (options?: object); + } - interface IControlParent extends IParentOnMap { - getChildElement(child: IControl): Promise; - } + interface IControlParent extends IParentOnMap { + getChildElement(child: IControl): Promise; + } - interface ICoordSystem { - getDistance(point1: number[], point2: number[]): number; + interface ICoordSystem { + getDistance(point1: number[], point2: number[]): number; - solveDirectProblem(startPoint: number[], direction: number[], distance: number): object; + solveDirectProblem(startPoint: number[], direction: number[], distance: number): object; - solveInverseProblem(startPoint: number[], endPoint: number[], reverseDirection?: boolean): object; - } + solveInverseProblem(startPoint: number[], endPoint: number[], reverseDirection?: boolean): object; + } - interface ICopyrightsAccessor extends ICopyrightsProvider { //tslint:disable-line no-empty-interface no-empty-interfaces - } + interface ICopyrightsAccessor extends ICopyrightsProvider { //tslint:disable-line no-empty-interface no-empty-interfaces + } - interface ICopyrightsProvider extends IEventEmitter { - getCopyrights(coords: number[], zoom: number): Promise>; + interface ICopyrightsProvider extends IEventEmitter { + getCopyrights(coords: number[], zoom: number): Promise>; - remove(): void; + remove(): void; - setCopyrights(copyrights: string | HTMLElement | Array): void; - } + setCopyrights(copyrights: string | HTMLElement | Array): void; + } - interface ICustomizable extends IEventEmitter { - options: IOptionManager; - } + interface ICustomizable extends IEventEmitter { + options: IOptionManager; + } - interface IDataManager extends IEventEmitter { - get(path: string, defaultValue: object): object; - } + interface IDataManager extends IEventEmitter { + get(path: string, defaultValue: object): object; + } - interface IDomEventEmitter extends IEventEmitter { //tslint:disable-line no-empty-interface no-empty-interfaces - } + interface IDomEventEmitter extends IEventEmitter { //tslint:disable-line no-empty-interface no-empty-interfaces + } - interface IEvent { - allowMapEvent(): void; + interface IEvent { + allowMapEvent(): void; - callMethod(name: string): void; + callMethod(name: string): void; - get(name: string): object; + get(name: string): object; - getSourceEvent(): IEvent | null; + getSourceEvent(): IEvent | null; - isDefaultPrevented(): boolean; + isDefaultPrevented(): boolean; - isImmediatePropagationStopped(): boolean; + isImmediatePropagationStopped(): boolean; - isMapEventAllowed(): boolean; + isMapEventAllowed(): boolean; - isPropagationStopped(): boolean; + isPropagationStopped(): boolean; - preventDefault(): boolean; + preventDefault(): boolean; - stopImmediatePropagation(): boolean; + stopImmediatePropagation(): boolean; - stopPropagation(): boolean; - } + stopPropagation(): boolean; + } - interface IEventController { - onStartListening?(events: IEventManager, type: string): void; + interface IEventController { + onStartListening?(events: IEventManager, type: string): void; - onStopListening?(events: IEventManager, type: string): void; - } + onStopListening?(events: IEventManager, type: string): void; + } - interface IEventEmitter { - events: IEventManager; - } + interface IEventEmitter { + events: IEventManager; + } - interface IEventGroup { - add(types: string[][] | string[] | string, callback: (event: object | IEvent) => void, context?: object, priority?: number): this; + interface IEventGroup { + add(types: string[][] | string[] | string, callback: (event: object | IEvent) => void, context?: object, priority?: number): this; - remove(types: string[][] | string[] | string, callback: (event: object | IEvent) => void, context?: object, priority?: number): this; + remove(types: string[][] | string[] | string, callback: (event: object | IEvent) => void, context?: object, priority?: number): this; - removeAll(): this; - } + removeAll(): this; + } - interface IEventManager extends IEventTrigger { - add(types: string[][] | string[] | string, callback: (event: object | IEvent) => void, context?: object, priority?: number): this; + interface IEventManager extends IEventTrigger { + add(types: string[][] | string[] | string, callback: (event: object | IEvent) => void, context?: object, priority?: number): this; - getParent(): object | null; + getParent(): object | null; - group(): IEventGroup; + group(): IEventGroup; - //remove(types: string[][] | string[] | string, callback: (event: object | IEvent) => void, context?: object, priority?: number): this; + //remove(types: string[][] | string[] | string, callback: (event: object | IEvent) => void, context?: object, priority?: number): this; - setParent(parent: object | null): this; - } + setParent(parent: object | null): this; + } - interface IEventTrigger { - fire(type: string, eventobject: object | IEvent): this; - } + interface IEventTrigger { + fire(type: string, eventobject: object | IEvent): this; + } - interface IEventWorkflowController extends IEventController { - onAfterEventFiring?(events: IEventManager, type: string, event?: IEvent): void; + interface IEventWorkflowController extends IEventController { + onAfterEventFiring?(events: IEventManager, type: string, event?: IEvent): void; - onBeforeEventFiring?(events: IEventManager, type: string, event?: IEvent): void; - } + onBeforeEventFiring?(events: IEventManager, type: string, event?: IEvent): void; + } - interface IExpandableControlLayout extends ILayout { //tslint:disable-line no-empty-interface no-empty-interfaces - } + interface IExpandableControlLayout extends ILayout { //tslint:disable-line no-empty-interface no-empty-interfaces + } - interface IFreezable extends IEventManager { - freeze(): IFreezable; + interface IFreezable extends IEventManager { + freeze(): IFreezable; - isFrozen(): boolean; + isFrozen(): boolean; - unfreeze(): IFreezable; - } + unfreeze(): IFreezable; + } - interface IGeocodeProvider { - geocode(request: string, options?: { boundedBy?: number[][], results?: number, skip?: number, strictBounds?: boolean }): Promise; + interface IGeocodeProvider { + geocode(request: string, options?: { boundedBy?: number[][], results?: number, skip?: number, strictBounds?: boolean }): Promise; - suggest(request: string, options?: { boundedBy?: number[][], results?: number, strictBounds?: boolean }): Promise; - } + suggest(request: string, options?: { boundedBy?: number[][], results?: number, strictBounds?: boolean }): Promise; + } - interface IGeometry extends IBaseGeometry, ICustomizable { - getMap(): Map | null; + interface IGeometry extends IBaseGeometry, ICustomizable { + getMap(): Map | null; - getPixelGeometry(options?: object): IPixelGeometry; + getPixelGeometry(options?: object): IPixelGeometry; - setMap(map: Map): void; - } + setMap(map: Map): void; + } - interface IGeometryEditor extends ICustomizable, IEventEmitter { - startEditing(): void; + interface IGeometryEditor extends ICustomizable, IEventEmitter { + startEditing(): void; - stopEditing(): void; - } + stopEditing(): void; + } - interface IGeometryJson { - type: string; - } + interface IGeometryJson { + type: string; + } - interface IGeoObject extends IChildOnMap, ICustomizable, IDomEventEmitter, IParentOnMap { - geometry: IGeometry | null; - properties: IDataManager; - state: IDataManager; + interface IGeoObject extends IChildOnMap, ICustomizable, IDomEventEmitter, IParentOnMap { + geometry: IGeometry | null; + properties: IDataManager; + state: IDataManager; - getOverlay(): Promise; + getOverlay(): Promise; - getOverlaySync(): IOverlay | null; - } + getOverlaySync(): IOverlay | null; + } - interface IGeoObjectCollection extends ICustomizable, IEventEmitter, IParentOnMap { - add(child: IGeoObject, index?: number): this; + interface IGeoObjectCollection extends ICustomizable, IEventEmitter, IParentOnMap { + add(child: IGeoObject, index?: number): this; - each(callback: (object: IGeoObject) => void, context: object): void; + each(callback: (object: IGeoObject) => void, context: object): void; - get(index: number): IGeoObject; + get(index: number): IGeoObject; - getBounds(): number[][] | null; + getBounds(): number[][] | null; - getIterator(): IIterator; + getIterator(): IIterator; - getLength(): number; + getLength(): number; - getPixelBounds(): number[][] | null; + getPixelBounds(): number[][] | null; - indexOf(object: IGeoObject): number; + indexOf(object: IGeoObject): number; - remove(child: IGeoObject): this; + remove(child: IGeoObject): this; - removeAll(): this; + removeAll(): this; - set(index: number, child: IGeoObject): this; + set(index: number, child: IGeoObject): this; - splice(index: number, length: number): this; - } + splice(index: number, length: number): this; + } - interface IGeoObjectSequence extends ICustomizable, IEventEmitter, IParentOnMap { - each(callback: (geoObject: IGeoObject) => void, context?: object): void; + interface IGeoObjectSequence extends ICustomizable, IEventEmitter, IParentOnMap { + each(callback: (geoObject: IGeoObject) => void, context?: object): void; - get(index: number): IGeoObject; + get(index: number): IGeoObject; - getBounds(): number[][] | null; + getBounds(): number[][] | null; - getIterator(): IIterator; + getIterator(): IIterator; - getLength(): number; + getLength(): number; - getPixelBounds(): number[][] | null; + getPixelBounds(): number[][] | null; - indexOf(geoObject: IGeoObject): number; - } + indexOf(geoObject: IGeoObject): number; + } - interface IHintManager extends IPopupManager { //tslint:disable-line no-empty-interface no-empty-interfaces - } + interface IHintManager extends IPopupManager { //tslint:disable-line no-empty-interface no-empty-interfaces + } - interface IIterator { - getNext(): object | null; - } + interface IIterator { + getNext(): object | null; + } - interface ILayer extends IChildOnMap, ICustomizable, IEventEmitter { - getBrightness?(): number; + interface ILayer extends IChildOnMap, ICustomizable, IEventEmitter { + getBrightness?(): number; - getCopyrights?(coords: number[], zoom: number): Promise>; + getCopyrights?(coords: number[], zoom: number): Promise>; - getZoomRange?(point: number[]): Promise; - } + getZoomRange?(point: number[]): Promise; + } - interface ILayout extends IDomEventEmitter { - // new (data: object); - destroy(): void; + interface ILayout extends IDomEventEmitter { + // new (data: object); + destroy(): void; - getData(): object; + getData(): object; - getParentElement(): HTMLElement; + getParentElement(): HTMLElement; - getShape(): IShape | null; + getShape(): IShape | null; - isEmpty(): boolean; + isEmpty(): boolean; - setData(data: object): void; + setData(data: object): void; - setParentElement(parent: HTMLElement | null): void; - } + setParentElement(parent: HTMLElement | null): void; + } - interface ILineStringGeometry extends IGeometry, ILineStringGeometryAccess { //tslint:disable-line no-empty-interface no-empty-interfaces - } + interface ILineStringGeometry extends IGeometry, ILineStringGeometryAccess { //tslint:disable-line no-empty-interface no-empty-interfaces + } - interface ILineStringGeometryAccess extends IFreezable { - get(index: number): number[]; + interface ILineStringGeometryAccess extends IFreezable { + get(index: number): number[]; - getChildGeometry(index: number): IPointGeometryAccess; + getChildGeometry(index: number): IPointGeometryAccess; - getClosest(anchorPosition: number[]): object; + getClosest(anchorPosition: number[]): object; - getCoordinates(): number[][]; + getCoordinates(): number[][]; - getLength(): number; + getLength(): number; - insert(index: number, coordinates: number[][]): ILineStringGeometryAccess; + insert(index: number, coordinates: number[][]): ILineStringGeometryAccess; - remove(index: number): number[]; + remove(index: number): number[]; - set(index: number, coordinates: number[]): ILineStringGeometryAccess; + set(index: number, coordinates: number[]): ILineStringGeometryAccess; - setCoordinates(coordinates: number[]): ILineStringGeometryAccess; + setCoordinates(coordinates: number[]): ILineStringGeometryAccess; - splice(index: number, length: number): number[][]; - } + splice(index: number, length: number): number[][]; + } - interface IMapAction extends IEventEmitter { - begin(mapActionManager: map.action.Manager): void; + interface IMapAction extends IEventEmitter { + begin(mapActionManager: map.action.Manager): void; - end(): void; - } + end(): void; + } - interface IMapObjectCollection extends ICollection, ICustomizable, IParentOnMap { //tslint:disable-line no-empty-interface no-empty-interfaces - } + interface IMapObjectCollection extends ICollection, ICustomizable, IParentOnMap { //tslint:disable-line no-empty-interface no-empty-interfaces + } - interface IMultiRouteModelJson { - params: IMultiRouteParams; - referencePoints: IMultiRouteReferencePoint[]; - } + interface IMultiRouteModelJson { + params: IMultiRouteParams; + referencePoints: IMultiRouteReferencePoint[]; + } - interface IMultiRouteParams { - avoidTrafficJams?: boolean; - boundedBy?: number[][] | null; - requestSendInterval?: string | number; - results?: number; - reverseGeocoding?: boolean; - routingMode?: "auto" | "masstransit" | "pedestrian"; - searchCoordOrder?: string; - strictBounds?: boolean; - viaIndexes?: number[]; - } + interface IMultiRouteParams { + avoidTrafficJams?: boolean; + boundedBy?: number[][] | null; + requestSendInterval?: string | number; + results?: number; + reverseGeocoding?: boolean; + routingMode?: "auto" | "masstransit" | "pedestrian"; + searchCoordOrder?: string; + strictBounds?: boolean; + viaIndexes?: number[]; + } - type IMultiRouteReferencePoint = string | number[] | geometry.Point; + type IMultiRouteReferencePoint = string | number[] | geometry.Point; - interface IOptionManager extends IChild, IEventEmitter, IFreezable { - get(key: string, defaultValue: object): object; + interface IOptionManager extends IChild, IEventEmitter, IFreezable { + get(key: string, defaultValue: object): object; - getAll(): object; + getAll(): object; - getName(): string; + getName(): string; - getNative(key: string): object; + getNative(key: string): object; - resolve(key: string, name?: string): object; + resolve(key: string, name?: string): object; - setName(name: string): void; - } + setName(name: string): void; + } - interface IOverlay extends ICustomizable, IDomEventEmitter { - getData(): object; + interface IOverlay extends ICustomizable, IDomEventEmitter { + getData(): object; - getGeometry(): IPixelGeometry; + getGeometry(): IPixelGeometry; - getMap(): Map | null; + getMap(): Map | null; - getShape(): IShape | null; + getShape(): IShape | null; - isEmpty(): boolean; + isEmpty(): boolean; - setData(data: object): void; + setData(data: object): void; - setGeometry(geometry: IPixelGeometry): void; + setGeometry(geometry: IPixelGeometry): void; - setMap(map: Map | null): void; - } + setMap(map: Map | null): void; + } - interface IPane extends IEventEmitter { - destroy(): void; + interface IPane extends IEventEmitter { + destroy(): void; - getElement(): HTMLElement; + getElement(): HTMLElement; - getMap(): Map; + getMap(): Map; - getOverflow(): "visible" | "hidden"; + getOverflow(): "visible" | "hidden"; - getZIndex(): number; - } + getZIndex(): number; + } - interface IPanorama { - getAngularBBox(): number[]; + interface IPanorama { + getAngularBBox(): number[]; - getConnectionArrows(): IPanoramaConnectionArrow[]; + getConnectionArrows(): IPanoramaConnectionArrow[]; - getConnectionMarkers(): IPanoramaConnectionMarker[]; + getConnectionMarkers(): IPanoramaConnectionMarker[]; - getCoordSystem(): ICoordSystem; + getCoordSystem(): ICoordSystem; - getDefaultDirection(): number[]; + getDefaultDirection(): number[]; - getDefaultSpan(): number[]; + getDefaultSpan(): number[]; - getGraph(): IPanoramaGraph | null; + getGraph(): IPanoramaGraph | null; - getMarkers(): IPanoramaMarker[]; + getMarkers(): IPanoramaMarker[]; - getName(): string; + getName(): string; - getPosition(): number[]; + getPosition(): number[]; - getTileLevels(): IPanoramaTileLevel[]; + getTileLevels(): IPanoramaTileLevel[]; - getTileSize(): number[]; - } + getTileSize(): number[]; + } - interface IPanoramaConnection { - getConnectedPanorama(): Promise; - } + interface IPanoramaConnection { + getConnectedPanorama(): Promise; + } - interface IPanoramaConnectionArrow extends IPanoramaConnection { - properties: data.Manager; + interface IPanoramaConnectionArrow extends IPanoramaConnection { + properties: data.Manager; - getDirection(): number[]; + getDirection(): number[]; - getPanorama(): IPanorama; - } + getPanorama(): IPanorama; + } - interface IPanoramaConnectionMarker extends IPanoramaConnection, IPanoramaMarker { //tslint:disable-line no-empty-interface no-empty-interfaces - } + interface IPanoramaConnectionMarker extends IPanoramaConnection, IPanoramaMarker { //tslint:disable-line no-empty-interface no-empty-interfaces + } - interface IPanoramaGraph { - getEdges(): IPanoramaGraphEdge[]; + interface IPanoramaGraph { + getEdges(): IPanoramaGraphEdge[]; - getNodes(): IPanoramaGraphEdge[]; + getNodes(): IPanoramaGraphEdge[]; - getPanorama(): IPanorama; - } + getPanorama(): IPanorama; + } - interface IPanoramaGraphEdge { - getEndNodes(): IPanoramaGraphNode[]; - } + interface IPanoramaGraphEdge { + getEndNodes(): IPanoramaGraphNode[]; + } - interface IPanoramaGraphNode { - getConnectedPanorama(): Promise; - } + interface IPanoramaGraphNode { + getConnectedPanorama(): Promise; + } - interface IPanoramaMarker { - properties: data.Manager; + interface IPanoramaMarker { + properties: data.Manager; - getIconSet(): Promise; + getIconSet(): Promise; - getPanorama(): IPanorama; + getPanorama(): IPanorama; - getPosition(): number[]; - } + getPosition(): number[]; + } - interface IPanoramaMarkerIcon { - image: HTMLCanvasElement | HTMLImageElement; - offset: number[]; - } + interface IPanoramaMarkerIcon { + image: HTMLCanvasElement | HTMLImageElement; + offset: number[]; + } - interface IPanoramaMarkerIconSet { - default: IPanoramaMarkerIcon | null; - expanded: IPanoramaMarkerIcon | null; - expandedHovered: IPanoramaMarkerIcon | null; - hovered: IPanoramaMarkerIcon | null; - } + interface IPanoramaMarkerIconSet { + default: IPanoramaMarkerIcon | null; + expanded: IPanoramaMarkerIcon | null; + expandedHovered: IPanoramaMarkerIcon | null; + hovered: IPanoramaMarkerIcon | null; + } - interface IPanoramaTileLevel { - getImageSize(): number[]; + interface IPanoramaTileLevel { + getImageSize(): number[]; - getTileUrl(x: number, y: number): string; - } + getTileUrl(x: number, y: number): string; + } - interface IParentOnMap { - getMap(): Map; - } + interface IParentOnMap { + getMap(): Map; + } - interface IPixelCircleGeometry extends IPixelGeometry { - getCoordinates(): number[]; + interface IPixelCircleGeometry extends IPixelGeometry { + getCoordinates(): number[]; - getRadius(): number; - } + getRadius(): number; + } - interface IPixelLineStringGeometry extends IPixelGeometry { - getClosest(anchorPosition: number[]): object; + interface IPixelLineStringGeometry extends IPixelGeometry { + getClosest(anchorPosition: number[]): object; - getCoordinates(): number[][]; + getCoordinates(): number[][]; - getLength(): number; - } + getLength(): number; + } - interface IPixelGeometry extends IBaseGeometry { - equals(geometry: IPixelGeometry): boolean; + interface IPixelGeometry extends IBaseGeometry { + equals(geometry: IPixelGeometry): boolean; - getMetaData(): object; + getMetaData(): object; - scale(factor: number): IPixelGeometry; + scale(factor: number): IPixelGeometry; - shift(offset: number[]): IPixelGeometry; - } + shift(offset: number[]): IPixelGeometry; + } - interface IPointGeometry extends IGeometry, IPointGeometryAccess { //tslint:disable-line no-empty-interface no-empty-interfaces - } + interface IPointGeometry extends IGeometry, IPointGeometryAccess { //tslint:disable-line no-empty-interface no-empty-interfaces + } - interface IPointGeometryAccess { - getCoordinates(): number[] | null; + interface IPointGeometryAccess { + getCoordinates(): number[] | null; - setCoordinates(coordinates: number[] | null): this; - } + setCoordinates(coordinates: number[] | null): this; + } - interface IPopup extends ICustomizable, IEventEmitter { - close(force?: boolean): Promise; + interface IPopup extends ICustomizable, IEventEmitter { + close(force?: boolean): Promise; - getData(): object; + getData(): object; - getOverlay(): Promise; + getOverlay(): Promise; - getOverlaySync(): IOverlay; + getOverlaySync(): IOverlay; - getPosition(): number[]; + getPosition(): number[]; - isOpen(): boolean; + isOpen(): boolean; - open(position: number[], data: object | string | HTMLElement): Promise; + open(position: number[], data: object | string | HTMLElement): Promise; - setData(data: object | string | HTMLElement): Promise; + setData(data: object | string | HTMLElement): Promise; - setPosition(position: number[]): Promise; - } + setPosition(position: number[]): Promise; + } - interface IPopupManager extends IEventEmitter { - close(force?: boolean): Promise; + interface IPopupManager extends IEventEmitter { + close(force?: boolean): Promise; - destroy(): void; + destroy(): void; - getData(): object | null; + getData(): object | null; - getOptions(): IOptionManager | null; + getOptions(): IOptionManager | null; - getOverlay(): Promise; + getOverlay(): Promise; - getOverlaySync(): IOverlay | null; + getOverlaySync(): IOverlay | null; - getPosition(): number[] | null; + getPosition(): number[] | null; - isOpen(): boolean; + isOpen(): boolean; - open(position?: number[], data?: object | string | HTMLElement, options?: object): Promise; + open(position?: number[], data?: object | string | HTMLElement, options?: object): Promise; - setData(data: object | string | HTMLElement): Promise; + setData(data: object | string | HTMLElement): Promise; - setOptions(options: object): Promise; + setOptions(options: object): Promise; - setPosition(position: number[]): Promise; - } + setPosition(position: number[]): Promise; + } - interface IPositioningContext { - fromClientPixels(clientPixelPoint: number[]): number[]; + interface IPositioningContext { + fromClientPixels(clientPixelPoint: number[]): number[]; - getZoom(): number; + getZoom(): number; - toClientPixels(globalPixelPoint: number[]): number[]; - } + toClientPixels(globalPixelPoint: number[]): number[]; + } - interface IProjection { - fromGlobalPixels(globalPixelPoint: number[], zoom: number): number[]; + interface IProjection { + fromGlobalPixels(globalPixelPoint: number[], zoom: number): number[]; - getCoordSystem(): ICoordSystem; + getCoordSystem(): ICoordSystem; - isCycled(): boolean[]; + isCycled(): boolean[]; - toGlobalPixels(coordPoint: number[], zoom: number): number[]; - } + toGlobalPixels(coordPoint: number[], zoom: number): number[]; + } - interface IRoutePanel { - options: IOptionManager; - state: IDataManager; + interface IRoutePanel { + options: IOptionManager; + state: IDataManager; - getRoute(): multiRouter.MultiRoute; + getRoute(): multiRouter.MultiRoute; - switchPoints(): void; - } + switchPoints(): void; + } - interface ISearchControlLayout extends IExpandableControlLayout { //tslint:disable-line no-empty-interface no-empty-interfaces - } + interface ISearchControlLayout extends IExpandableControlLayout { //tslint:disable-line no-empty-interface no-empty-interfaces + } - interface ISelectableControl extends IControl { - deselect(): void; + interface ISelectableControl extends IControl { + deselect(): void; - disable(): void; + disable(): void; - enable(): void; + enable(): void; - isEnabled(): boolean; + isEnabled(): boolean; - isSelected(): boolean; + isSelected(): boolean; - select(): void; - } + select(): void; + } - interface ISelectableControlLayout extends ILayout { //tslint:disable-line no-empty-interface no-empty-interfaces - } + interface ISelectableControlLayout extends ILayout { //tslint:disable-line no-empty-interface no-empty-interfaces + } - interface IShape { - contains(position: number[]): boolean; + interface IShape { + contains(position: number[]): boolean; - equals(shape: IShape): boolean; + equals(shape: IShape): boolean; - getBounds(): number[][] | null; + getBounds(): number[][] | null; - getGeometry(): IPixelGeometry; + getGeometry(): IPixelGeometry; - getType(): string; + getType(): string; - scale(factor: number): IShape; + scale(factor: number): IShape; + + shift(offset: number[]): IShape; + } + + class Monitor { + constructor(dataManager: IDataManager | IOptionManager); + add(name: string[] | string, changeCallback: (event: (object | IEvent)) => void, context?: any, params?: any): Monitor; + forceChange(): Monitor; + get(name: string): any; + remove(name: string): Monitor; + removeAll(): Monitor; + } - shift(offset: number[]): IShape; - } - - class Monitor { - constructor(dataManager: IDataManager | IOptionManager); - add(name: string[] | string, changeCallback: (event: (object | IEvent)) => void, context?: any, params?: any): Monitor; - forceChange(): Monitor; - get(name: string): any; - remove(name: string): Monitor; - removeAll(): Monitor; - } - class Polyline extends GeoObject { constructor(geometry: number[][] | object | ILineStringGeometry, properties: object | IDataManager, options?: IPolylineOptions); } - interface IPolylineOptions { - cursor?: string; + interface IPolylineOptions { + cursor?: string; [index: string]: any; } }