nativescript-mapbox/platforms/ios/Mapbox.d.ts

A Nativescript plugin for Mapbox Native Maps.

declare var MGLAbstractClassException: string;

declare class MGLAccountManager extends NSObject {

	static alloc(): MGLAccountManager; // inherited from NSObject

	static new(): MGLAccountManager; // inherited from NSObject

	static accessToken: string;
}

declare function MGLAltitudeForZoomLevel(zoomLevel: number, pitch: number, latitude: number, size: CGSize): number;

interface MGLAnnotation extends NSObjectProtocol {

	coordinate: CLLocationCoordinate2D;

	subtitle?: string;

	title?: string;
}
declare var MGLAnnotation: {

	prototype: MGLAnnotation;
};

declare class MGLAnnotationImage extends NSObject implements NSSecureCoding {

	static alloc(): MGLAnnotationImage; // inherited from NSObject

	static annotationImageWithImageReuseIdentifier(image: UIImage, reuseIdentifier: string): MGLAnnotationImage;

	static new(): MGLAnnotationImage; // inherited from NSObject

	enabled: boolean;

	image: UIImage;

	readonly reuseIdentifier: string;

	static readonly supportsSecureCoding: boolean; // inherited from NSSecureCoding

	constructor(o: { coder: NSCoder; }); // inherited from NSCoding

	encodeWithCoder(aCoder: NSCoder): void;

	initWithCoder(aDecoder: NSCoder): this;
}

declare const enum MGLAnnotationVerticalAlignment {

	Center = 0,

	Top = 1,

	Bottom = 2
}

declare class MGLAnnotationView extends UIView implements NSSecureCoding {

	static alloc(): MGLAnnotationView; // inherited from NSObject

	static appearance(): MGLAnnotationView; // inherited from UIAppearance

	static appearanceForTraitCollection(trait: UITraitCollection): MGLAnnotationView; // inherited from UIAppearance

	static appearanceForTraitCollectionWhenContainedIn(trait: UITraitCollection, ContainerClass: typeof NSObject): MGLAnnotationView; // inherited from UIAppearance

	static appearanceForTraitCollectionWhenContainedInInstancesOfClasses(trait: UITraitCollection, containerTypes: NSArray<typeof NSObject> | typeof NSObject[]): MGLAnnotationView; // inherited from UIAppearance

	static appearanceWhenContainedIn(ContainerClass: typeof NSObject): MGLAnnotationView; // inherited from UIAppearance

	static appearanceWhenContainedInInstancesOfClasses(containerTypes: NSArray<typeof NSObject> | typeof NSObject[]): MGLAnnotationView; // inherited from UIAppearance

	static new(): MGLAnnotationView; // inherited from NSObject

	annotation: MGLAnnotation;

	centerOffset: CGVector;

	readonly dragState: MGLAnnotationViewDragState;

	draggable: boolean;

	enabled: boolean;

	readonly reuseIdentifier: string;

	rotatesToMatchCamera: boolean;

	scalesWithViewingDistance: boolean;

	selected: boolean;

	static readonly supportsSecureCoding: boolean; // inherited from NSSecureCoding

	constructor(o: { annotation: MGLAnnotation; reuseIdentifier: string; });

	constructor(o: { coder: NSCoder; }); // inherited from NSCoding

	constructor(o: { reuseIdentifier: string; });

	encodeWithCoder(aCoder: NSCoder): void;

	initWithAnnotationReuseIdentifier(annotation: MGLAnnotation, reuseIdentifier: string): this;

	initWithCoder(aDecoder: NSCoder): this;

	initWithReuseIdentifier(reuseIdentifier: string): this;

	prepareForReuse(): void;

	setDragStateAnimated(dragState: MGLAnnotationViewDragState, animated: boolean): void;

	setSelectedAnimated(selected: boolean, animated: boolean): void;
}

declare const enum MGLAnnotationViewDragState {

	None = 0,

	Starting = 1,

	Dragging = 2,

	Canceling = 3,

	Ending = 4
}

declare class MGLAttributedExpression extends NSObject {

	static alloc(): MGLAttributedExpression; // inherited from NSObject

	static attributedExpressionAttributes(expression: NSExpression, attrs: NSDictionary<string, NSExpression>): MGLAttributedExpression;

	static attributedExpressionFontNamesFontScale(expression: NSExpression, fontNames: NSArray<string> | string[], fontScale: number): MGLAttributedExpression;

	static new(): MGLAttributedExpression; // inherited from NSObject

	readonly attributes: NSDictionary<string, NSExpression>;

	expression: NSExpression;

	constructor(o: { expression: NSExpression; });

	constructor(o: { expression: NSExpression; attributes: NSDictionary<string, NSExpression>; });

	initWithExpression(expression: NSExpression): this;

	initWithExpressionAttributes(expression: NSExpression, attrs: NSDictionary<string, NSExpression>): this;
}

declare class MGLAttributionInfo extends NSObject {

	static alloc(): MGLAttributionInfo; // inherited from NSObject

	static new(): MGLAttributionInfo; // inherited from NSObject

	URL: NSURL;

	feedbackLink: boolean;

	title: NSAttributedString;

	constructor(o: { title: NSAttributedString; URL: NSURL; });

	feedbackURLAtCenterCoordinateZoomLevel(centerCoordinate: CLLocationCoordinate2D, zoomLevel: number): NSURL;

	initWithTitleURL(title: NSAttributedString, URL: NSURL): this;

	titleWithStyle(style: MGLAttributionInfoStyle): NSAttributedString;
}

declare const enum MGLAttributionInfoStyle {

	Short = 1,

	Medium = 2,

	Long = 3
}

declare class MGLBackgroundStyleLayer extends MGLStyleLayer {

	static alloc(): MGLBackgroundStyleLayer; // inherited from NSObject

	static new(): MGLBackgroundStyleLayer; // inherited from NSObject

	backgroundColor: NSExpression;

	backgroundColorTransition: MGLTransition;

	backgroundOpacity: NSExpression;

	backgroundOpacityTransition: MGLTransition;

	backgroundPattern: NSExpression;

	backgroundPatternTransition: MGLTransition;

	constructor(o: { identifier: string; });

	initWithIdentifier(identifier: string): this;
}

interface MGLCalloutView extends NSObjectProtocol {

	anchoredToAnnotation?: boolean;

	delegate: MGLCalloutViewDelegate;

	dismissesAutomatically?: boolean;

	leftAccessoryView: UIView;

	representedObject: MGLAnnotation;

	rightAccessoryView: UIView;

	dismissCalloutAnimated(animated: boolean): void;

	marginInsetsHintForPresentationFromRect?(rect: CGRect): UIEdgeInsets;

	presentCalloutFromRectInViewConstrainedToRectAnimated(rect: CGRect, view: UIView, constrainedRect: CGRect, animated: boolean): void;
}
declare var MGLCalloutView: {

	prototype: MGLCalloutView;
};

interface MGLCalloutViewDelegate extends NSObjectProtocol {

	calloutViewDidAppear?(calloutView: UIView): void;

	calloutViewShouldHighlight?(calloutView: UIView): boolean;

	calloutViewTapped?(calloutView: UIView): void;

	calloutViewWillAppear?(calloutView: UIView): void;
}
declare var MGLCalloutViewDelegate: {

	prototype: MGLCalloutViewDelegate;
};

declare const enum MGLCameraChangeReason {

	None = 0,

	Programmatic = 1,

	ResetNorth = 2,

	GesturePan = 4,

	GesturePinch = 8,

	GestureRotate = 16,

	GestureZoomIn = 32,

	GestureZoomOut = 64,

	GestureOneFingerZoom = 128,

	GestureTilt = 256,

	TransitionCancelled = 65536
}

declare const enum MGLCirclePitchAlignment {

	Map = 0,

	Viewport = 1
}

declare const enum MGLCircleScaleAlignment {

	Map = 0,

	Viewport = 1
}

declare class MGLCircleStyleLayer extends MGLVectorStyleLayer {

	static alloc(): MGLCircleStyleLayer; // inherited from NSObject

	static new(): MGLCircleStyleLayer; // inherited from NSObject

	circleBlur: NSExpression;

	circleBlurTransition: MGLTransition;

	circleColor: NSExpression;

	circleColorTransition: MGLTransition;

	circleOpacity: NSExpression;

	circleOpacityTransition: MGLTransition;

	circlePitchAlignment: NSExpression;

	circleRadius: NSExpression;

	circleRadiusTransition: MGLTransition;

	circleScaleAlignment: NSExpression;

	circleStrokeColor: NSExpression;

	circleStrokeColorTransition: MGLTransition;

	circleStrokeOpacity: NSExpression;

	circleStrokeOpacityTransition: MGLTransition;

	circleStrokeWidth: NSExpression;

	circleStrokeWidthTransition: MGLTransition;

	circleTranslation: NSExpression;

	circleTranslationAnchor: NSExpression;

	circleTranslationTransition: MGLTransition;

	constructor(o: { identifier: string; source: MGLSource; });

	initWithIdentifierSource(identifier: string, source: MGLSource): this;
}

declare const enum MGLCircleTranslationAnchor {

	Map = 0,

	Viewport = 1
}

declare class MGLClockDirectionFormatter extends NSFormatter {

	static alloc(): MGLClockDirectionFormatter; // inherited from NSObject

	static new(): MGLClockDirectionFormatter; // inherited from NSObject

	unitStyle: NSFormattingUnitStyle;

	stringFromDirection(direction: number): string;
}

interface MGLCluster extends MGLFeature {

	clusterIdentifier: number;

	clusterPointCount: number;
}
declare var MGLCluster: {

	prototype: MGLCluster;
};

declare var MGLClusterIdentifierInvalid: number;

declare class MGLCompassDirectionFormatter extends NSFormatter {

	static alloc(): MGLCompassDirectionFormatter; // inherited from NSObject

	static new(): MGLCompassDirectionFormatter; // inherited from NSObject

	unitStyle: NSFormattingUnitStyle;

	stringFromDirection(direction: number): string;
}

declare class MGLComputedShapeSource extends MGLSource {

	static alloc(): MGLComputedShapeSource; // inherited from NSObject

	static new(): MGLComputedShapeSource; // inherited from NSObject

	dataSource: MGLComputedShapeSourceDataSource;

	readonly requestQueue: NSOperationQueue;

	constructor(o: { identifier: string; dataSource: MGLComputedShapeSourceDataSource; options: NSDictionary<string, any>; });

	constructor(o: { identifier: string; options: NSDictionary<string, any>; });

	initWithIdentifierDataSourceOptions(identifier: string, dataSource: MGLComputedShapeSourceDataSource, options: NSDictionary<string, any>): this;

	initWithIdentifierOptions(identifier: string, options: NSDictionary<string, any>): this;

	invalidateBounds(bounds: MGLCoordinateBounds): void;

	invalidateTileAtXYZoomLevel(x: number, y: number, zoomLevel: number): void;

	setFeaturesInTileAtXYZoomLevel(features: NSArray<MGLShape> | MGLShape[], x: number, y: number, zoomLevel: number): void;
}

interface MGLComputedShapeSourceDataSource extends NSObjectProtocol {

	featuresInCoordinateBoundsZoomLevel?(bounds: MGLCoordinateBounds, zoomLevel: number): NSArray<MGLShape>;

	featuresInTileAtXYZoomLevel?(x: number, y: number, zoomLevel: number): NSArray<MGLShape>;
}
declare var MGLComputedShapeSourceDataSource: {

	prototype: MGLComputedShapeSourceDataSource;
};

interface MGLCoordinateBounds {
	sw: CLLocationCoordinate2D;
	ne: CLLocationCoordinate2D;
}
declare var MGLCoordinateBounds: interop.StructType<MGLCoordinateBounds>;

declare class MGLCoordinateFormatter extends NSFormatter {

	static alloc(): MGLCoordinateFormatter; // inherited from NSObject

	static new(): MGLCoordinateFormatter; // inherited from NSObject

	allowsMinutes: boolean;

	allowsSeconds: boolean;

	unitStyle: NSFormattingUnitStyle;

	stringFromCoordinate(coordinate: CLLocationCoordinate2D): string;
}

interface MGLCoordinateQuad {
	topLeft: CLLocationCoordinate2D;
	bottomLeft: CLLocationCoordinate2D;
	bottomRight: CLLocationCoordinate2D;
	topRight: CLLocationCoordinate2D;
}
declare var MGLCoordinateQuad: interop.StructType<MGLCoordinateQuad>;

interface MGLCoordinateSpan {
	latitudeDelta: number;
	longitudeDelta: number;
}
declare var MGLCoordinateSpan: interop.StructType<MGLCoordinateSpan>;

declare var MGLCoordinateSpanZero: MGLCoordinateSpan;

declare const enum MGLDEMEncoding {

	Mapbox = 0,

	Terrarium = 1
}

declare class MGLDistanceFormatter extends NSLengthFormatter {

	static alloc(): MGLDistanceFormatter; // inherited from NSObject

	static new(): MGLDistanceFormatter; // inherited from NSObject

	stringFromDistance(distance: number): string;
}

declare class MGLEmptyFeature extends MGLShape implements MGLFeature {

	static alloc(): MGLEmptyFeature; // inherited from NSObject

	static new(): MGLEmptyFeature; // inherited from NSObject

	attributes: NSDictionary<string, any>; // inherited from MGLFeature

	readonly coordinate: CLLocationCoordinate2D; // inherited from MGLAnnotation

	readonly debugDescription: string; // inherited from NSObjectProtocol

	readonly description: string; // inherited from NSObjectProtocol

	readonly hash: number; // inherited from NSObjectProtocol

	identifier: any; // inherited from MGLFeature

	readonly isProxy: boolean; // inherited from NSObjectProtocol

	readonly subtitle: string; // inherited from MGLAnnotation

	readonly superclass: typeof NSObject; // inherited from NSObjectProtocol

	readonly title: string; // inherited from MGLAnnotation

	readonly  // inherited from NSObjectProtocol

	attributeForKey(key: string): any;

	class(): typeof NSObject;

	conformsToProtocol(aProtocol: any /* Protocol */): boolean;

	geoJSONDictionary(): NSDictionary<string, any>;

	isEqual(object: any): boolean;

	isKindOfClass(aClass: typeof NSObject): boolean;

	isMemberOfClass(aClass: typeof NSObject): boolean;

	performSelector(aSelector: string): any;

	performSelectorWithObject(aSelector: string, object: any): any;

	performSelectorWithObjectWithObject(aSelector: string, object1: any, object2: any): any;

	respondsToSelector(aSelector: string): boolean;

	retainCount(): number;

	self(): this;
}

declare const enum MGLErrorCode {

	Unknown = -1,

	NotFound = 1,

	BadServerResponse = 2,

	ConnectionFailed = 3,

	ParseStyleFailed = 4,

	LoadStyleFailed = 5,

	SnapshotFailed = 6,

	SourceIsInUseCannotRemove = 7,

	SourceIdentifierMismatch = 8
}

declare var MGLErrorDomain: string;

declare var MGLExpressionInterpolationModeCubicBezier: string;

declare var MGLExpressionInterpolationModeExponential: string;

declare var MGLExpressionInterpolationModeLinear: string;

interface MGLFeature extends MGLAnnotation {

	attributes: NSDictionary<string, any>;

	identifier: any;

	attributeForKey(key: string): any;

	geoJSONDictionary(): NSDictionary<string, any>;
}
declare var MGLFeature: {

	prototype: MGLFeature;
};

declare class MGLFillExtrusionStyleLayer extends MGLVectorStyleLayer {

	static alloc(): MGLFillExtrusionStyleLayer; // inherited from NSObject

	static new(): MGLFillExtrusionStyleLayer; // inherited from NSObject

	fillExtrusionBase: NSExpression;

	fillExtrusionBaseTransition: MGLTransition;

	fillExtrusionColor: NSExpression;

	fillExtrusionColorTransition: MGLTransition;

	fillExtrusionHasVerticalGradient: NSExpression;

	fillExtrusionHeight: NSExpression;

	fillExtrusionHeightTransition: MGLTransition;

	fillExtrusionOpacity: NSExpression;

	fillExtrusionOpacityTransition: MGLTransition;

	fillExtrusionPattern: NSExpression;

	fillExtrusionPatternTransition: MGLTransition;

	fillExtrusionTranslation: NSExpression;

	fillExtrusionTranslationAnchor: NSExpression;

	fillExtrusionTranslationTransition: MGLTransition;

	constructor(o: { identifier: string; source: MGLSource; });

	initWithIdentifierSource(identifier: string, source: MGLSource): this;
}

declare const enum MGLFillExtrusionTranslationAnchor {

	Map = 0,

	Viewport = 1
}

declare class MGLFillStyleLayer extends MGLVectorStyleLayer {

	static alloc(): MGLFillStyleLayer; // inherited from NSObject

	static new(): MGLFillStyleLayer; // inherited from NSObject

	fillAntialiased: NSExpression;

	fillColor: NSExpression;

	fillColorTransition: MGLTransition;

	fillOpacity: NSExpression;

	fillOpacityTransition: MGLTransition;

	fillOutlineColor: NSExpression;

	fillOutlineColorTransition: MGLTransition;

	fillPattern: NSExpression;

	fillPatternTransition: MGLTransition;

	fillTranslation: NSExpression;

	fillTranslationAnchor: NSExpression;

	fillTranslationTransition: MGLTransition;

	constructor(o: { identifier: string; source: MGLSource; });

	initWithIdentifierSource(identifier: string, source: MGLSource): this;
}

declare const enum MGLFillTranslationAnchor {

	Map = 0,

	Viewport = 1
}

declare var MGLFontColorAttribute: string;

declare var MGLFontNamesAttribute: string;

declare var MGLFontScaleAttribute: string;

declare class MGLForegroundStyleLayer extends MGLStyleLayer {

	static alloc(): MGLForegroundStyleLayer; // inherited from NSObject

	static new(): MGLForegroundStyleLayer; // inherited from NSObject

	readonly sourceIdentifier: string;
}

declare class MGLHeatmapStyleLayer extends MGLVectorStyleLayer {

	static alloc(): MGLHeatmapStyleLayer; // inherited from NSObject

	static new(): MGLHeatmapStyleLayer; // inherited from NSObject

	heatmapColor: NSExpression;

	heatmapIntensity: NSExpression;

	heatmapIntensityTransition: MGLTransition;

	heatmapOpacity: NSExpression;

	heatmapOpacityTransition: MGLTransition;

	heatmapRadius: NSExpression;

	heatmapRadiusTransition: MGLTransition;

	heatmapWeight: NSExpression;

	constructor(o: { identifier: string; source: MGLSource; });

	initWithIdentifierSource(identifier: string, source: MGLSource): this;
}

declare const enum MGLHillshadeIlluminationAnchor {

	Map = 0,

	Viewport = 1
}

declare class MGLHillshadeStyleLayer extends MGLForegroundStyleLayer {

	static alloc(): MGLHillshadeStyleLayer; // inherited from NSObject

	static new(): MGLHillshadeStyleLayer; // inherited from NSObject

	hillshadeAccentColor: NSExpression;

	hillshadeAccentColorTransition: MGLTransition;

	hillshadeExaggeration: NSExpression;

	hillshadeExaggerationTransition: MGLTransition;

	hillshadeHighlightColor: NSExpression;

	hillshadeHighlightColorTransition: MGLTransition;

	hillshadeIlluminationAnchor: NSExpression;

	hillshadeIlluminationDirection: NSExpression;

	hillshadeShadowColor: NSExpression;

	hillshadeShadowColorTransition: MGLTransition;

	constructor(o: { identifier: string; source: MGLSource; });

	initWithIdentifierSource(identifier: string, source: MGLSource): this;
}

declare const enum MGLIconAnchor {

	Center = 0,

	Left = 1,

	Right = 2,

	Top = 3,

	Bottom = 4,

	TopLeft = 5,

	TopRight = 6,

	BottomLeft = 7,

	BottomRight = 8
}

declare const enum MGLIconPitchAlignment {

	Map = 0,

	Viewport = 1,

	Auto = 2
}

declare const enum MGLIconRotationAlignment {

	Map = 0,

	Viewport = 1,

	Auto = 2
}

declare const enum MGLIconTextFit {

	None = 0,

	Width = 1,

	Height = 2,

	Both = 3
}

declare const enum MGLIconTranslationAnchor {

	Map = 0,

	Viewport = 1
}

declare class MGLImageSource extends MGLSource {

	static alloc(): MGLImageSource; // inherited from NSObject

	static new(): MGLImageSource; // inherited from NSObject

	URL: NSURL;

	coordinates: MGLCoordinateQuad;

	image: UIImage;

	constructor(o: { identifier: string; coordinateQuad: MGLCoordinateQuad; image: UIImage; });

	constructor(o: { identifier: string; coordinateQuad: MGLCoordinateQuad; URL: NSURL; });

	initWithIdentifierCoordinateQuadImage(identifier: string, coordinateQuad: MGLCoordinateQuad, image: UIImage): this;

	initWithIdentifierCoordinateQuadURL(identifier: string, coordinateQuad: MGLCoordinateQuad, url: NSURL): this;
}

declare var MGLInvalidDatasourceException: string;

declare var MGLInvalidOfflinePackException: string;

declare var MGLInvalidStyleLayerException: string;

declare var MGLInvalidStyleURLException: string;

declare class MGLLight extends NSObject {

	static alloc(): MGLLight; // inherited from NSObject

	static new(): MGLLight; // inherited from NSObject

	anchor: NSExpression;

	color: NSExpression;

	colorTransition: MGLTransition;

	intensity: NSExpression;

	intensityTransition: MGLTransition;

	position: NSExpression;

	positionTransition: MGLTransition;
}

declare const enum MGLLightAnchor {

	Map = 0,

	Viewport = 1
}

declare const enum MGLLineCap {

	Butt = 0,

	Round = 1,

	Square = 2
}

declare const enum MGLLineJoin {

	Bevel = 0,

	Round = 1,

	Miter = 2
}

declare class MGLLineStyleLayer extends MGLVectorStyleLayer {

	static alloc(): MGLLineStyleLayer; // inherited from NSObject

	static new(): MGLLineStyleLayer; // inherited from NSObject

	lineBlur: NSExpression;

	lineBlurTransition: MGLTransition;

	lineCap: NSExpression;

	lineColor: NSExpression;

	lineColorTransition: MGLTransition;

	lineDashPattern: NSExpression;

	lineDashPatternTransition: MGLTransition;

	lineGapWidth: NSExpression;

	lineGapWidthTransition: MGLTransition;

	lineGradient: NSExpression;

	lineJoin: NSExpression;

	lineMiterLimit: NSExpression;

	lineOffset: NSExpression;

	lineOffsetTransition: MGLTransition;

	lineOpacity: NSExpression;

	lineOpacityTransition: MGLTransition;

	linePattern: NSExpression;

	linePatternTransition: MGLTransition;

	lineRoundLimit: NSExpression;

	lineTranslation: NSExpression;

	lineTranslationAnchor: NSExpression;

	lineTranslationTransition: MGLTransition;

	lineWidth: NSExpression;

	lineWidthTransition: MGLTransition;

	constructor(o: { identifier: string; source: MGLSource; });

	initWithIdentifierSource(identifier: string, source: MGLSource): this;
}

declare const enum MGLLineTranslationAnchor {

	Map = 0,

	Viewport = 1
}

interface MGLLocationManager extends NSObjectProtocol {

	authorizationStatus: CLAuthorizationStatus;

	delegate: MGLLocationManagerDelegate;

	headingOrientation: CLDeviceOrientation;

	activityType?(): CLActivityType;

	desiredAccuracy?(): number;

	dismissHeadingCalibrationDisplay(): void;

	distanceFilter?(): number;

	requestAlwaysAuthorization(): void;

	requestWhenInUseAuthorization(): void;

	setActivityType?(activityType: CLActivityType): void;

	setDesiredAccuracy?(desiredAccuracy: number): void;

	setDistanceFilter?(distanceFilter: number): void;

	startUpdatingHeading(): void;

	startUpdatingLocation(): void;

	stopUpdatingHeading(): void;

	stopUpdatingLocation(): void;
}
declare var MGLLocationManager: {

	prototype: MGLLocationManager;
};

interface MGLLocationManagerDelegate extends NSObjectProtocol {

	locationManagerDidFailWithError(manager: MGLLocationManager, error: NSError): void;

	locationManagerDidUpdateHeading(manager: MGLLocationManager, newHeading: CLHeading): void;

	locationManagerDidUpdateLocations(manager: MGLLocationManager, locations: NSArray<CLLocation> | CLLocation[]): void;

	locationManagerShouldDisplayHeadingCalibration(manager: MGLLocationManager): boolean;
}
declare var MGLLocationManagerDelegate: {

	prototype: MGLLocationManagerDelegate;
};

declare class MGLLoggingConfiguration extends NSObject {

	static alloc(): MGLLoggingConfiguration; // inherited from NSObject

	static new(): MGLLoggingConfiguration; // inherited from NSObject

	loggingLevel: MGLLoggingLevel;

	static readonly sharedConfiguration: MGLLoggingConfiguration;
}

declare const enum MGLLoggingLevel {

	None = 0,

	Info = 1,

	Debug = 2,

	Error = 3,

	Fault = 4
}

declare class MGLMapCamera extends NSObject implements NSCopying, NSSecureCoding {

	static alloc(): MGLMapCamera; // inherited from NSObject

	static camera(): MGLMapCamera;

	static cameraLookingAtCenterCoordinateAcrossDistancePitchHeading(centerCoordinate: CLLocationCoordinate2D, distance: number, pitch: number, heading: number): MGLMapCamera;

	static cameraLookingAtCenterCoordinateAltitudePitchHeading(centerCoordinate: CLLocationCoordinate2D, altitude: number, pitch: number, heading: number): MGLMapCamera;

	static cameraLookingAtCenterCoordinateFromDistancePitchHeading(centerCoordinate: CLLocationCoordinate2D, distance: number, pitch: number, heading: number): MGLMapCamera;

	static cameraLookingAtCenterCoordinateFromEyeCoordinateEyeAltitude(centerCoordinate: CLLocationCoordinate2D, eyeCoordinate: CLLocationCoordinate2D, eyeAltitude: number): MGLMapCamera;

	static new(): MGLMapCamera; // inherited from NSObject

	altitude: number;

	centerCoordinate: CLLocationCoordinate2D;

	heading: number;

	pitch: number;

	viewingDistance: number;

	static readonly supportsSecureCoding: boolean; // inherited from NSSecureCoding

	constructor(o: { coder: NSCoder; }); // inherited from NSCoding

	copyWithZone(zone: interop.Pointer | interop.Reference<any>): any;

	encodeWithCoder(aCoder: NSCoder): void;

	initWithCoder(aDecoder: NSCoder): this;

	isEqualToMapCamera(otherCamera: MGLMapCamera): boolean;
}

declare const enum MGLMapDebugMaskOptions {

	TileBoundariesMask = 2,

	TileInfoMask = 4,

	TimestampsMask = 8,

	CollisionBoxesMask = 16,

	OverdrawVisualizationMask = 32
}

interface MGLMapPoint {
	x: number;
	y: number;
	zoomLevel: number;
}
declare var MGLMapPoint: interop.StructType<MGLMapPoint>;

declare function MGLMapPointForCoordinate(coordinate: CLLocationCoordinate2D, zoomLevel: number): MGLMapPoint;

declare class MGLMapSnapshot extends NSObject {

	static alloc(): MGLMapSnapshot; // inherited from NSObject

	static new(): MGLMapSnapshot; // inherited from NSObject

	readonly image: UIImage;

	coordinateForPoint(point: CGPoint): CLLocationCoordinate2D;

	pointForCoordinate(coordinate: CLLocationCoordinate2D): CGPoint;
}

declare class MGLMapSnapshotOptions extends NSObject {

	static alloc(): MGLMapSnapshotOptions; // inherited from NSObject

	static new(): MGLMapSnapshotOptions; // inherited from NSObject

	camera: MGLMapCamera;

	coordinateBounds: MGLCoordinateBounds;

	scale: number;

	readonly size: CGSize;

	readonly styleURL: NSURL;

	zoomLevel: number;

	constructor(o: { styleURL: NSURL; camera: MGLMapCamera; size: CGSize; });

	initWithStyleURLCameraSize(styleURL: NSURL, camera: MGLMapCamera, size: CGSize): this;
}

declare class MGLMapSnapshotter extends NSObject {

	static alloc(): MGLMapSnapshotter; // inherited from NSObject

	static new(): MGLMapSnapshotter; // inherited from NSObject

	readonly loading: boolean;

	options: MGLMapSnapshotOptions;

	constructor(o: { options: MGLMapSnapshotOptions; });

	cancel(): void;

	initWithOptions(options: MGLMapSnapshotOptions): this;

	startWithCompletionHandler(completionHandler: (p1: MGLMapSnapshot, p2: NSError) => void): void;

	startWithQueueCompletionHandler(queue: NSObject, completionHandler: (p1: MGLMapSnapshot, p2: NSError) => void): void;
}

declare class MGLMapView extends UIView {

	static alloc(): MGLMapView; // inherited from NSObject

	static appearance(): MGLMapView; // inherited from UIAppearance

	static appearanceForTraitCollection(trait: UITraitCollection): MGLMapView; // inherited from UIAppearance

	static appearanceForTraitCollectionWhenContainedIn(trait: UITraitCollection, ContainerClass: typeof NSObject): MGLMapView; // inherited from UIAppearance

	static appearanceForTraitCollectionWhenContainedInInstancesOfClasses(trait: UITraitCollection, containerTypes: NSArray<typeof NSObject> | typeof NSObject[]): MGLMapView; // inherited from UIAppearance

	static appearanceWhenContainedIn(ContainerClass: typeof NSObject): MGLMapView; // inherited from UIAppearance

	static appearanceWhenContainedInInstancesOfClasses(containerTypes: NSArray<typeof NSObject> | typeof NSObject[]): MGLMapView; // inherited from UIAppearance

	static new(): MGLMapView; // inherited from NSObject

	allowsRotating: boolean;

	allowsScrolling: boolean;

	allowsTilting: boolean;

	allowsZooming: boolean;

	readonly annotations: NSArray<MGLAnnotation>;

	readonly attributionButton: UIButton;

	attributionButtonMargins: CGPoint;

	attributionButtonPosition: MGLOrnamentPosition;

	camera: MGLMapCamera;

	centerCoordinate: CLLocationCoordinate2D;

	readonly compassView: UIImageView;

	compassViewMargins: CGPoint;

	compassViewPosition: MGLOrnamentPosition;

	contentInset: UIEdgeInsets;

	debugMask: MGLMapDebugMaskOptions;

	decelerationRate: number;

	delegate: MGLMapViewDelegate;

	direction: number;

	displayHeadingCalibration: boolean;

	hapticFeedbackEnabled: boolean;

	latitude: number;

	locationManager: MGLLocationManager;

	readonly logoView: UIImageView;

	logoViewMargins: CGPoint;

	logoViewPosition: MGLOrnamentPosition;

	longitude: number;

	maximumZoomLevel: number;

	minimumZoomLevel: number;

	readonly overlays: NSArray<MGLOverlay>;

	pitchEnabled: boolean;

	preferredFramesPerSecond: number;

	prefetchesTiles: boolean;

	rotateEnabled: boolean;

	readonly scaleBar: UIView;

	scaleBarMargins: CGPoint;

	scaleBarPosition: MGLOrnamentPosition;

	scrollEnabled: boolean;

	selectedAnnotations: NSArray<MGLAnnotation>;

	showsHeading: boolean;

	showsScale: boolean;

	showsUserHeadingIndicator: boolean;

	showsUserLocation: boolean;

	readonly style: MGLStyle;

	styleURL: NSURL;

	targetCoordinate: CLLocationCoordinate2D;

	readonly userLocation: MGLUserLocation;

	userLocationVerticalAlignment: MGLAnnotationVerticalAlignment;

	readonly userLocationVisible: boolean;

	userTrackingMode: MGLUserTrackingMode;

	readonly visibleAnnotations: NSArray<MGLAnnotation>;

	visibleCoordinateBounds: MGLCoordinateBounds;

	zoomEnabled: boolean;

	zoomLevel: number;

	constructor(o: { frame: CGRect; styleURL: NSURL; });

	addAnnotation(annotation: MGLAnnotation): void;

	addAnnotations(annotations: NSArray<MGLAnnotation> | MGLAnnotation[]): void;

	addOverlay(overlay: MGLOverlay): void;

	addOverlays(overlays: NSArray<MGLOverlay> | MGLOverlay[]): void;

	anchorPointForGesture(gesture: UIGestureRecognizer): CGPoint;

	cameraFittingCoordinateBoundsEdgePadding(camera: MGLMapCamera, bounds: MGLCoordinateBounds, insets: UIEdgeInsets): MGLMapCamera;

	cameraFittingShapeEdgePadding(camera: MGLMapCamera, shape: MGLShape, insets: UIEdgeInsets): MGLMapCamera;

	cameraThatFitsCoordinateBounds(bounds: MGLCoordinateBounds): MGLMapCamera;

	cameraThatFitsCoordinateBoundsEdgePadding(bounds: MGLCoordinateBounds, insets: UIEdgeInsets): MGLMapCamera;

	cameraThatFitsShapeDirectionEdgePadding(shape: MGLShape, direction: number, insets: UIEdgeInsets): MGLMapCamera;

	convertCoordinateBoundsToRectToView(bounds: MGLCoordinateBounds, view: UIView): CGRect;

	convertCoordinateToPointToView(coordinate: CLLocationCoordinate2D, view: UIView): CGPoint;

	convertPointToCoordinateFromView(point: CGPoint, view: UIView): CLLocationCoordinate2D;

	convertRectToCoordinateBoundsFromView(rect: CGRect, view: UIView): MGLCoordinateBounds;

	dequeueReusableAnnotationImageWithIdentifier(identifier: string): MGLAnnotationImage;

	dequeueReusableAnnotationViewWithIdentifier(identifier: string): MGLAnnotationView;

	deselectAnnotationAnimated(annotation: MGLAnnotation, animated: boolean): void;

	flyToCameraCompletionHandler(camera: MGLMapCamera, completion: () => void): void;

	flyToCameraWithDurationCompletionHandler(camera: MGLMapCamera, duration: number, completion: () => void): void;

	flyToCameraWithDurationPeakAltitudeCompletionHandler(camera: MGLMapCamera, duration: number, peakAltitude: number, completion: () => void): void;

	initWithFrameStyleURL(frame: CGRect, styleURL: NSURL): this;

	metersPerPointAtLatitude(latitude: number): number;

	reloadStyle(sender: any): void;

	removeAnnotation(annotation: MGLAnnotation): void;

	removeAnnotations(annotations: NSArray<MGLAnnotation> | MGLAnnotation[]): void;

	removeOverlay(overlay: MGLOverlay): void;

	removeOverlays(overlays: NSArray<MGLOverlay> | MGLOverlay[]): void;

	resetNorth(): void;

	resetPosition(): void;

	selectAnnotationAnimated(annotation: MGLAnnotation, animated: boolean): void;

	selectAnnotationMoveIntoViewAnimateSelection(annotation: MGLAnnotation, moveIntoView: boolean, animateSelection: boolean): void;

	setCameraAnimated(camera: MGLMapCamera, animated: boolean): void;

	setCameraWithDurationAnimationTimingFunction(camera: MGLMapCamera, duration: number, _function: CAMediaTimingFunction): void;

	setCameraWithDurationAnimationTimingFunctionCompletionHandler(camera: MGLMapCamera, duration: number, _function: CAMediaTimingFunction, completion: () => void): void;

	setCameraWithDurationAnimationTimingFunctionEdgePaddingCompletionHandler(camera: MGLMapCamera, duration: number, _function: CAMediaTimingFunction, edgePadding: UIEdgeInsets, completion: () => void): void;

	setCenterCoordinateAnimated(coordinate: CLLocationCoordinate2D, animated: boolean): void;

	setCenterCoordinateZoomLevelAnimated(centerCoordinate: CLLocationCoordinate2D, zoomLevel: number, animated: boolean): void;

	setCenterCoordinateZoomLevelDirectionAnimated(centerCoordinate: CLLocationCoordinate2D, zoomLevel: number, direction: number, animated: boolean): void;

	setCenterCoordinateZoomLevelDirectionAnimatedCompletionHandler(centerCoordinate: CLLocationCoordinate2D, zoomLevel: number, direction: number, animated: boolean, completion: () => void): void;

	setContentInsetAnimated(contentInset: UIEdgeInsets, animated: boolean): void;

	setDirectionAnimated(direction: number, animated: boolean): void;

	setTargetCoordinateAnimated(targetCoordinate: CLLocationCoordinate2D, animated: boolean): void;

	setUserLocationVerticalAlignmentAnimated(alignment: MGLAnnotationVerticalAlignment, animated: boolean): void;

	setUserTrackingModeAnimated(mode: MGLUserTrackingMode, animated: boolean): void;

	setVisibleCoordinateBoundsAnimated(bounds: MGLCoordinateBounds, animated: boolean): void;

	setVisibleCoordinateBoundsEdgePaddingAnimated(bounds: MGLCoordinateBounds, insets: UIEdgeInsets, animated: boolean): void;

	setVisibleCoordinatesCountEdgePaddingAnimated(coordinates: interop.Pointer | interop.Reference<CLLocationCoordinate2D>, count: number, insets: UIEdgeInsets, animated: boolean): void;

	setVisibleCoordinatesCountEdgePaddingDirectionDurationAnimationTimingFunctionCompletionHandler(coordinates: interop.Pointer | interop.Reference<CLLocationCoordinate2D>, count: number, insets: UIEdgeInsets, direction: number, duration: number, _function: CAMediaTimingFunction, completion: () => void): void;

	setZoomLevelAnimated(zoomLevel: number, animated: boolean): void;

	showAnnotationsAnimated(annotations: NSArray<MGLAnnotation> | MGLAnnotation[], animated: boolean): void;

	showAnnotationsEdgePaddingAnimated(annotations: NSArray<MGLAnnotation> | MGLAnnotation[], insets: UIEdgeInsets, animated: boolean): void;

	showAttribution(sender: any): void;

	updateUserLocationAnnotationView(): void;

	updateUserLocationAnnotationViewAnimatedWithDuration(duration: number): void;

	viewForAnnotation(annotation: MGLAnnotation): MGLAnnotationView;

	visibleAnnotationsInRect(rect: CGRect): NSArray<MGLAnnotation>;

	visibleFeaturesAtPoint(point: CGPoint): NSArray<MGLFeature>;

	visibleFeaturesAtPointInStyleLayersWithIdentifiers(point: CGPoint, styleLayerIdentifiers: NSSet<string>): NSArray<MGLFeature>;

	visibleFeaturesAtPointInStyleLayersWithIdentifiersPredicate(point: CGPoint, styleLayerIdentifiers: NSSet<string>, predicate: NSPredicate): NSArray<MGLFeature>;

	visibleFeaturesInRect(rect: CGRect): NSArray<MGLFeature>;

	visibleFeaturesInRectInStyleLayersWithIdentifiers(rect: CGRect, styleLayerIdentifiers: NSSet<string>): NSArray<MGLFeature>;

	visibleFeaturesInRectInStyleLayersWithIdentifiersPredicate(rect: CGRect, styleLayerIdentifiers: NSSet<string>, predicate: NSPredicate): NSArray<MGLFeature>;
}

declare var MGLMapViewDecelerationRateFast: number;

declare var MGLMapViewDecelerationRateImmediate: number;

declare var MGLMapViewDecelerationRateNormal: number;

interface MGLMapViewDelegate extends NSObjectProtocol {

	mapViewAlphaForShapeAnnotation?(mapView: MGLMapView, annotation: MGLShape): number;

	mapViewAnnotationCalloutAccessoryControlTapped?(mapView: MGLMapView, annotation: MGLAnnotation, control: UIControl): void;

	mapViewAnnotationCanShowCallout?(mapView: MGLMapView, annotation: MGLAnnotation): boolean;

	mapViewCalloutViewForAnnotation?(mapView: MGLMapView, annotation: MGLAnnotation): MGLCalloutView;

	mapViewDidAddAnnotationViews?(mapView: MGLMapView, annotationViews: NSArray<MGLAnnotationView> | MGLAnnotationView[]): void;

	mapViewDidBecomeIdle?(mapView: MGLMapView): void;

	mapViewDidChangeUserTrackingModeAnimated?(mapView: MGLMapView, mode: MGLUserTrackingMode, animated: boolean): void;

	mapViewDidDeselectAnnotation?(mapView: MGLMapView, annotation: MGLAnnotation): void;

	mapViewDidDeselectAnnotationView?(mapView: MGLMapView, annotationView: MGLAnnotationView): void;

	mapViewDidFailLoadingMapWithError?(mapView: MGLMapView, error: NSError): void;

	mapViewDidFailToLoadImage?(mapView: MGLMapView, imageName: string): UIImage;

	mapViewDidFailToLocateUserWithError?(mapView: MGLMapView, error: NSError): void;

	mapViewDidFinishLoadingMap?(mapView: MGLMapView): void;

	mapViewDidFinishLoadingStyle?(mapView: MGLMapView, style: MGLStyle): void;

	mapViewDidFinishRenderingFrameFullyRendered?(mapView: MGLMapView, fullyRendered: boolean): void;

	mapViewDidFinishRenderingMapFullyRendered?(mapView: MGLMapView, fullyRendered: boolean): void;

	mapViewDidSelectAnnotation?(mapView: MGLMapView, annotation: MGLAnnotation): void;

	mapViewDidSelectAnnotationView?(mapView: MGLMapView, annotationView: MGLAnnotationView): void;

	mapViewDidStopLocatingUser?(mapView: MGLMapView): void;

	mapViewDidUpdateUserLocation?(mapView: MGLMapView, userLocation: MGLUserLocation): void;

	mapViewFillColorForPolygonAnnotation?(mapView: MGLMapView, annotation: MGLPolygon): UIColor;

	mapViewImageForAnnotation?(mapView: MGLMapView, annotation: MGLAnnotation): MGLAnnotationImage;

	mapViewLeftCalloutAccessoryViewForAnnotation?(mapView: MGLMapView, annotation: MGLAnnotation): UIView;

	mapViewLineWidthForPolylineAnnotation?(mapView: MGLMapView, annotation: MGLPolyline): number;

	mapViewRegionDidChangeAnimated?(mapView: MGLMapView, animated: boolean): void;

	mapViewRegionDidChangeWithReasonAnimated?(mapView: MGLMapView, reason: MGLCameraChangeReason, animated: boolean): void;

	mapViewRegionIsChanging?(mapView: MGLMapView): void;

	mapViewRegionIsChangingWithReason?(mapView: MGLMapView, reason: MGLCameraChangeReason): void;

	mapViewRegionWillChangeAnimated?(mapView: MGLMapView, animated: boolean): void;

	mapViewRegionWillChangeWithReasonAnimated?(mapView: MGLMapView, reason: MGLCameraChangeReason, animated: boolean): void;

	mapViewRightCalloutAccessoryViewForAnnotation?(mapView: MGLMapView, annotation: MGLAnnotation): UIView;

	mapViewShapeAnnotationIsEnabled?(mapView: MGLMapView, annotation: MGLShape): boolean;

	mapViewShouldChangeFromCameraToCamera?(mapView: MGLMapView, oldCamera: MGLMapCamera, newCamera: MGLMapCamera): boolean;

	mapViewShouldChangeFromCameraToCameraReason?(mapView: MGLMapView, oldCamera: MGLMapCamera, newCamera: MGLMapCamera, reason: MGLCameraChangeReason): boolean;

	mapViewStrokeColorForShapeAnnotation?(mapView: MGLMapView, annotation: MGLShape): UIColor;

	mapViewTapOnCalloutForAnnotation?(mapView: MGLMapView, annotation: MGLAnnotation): void;

	mapViewUserLocationAnchorPoint?(mapView: MGLMapView): CGPoint;

	mapViewViewForAnnotation?(mapView: MGLMapView, annotation: MGLAnnotation): MGLAnnotationView;

	mapViewWillStartLoadingMap?(mapView: MGLMapView): void;

	mapViewWillStartLocatingUser?(mapView: MGLMapView): void;

	mapViewWillStartRenderingFrame?(mapView: MGLMapView): void;

	mapViewWillStartRenderingMap?(mapView: MGLMapView): void;
}
declare var MGLMapViewDelegate: {

	prototype: MGLMapViewDelegate;
};

declare var MGLMapViewPreferredFramesPerSecondDefault: number;

declare var MGLMapViewPreferredFramesPerSecondLowPower: number;

declare var MGLMapViewPreferredFramesPerSecondMaximum: number;

interface MGLMatrix4 {
	m00: number;
	m01: number;
	m02: number;
	m03: number;
	m10: number;
	m11: number;
	m12: number;
	m13: number;
	m20: number;
	m21: number;
	m22: number;
	m23: number;
	m30: number;
	m31: number;
	m32: number;
	m33: number;
}
declare var MGLMatrix4: interop.StructType<MGLMatrix4>;

declare const enum MGLMetricType {

	Performance = 0
}

declare class MGLMetricsManager extends NSObject {

	static alloc(): MGLMetricsManager; // inherited from NSObject

	static new(): MGLMetricsManager; // inherited from NSObject

	delegate: MGLMetricsManagerDelegate;

	static readonly sharedManager: MGLMetricsManager;

	pushMetricWithAttributes(metricType: MGLMetricType, attributes: NSDictionary<any, any>): void;
}

interface MGLMetricsManagerDelegate extends NSObjectProtocol {

	metricsManagerDidCollectMetricWithAttributes(metricsManager: MGLMetricsManager, metricType: MGLMetricType, attributes: NSDictionary<any, any>): void;

	metricsManagerShouldHandleMetric(metricsManager: MGLMetricsManager, metricType: MGLMetricType): boolean;
}
declare var MGLMetricsManagerDelegate: {

	prototype: MGLMetricsManagerDelegate;
};

declare var MGLMissingLocationServicesUsageDescriptionException: string;

declare class MGLMultiPoint extends MGLShape {

	static alloc(): MGLMultiPoint; // inherited from NSObject

	static new(): MGLMultiPoint; // inherited from NSObject

	readonly coordinates: interop.Pointer | interop.Reference<CLLocationCoordinate2D>;

	readonly pointCount: number;

	appendCoordinatesCount(coords: interop.Pointer | interop.Reference<CLLocationCoordinate2D>, count: number): void;

	getCoordinatesRange(coords: interop.Pointer | interop.Reference<CLLocationCoordinate2D>, range: NSRange): void;

	insertCoordinatesCountAtIndex(coords: interop.Pointer | interop.Reference<CLLocationCoordinate2D>, count: number, index: number): void;

	removeCoordinatesInRange(range: NSRange): void;

	replaceCoordinatesInRangeWithCoordinates(range: NSRange, coords: interop.Pointer | interop.Reference<CLLocationCoordinate2D>): void;

	replaceCoordinatesInRangeWithCoordinatesCount(range: NSRange, coords: interop.Pointer | interop.Reference<CLLocationCoordinate2D>, count: number): void;

	setCoordinatesCount(coords: interop.Pointer | interop.Reference<CLLocationCoordinate2D>, count: number): void;
}

declare class MGLMultiPolygon extends MGLShape implements MGLOverlay {

	static alloc(): MGLMultiPolygon; // inherited from NSObject

	static multiPolygonWithPolygons(polygons: NSArray<MGLPolygon> | MGLPolygon[]): MGLMultiPolygon;

	static new(): MGLMultiPolygon; // inherited from NSObject

	readonly polygons: NSArray<MGLPolygon>;

	readonly coordinate: CLLocationCoordinate2D; // inherited from MGLAnnotation

	readonly debugDescription: string; // inherited from NSObjectProtocol

	readonly description: string; // inherited from NSObjectProtocol

	readonly hash: number; // inherited from NSObjectProtocol

	readonly isProxy: boolean; // inherited from NSObjectProtocol

	readonly overlayBounds: MGLCoordinateBounds; // inherited from MGLOverlay

	readonly subtitle: string; // inherited from MGLAnnotation

	readonly superclass: typeof NSObject; // inherited from NSObjectProtocol

	readonly title: string; // inherited from MGLAnnotation

	readonly  // inherited from NSObjectProtocol

	class(): typeof NSObject;

	conformsToProtocol(aProtocol: any /* Protocol */): boolean;

	intersectsOverlayBounds(overlayBounds: MGLCoordinateBounds): boolean;

	isEqual(object: any): boolean;

	isKindOfClass(aClass: typeof NSObject): boolean;

	isMemberOfClass(aClass: typeof NSObject): boolean;

	performSelector(aSelector: string): any;

	performSelectorWithObject(aSelector: string, object: any): any;

	performSelectorWithObjectWithObject(aSelector: string, object1: any, object2: any): any;

	respondsToSelector(aSelector: string): boolean;

	retainCount(): number;

	self(): this;
}

declare class MGLMultiPolygonFeature extends MGLMultiPolygon implements MGLFeature {

	static alloc(): MGLMultiPolygonFeature; // inherited from NSObject

	static multiPolygonWithPolygons(polygons: NSArray<MGLPolygon> | MGLPolygon[]): MGLMultiPolygonFeature; // inherited from MGLMultiPolygon

	static new(): MGLMultiPolygonFeature; // inherited from NSObject

	attributes: NSDictionary<string, any>; // inherited from MGLFeature

	readonly coordinate: CLLocationCoordinate2D; // inherited from MGLAnnotation

	readonly debugDescription: string; // inherited from NSObjectProtocol

	readonly description: string; // inherited from NSObjectProtocol

	readonly hash: number; // inherited from NSObjectProtocol

	identifier: any; // inherited from MGLFeature

	readonly isProxy: boolean; // inherited from NSObjectProtocol

	readonly subtitle: string; // inherited from MGLAnnotation

	readonly superclass: typeof NSObject; // inherited from NSObjectProtocol

	readonly title: string; // inherited from MGLAnnotation

	readonly  // inherited from NSObjectProtocol

	attributeForKey(key: string): any;

	class(): typeof NSObject;

	conformsToProtocol(aProtocol: any /* Protocol */): boolean;

	geoJSONDictionary(): NSDictionary<string, any>;

	isEqual(object: any): boolean;

	isKindOfClass(aClass: typeof NSObject): boolean;

	isMemberOfClass(aClass: typeof NSObject): boolean;

	performSelector(aSelector: string): any;

	performSelectorWithObject(aSelector: string, object: any): any;

	performSelectorWithObjectWithObject(aSelector: string, object1: any, object2: any): any;

	respondsToSelector(aSelector: string): boolean;

	retainCount(): number;

	self(): this;
}

declare class MGLMultiPolyline extends MGLShape implements MGLOverlay {

	static alloc(): MGLMultiPolyline; // inherited from NSObject

	static multiPolylineWithPolylines(polylines: NSArray<MGLPolyline> | MGLPolyline[]): MGLMultiPolyline;

	static new(): MGLMultiPolyline; // inherited from NSObject

	readonly polylines: NSArray<MGLPolyline>;

	readonly coordinate: CLLocationCoordinate2D; // inherited from MGLAnnotation

	readonly debugDescription: string; // inherited from NSObjectProtocol

	readonly description: string; // inherited from NSObjectProtocol

	readonly hash: number; // inherited from NSObjectProtocol

	readonly isProxy: boolean; // inherited from NSObjectProtocol

	readonly overlayBounds: MGLCoordinateBounds; // inherited from MGLOverlay

	readonly subtitle: string; // inherited from MGLAnnotation

	readonly superclass: typeof NSObject; // inherited from NSObjectProtocol

	readonly title: string; // inherited from MGLAnnotation

	readonly  // inherited from NSObjectProtocol

	class(): typeof NSObject;

	conformsToProtocol(aProtocol: any /* Protocol */): boolean;

	intersectsOverlayBounds(overlayBounds: MGLCoordinateBounds): boolean;

	isEqual(object: any): boolean;

	isKindOfClass(aClass: typeof NSObject): boolean;

	isMemberOfClass(aClass: typeof NSObject): boolean;

	performSelector(aSelector: string): any;

	performSelectorWithObject(aSelector: string, object: any): any;

	performSelectorWithObjectWithObject(aSelector: string, object1: any, object2: any): any;

	respondsToSelector(aSelector: string): boolean;

	retainCount(): number;

	self(): this;
}

declare class MGLMultiPolylineFeature extends MGLMultiPolyline implements MGLFeature {

	static alloc(): MGLMultiPolylineFeature; // inherited from NSObject

	static multiPolylineWithPolylines(polylines: NSArray<MGLPolyline> | MGLPolyline[]): MGLMultiPolylineFeature; // inherited from MGLMultiPolyline

	static new(): MGLMultiPolylineFeature; // inherited from NSObject

	attributes: NSDictionary<string, any>; // inherited from MGLFeature

	readonly coordinate: CLLocationCoordinate2D; // inherited from MGLAnnotation

	readonly debugDescription: string; // inherited from NSObjectProtocol

	readonly description: string; // inherited from NSObjectProtocol

	readonly hash: number; // inherited from NSObjectProtocol

	identifier: any; // inherited from MGLFeature

	readonly isProxy: boolean; // inherited from NSObjectProtocol

	readonly subtitle: string; // inherited from MGLAnnotation

	readonly superclass: typeof NSObject; // inherited from NSObjectProtocol

	readonly title: string; // inherited from MGLAnnotation

	readonly  // inherited from NSObjectProtocol

	attributeForKey(key: string): any;

	class(): typeof NSObject;

	conformsToProtocol(aProtocol: any /* Protocol */): boolean;

	geoJSONDictionary(): NSDictionary<string, any>;

	isEqual(object: any): boolean;

	isKindOfClass(aClass: typeof NSObject): boolean;

	isMemberOfClass(aClass: typeof NSObject): boolean;

	performSelector(aSelector: string): any;

	performSelectorWithObject(aSelector: string, object: any): any;

	performSelectorWithObjectWithObject(aSelector: string, object1: any, object2: any): any;

	respondsToSelector(aSelector: string): boolean;

	retainCount(): number;

	self(): this;
}

declare class MGLNetworkConfiguration extends NSObject {

	static alloc(): MGLNetworkConfiguration; // inherited from NSObject

	static new(): MGLNetworkConfiguration; // inherited from NSObject

	sessionConfiguration: NSURLSessionConfiguration;

	static readonly sharedManager: MGLNetworkConfiguration;
}

declare class MGLOfflinePack extends NSObject {

	static alloc(): MGLOfflinePack; // inherited from NSObject

	static new(): MGLOfflinePack; // inherited from NSObject

	readonly context: NSData;

	readonly progress: MGLOfflinePackProgress;

	readonly region: MGLOfflineRegion;

	readonly state: MGLOfflinePackState;

	requestProgress(): void;

	resume(): void;

	suspend(): void;
}

declare var MGLOfflinePackErrorNotification: string;

declare var MGLOfflinePackMaximumMapboxTilesReachedNotification: string;

interface MGLOfflinePackProgress {
	countOfResourcesCompleted: number;
	countOfBytesCompleted: number;
	countOfTilesCompleted: number;
	countOfTileBytesCompleted: number;
	countOfResourcesExpected: number;
	maximumResourcesExpected: number;
}
declare var MGLOfflinePackProgress: interop.StructType<MGLOfflinePackProgress>;

declare var MGLOfflinePackProgressChangedNotification: string;

declare const enum MGLOfflinePackState {

	Unknown = 0,

	Inactive = 1,

	Active = 2,

	Complete = 3,

	Invalid = 4
}

declare var MGLOfflinePackUserInfoKeyError: string;

declare var MGLOfflinePackUserInfoKeyMaximumCount: string;

declare var MGLOfflinePackUserInfoKeyProgress: string;

declare var MGLOfflinePackUserInfoKeyState: string;

interface MGLOfflineRegion extends NSObjectProtocol {

	includesIdeographicGlyphs: boolean;

	styleURL: NSURL;
}
declare var MGLOfflineRegion: {

	prototype: MGLOfflineRegion;
};

declare class MGLOfflineStorage extends NSObject {

	static alloc(): MGLOfflineStorage; // inherited from NSObject

	static new(): MGLOfflineStorage; // inherited from NSObject

	readonly countOfBytesCompleted: number;

	delegate: MGLOfflineStorageDelegate;

	readonly packs: NSArray<MGLOfflinePack>;

	static readonly sharedOfflineStorage: MGLOfflineStorage;

	addContentsOfFileWithCompletionHandler(filePath: string, completion: (p1: NSURL, p2: NSArray<MGLOfflinePack>, p3: NSError) => void): void;

	addContentsOfURLWithCompletionHandler(fileURL: NSURL, completion: (p1: NSURL, p2: NSArray<MGLOfflinePack>, p3: NSError) => void): void;

	addPackForRegionWithContextCompletionHandler(region: MGLOfflineRegion, context: NSData