react-native-maps 0.31.1 → 1.0.0-beta.1

package/lib/MapCircle.d.ts

@@ -0,0 +1,117 @@
+import * as React from 'react';
+import { View, ViewProps } from 'react-native';
+import { ProviderContext, NativeComponent, MapManagerCommand, UIManagerCommand } from './decorateMapComponent';
+import { LatLng, LineCapType, LineJoinType } from './sharedTypes';
+declare type Props = ViewProps & {
+    /**
+     * The coordinates of the center of the circle.
+     *
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    center: LatLng;
+    /**
+     * The fill color to use for the path.
+     *
+     * @default `#000`, `rgba(r,g,b,0.5)`
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    fillColor?: string;
+    /**
+     * The line cap style to apply to the open ends of the path
+     *
+     * @default `round`
+     * @platform iOS: Apple Maps only
+     * @platform Android: Not supported
+     */
+    lineCap?: LineCapType;
+    /**
+     * An array of numbers specifying the dash pattern to use for the path.
+     * The array contains one or more numbers that indicate the lengths (measured in points)
+     * of the line segments and gaps in the pattern.
+     * The values in the array alternate, starting with the first line segment length,
+     * followed by the first gap length, followed by the second line segment length, and so on.
+     *
+     * @platform iOS: Apple Maps only
+     * @platform Android: Not supported
+     */
+    lineDashPattern?: number[];
+    /**
+     * The offset (in points) at which to start drawing the dash pattern.
+     * Use this property to start drawing a dashed line partway through a segment or gap.
+     * For example, a phase value of 6 for the patter 5-2-3-2 would cause drawing to begin in the middle of the first gap.
+     *
+     * @default 0
+     * @platform iOS: Apple Maps only
+     * @platform Android: Not supported
+     */
+    lineDashPhase?: number;
+    /**
+     * The line join style to apply to corners of the path.
+     *
+     * @platform iOS: Apple Maps only
+     * @platform Android: Not supported
+     */
+    lineJoin?: LineJoinType;
+    /**
+     * The limiting value that helps avoid spikes at junctions between connected line segments.
+     * The miter limit helps you avoid spikes in paths that use the `miter` `lineJoin` style.
+     * If the ratio of the miter length—that is, the diagonal length of the miter join—to the line thickness exceeds the miter limit,
+     * the joint is converted to a bevel join.
+     * The default miter limit is 10, which results in the conversion of miters whose angle at the joint is less than 11 degrees.
+     *
+     * @default 10
+     * @platform iOS: Apple Maps only
+     * @platform Android: Not supported
+     */
+    miterLimit?: number;
+    /**
+     * The radius of the circle to be drawn (in meters)
+     *
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    radius: number;
+    /**
+     * The stroke color to use for the path.
+     *
+     * @default `#000`, `rgba(r,g,b,0.5)`
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    strokeColor?: string;
+    /**
+     * The stroke width to use for the path.
+     *
+     * @default 1
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    strokeWidth?: number;
+    /**
+     * The order in which this tile overlay is drawn with respect to other overlays.
+     * An overlay with a larger z-index is drawn over overlays with smaller z-indices.
+     * The order of overlays with the same z-index is arbitrary.
+     *
+     * @default 0
+     * @platform iOS: Google Maps only
+     * @platform Android: Supported
+     */
+    zIndex?: number;
+};
+declare type NativeProps = Props & {
+    ref: React.RefObject<View>;
+};
+export declare class MapCircle extends React.Component<Props> {
+    context: React.ContextType<typeof ProviderContext>;
+    getNativeComponent: () => NativeComponent<NativeProps>;
+    getMapManagerCommand: (name: string) => MapManagerCommand;
+    getUIManagerCommand: (name: string) => UIManagerCommand;
+    private circle;
+    constructor(props: Props);
+    setNativeProps(props: Partial<NativeProps>): void;
+    render(): JSX.Element;
+}
+declare const _default: typeof MapCircle;
+export default _default;

package/lib/MapCircle.js

@@ -0,0 +1,53 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MapCircle = void 0;
+const React = __importStar(require("react"));
+const decorateMapComponent_1 = __importStar(require("./decorateMapComponent"));
+class MapCircle extends React.Component {
+    getNativeComponent;
+    getMapManagerCommand;
+    getUIManagerCommand;
+    circle;
+    constructor(props) {
+        super(props);
+        this.circle = React.createRef();
+    }
+    setNativeProps(props) {
+        this.circle.current?.setNativeProps(props);
+    }
+    render() {
+        const { strokeColor = '#000', strokeWidth = 1 } = this.props;
+        const AIRMapCircle = this.getNativeComponent();
+        return (<AIRMapCircle {...this.props} strokeColor={strokeColor} strokeWidth={strokeWidth} ref={this.circle}/>);
+    }
+}
+exports.MapCircle = MapCircle;
+exports.default = (0, decorateMapComponent_1.default)(MapCircle, 'Circle', {
+    google: {
+        ios: decorateMapComponent_1.SUPPORTED,
+        android: decorateMapComponent_1.USES_DEFAULT_IMPLEMENTATION,
+    },
+});

package/lib/MapHeatmap.d.ts

@@ -0,0 +1,77 @@
+import * as React from 'react';
+import { ProcessedColorValue, View, ViewProps } from 'react-native';
+import { MapManagerCommand, NativeComponent, ProviderContext, UIManagerCommand } from './decorateMapComponent';
+import { LatLng, Modify } from './sharedTypes';
+declare type Props = ViewProps & {
+    gradient?: {
+        /**
+         * Resolution of color map -- number corresponding to the number of steps colors are interpolated into.
+         *
+         * @default 256
+         * @platform iOS: Google Maps only
+         * @platform Android: Supported
+         */
+        colorMapSize: number;
+        /**
+         * Colors (one or more) to used for gradient.
+         *
+         * @platform iOS: Google Maps only
+         * @platform Android: Supported
+         */
+        colors: string[];
+        /**
+         * Array of floating point values from 0 to 1 representing where each color starts.
+         *
+         * Array length must be equal to `colors` array length.
+         *
+         * @platform iOS: Google Maps only
+         * @platform Android: Supported
+         */
+        startPoints: number[];
+    };
+    /**
+     * The opacity of the heatmap.
+     *
+     * @default 0.7
+     * @platform iOS: Google Maps only
+     * @platform Android: Supported
+     */
+    opacity?: number;
+    /**
+     * Array of heatmap entries to apply towards density.
+     *
+     * @platform iOS: Google Maps only
+     * @platform Android: Supported
+     */
+    points?: WeightedLatLng[];
+    /**
+     * The radius of the heatmap points in pixels, between 10 and 50.
+     *
+     * @default 20
+     * @platform iOS: Google Maps only
+     * @platform Android: Supported
+     */
+    radius?: number;
+};
+declare type NativeProps = Modify<Props, {
+    gradient?: Modify<Props['gradient'], {
+        colors: (ProcessedColorValue | null | undefined)[];
+    }>;
+}> & {
+    ref: React.RefObject<View>;
+};
+export declare class MapHeatmap extends React.Component<Props> {
+    context: React.ContextType<typeof ProviderContext>;
+    getNativeComponent: () => NativeComponent<NativeProps>;
+    getMapManagerCommand: (name: string) => MapManagerCommand;
+    getUIManagerCommand: (name: string) => UIManagerCommand;
+    private heatmap;
+    constructor(props: Props);
+    setNativeProps(props: Partial<NativeProps>): void;
+    render(): JSX.Element;
+}
+declare const _default: typeof MapHeatmap;
+export default _default;
+declare type WeightedLatLng = LatLng & {
+    weight?: number;
+};

package/lib/MapHeatmap.js

@@ -0,0 +1,59 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MapHeatmap = void 0;
+const React = __importStar(require("react"));
+const react_native_1 = require("react-native");
+const decorateMapComponent_1 = __importStar(require("./decorateMapComponent"));
+class MapHeatmap extends React.Component {
+    getNativeComponent;
+    getMapManagerCommand;
+    getUIManagerCommand;
+    heatmap;
+    constructor(props) {
+        super(props);
+        this.heatmap = React.createRef();
+    }
+    setNativeProps(props) {
+        this.heatmap.current?.setNativeProps(props);
+    }
+    render() {
+        const AIRMapHeatmap = this.getNativeComponent();
+        const propGradient = this.props.gradient;
+        let gradient;
+        if (propGradient) {
+            const colors = propGradient.colors.map(c => (0, react_native_1.processColor)(c));
+            gradient = { ...propGradient, colors };
+        }
+        return (<AIRMapHeatmap {...this.props} gradient={gradient} ref={this.heatmap}/>);
+    }
+}
+exports.MapHeatmap = MapHeatmap;
+exports.default = (0, decorateMapComponent_1.default)(MapHeatmap, 'Heatmap', {
+    google: {
+        ios: decorateMapComponent_1.SUPPORTED,
+        android: decorateMapComponent_1.USES_DEFAULT_IMPLEMENTATION,
+    },
+});

package/lib/MapLocalTile.d.ts

@@ -0,0 +1,35 @@
+import * as React from 'react';
+import { ViewProps } from 'react-native';
+import { ProviderContext, NativeComponent, MapManagerCommand, UIManagerCommand } from './decorateMapComponent';
+declare type Props = ViewProps & {
+    /**
+     * @platform iOS: Apple Maps only
+     * @platform Android: Supported
+     */
+    pathTemplate: string;
+    /**
+     * @platform iOS: Apple Maps only
+     * @platform Android: Supported
+     */
+    tileSize?: number;
+    /**
+     * Set to true to use pathTemplate to open files from Android's AssetManager. The default is false.
+     * @platform android
+     */
+    useAssets?: boolean;
+    /**
+     * @platform iOS: Not supported
+     * @platform Android: Supported
+     */
+    zIndex?: number;
+};
+declare type NativeProps = Props;
+export declare class MapLocalTile extends React.Component<Props> {
+    context: React.ContextType<typeof ProviderContext>;
+    getNativeComponent: () => NativeComponent<NativeProps>;
+    getMapManagerCommand: (name: string) => MapManagerCommand;
+    getUIManagerCommand: (name: string) => UIManagerCommand;
+    render(): JSX.Element;
+}
+declare const _default: typeof MapLocalTile;
+export default _default;

package/lib/MapLocalTile.js

@@ -0,0 +1,44 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MapLocalTile = void 0;
+const React = __importStar(require("react"));
+const decorateMapComponent_1 = __importStar(require("./decorateMapComponent"));
+class MapLocalTile extends React.Component {
+    getNativeComponent;
+    getMapManagerCommand;
+    getUIManagerCommand;
+    render() {
+        const AIRMapLocalTile = this.getNativeComponent();
+        return <AIRMapLocalTile {...this.props}/>;
+    }
+}
+exports.MapLocalTile = MapLocalTile;
+exports.default = (0, decorateMapComponent_1.default)(MapLocalTile, 'LocalTile', {
+    google: {
+        ios: decorateMapComponent_1.SUPPORTED,
+        android: decorateMapComponent_1.USES_DEFAULT_IMPLEMENTATION,
+    },
+});

package/lib/MapMarker.d.ts

@@ -0,0 +1,289 @@
+import * as React from 'react';
+import { Animated, ViewProps, ImageURISource, ImageRequireSource, View } from 'react-native';
+import { MapManagerCommand, NativeComponent, ProviderContext, UIManagerCommand } from './decorateMapComponent';
+import { CalloutPressEvent, LatLng, MarkerDeselectEvent, MarkerDragEvent, MarkerDragStartEndEvent, MarkerPressEvent, MarkerSelectEvent, Modify, Point } from './sharedTypes';
+export declare type Props = ViewProps & {
+    /**
+     * Sets the anchor point for the marker.
+     * The anchor specifies the point in the icon image that is anchored to the marker's position on the Earth's surface.
+     *
+     * The anchor point is specified in the continuous space [0.0, 1.0] x [0.0, 1.0],
+     * where (0, 0) is the top-left corner of the image, and (1, 1) is the bottom-right corner.
+     *
+     * The anchoring point in a W x H image is the nearest discrete grid point in a (W + 1) x (H + 1) grid, obtained by scaling the then rounding.
+     * For example, in a 4 x 2 image, the anchor point (0.7, 0.6) resolves to the grid point at (3, 1).
+     *
+     * @default {x: 0.5, y: 1.0}
+     * @platform iOS: Google Maps only. For Apple Maps, see the `centerOffset` prop
+     * @platform Android: Supported
+     */
+    anchor?: Point;
+    /**
+     * Specifies the point in the marker image at which to anchor the callout when it is displayed.
+     * This is specified in the same coordinate system as the anchor.
+     *
+     * See the `anchor` prop for more details.
+     *
+     * @default {x: 0.5, y: 0.0}
+     * @platform iOS: Google Maps only. For Apple Maps, see the `calloutOffset` prop
+     * @platform Android: Supported
+     */
+    calloutAnchor?: Point;
+    /**
+     * The offset (in points) at which to place the callout bubble.
+     * When this property is set to (0, 0),
+     * the anchor point of the callout bubble is placed on the top-center point of the marker view’s frame.
+     *
+     * Specifying positive offset values moves the callout bubble down and to the right,
+     * while specifying negative values moves it up and to the left
+     *
+     * @default {x: 0.0, y: 0.0}
+     * @platform iOS: Apple Maps only. For Google Maps, see the `calloutAnchor` prop
+     * @platform Android: Not supported. See see the `calloutAnchor` prop
+     */
+    calloutOffset?: Point;
+    /**
+     * The offset (in points) at which to display the annotation view.
+     *
+     * By default, the center point of an annotation view is placed at the coordinate point of the associated annotation.
+     *
+     * Positive offset values move the annotation view down and to the right, while negative values move it up and to the left.
+     *
+     * @default {x: 0.0, y: 0.0}
+     * @platform iOS: Apple Maps only. For Google Maps, see the `anchor` prop
+     * @platform Android: Not supported. See see the `anchor` prop
+     */
+    centerOffset?: Point;
+    /**
+     * The coordinate for the marker.
+     *
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    coordinate: LatLng;
+    /**
+     * The description of the marker.
+     *
+     * This is only used if the <Marker /> component has no children that are a `<Callout />`,
+     * in which case the default callout behavior will be used,
+     * which will show both the `title` and the `description`, if provided.
+     *
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    description?: string;
+    /**
+     * if `true` allows the marker to be draggable (re-positioned).
+     *
+     * @default false
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    draggable?: boolean;
+    /**
+     * Sets whether this marker should be flat against the map true or a billboard facing the camera.
+     *
+     * @default false
+     * @platform iOS: Google Maps only
+     * @platform Android: Supported
+     */
+    flat?: boolean;
+    /**
+     * Marker icon to render (equivalent to `icon` property of GMSMarker Class).
+     * Only local image resources are allowed to be used.
+     *
+     * @platform iOS: Google Maps only
+     * @platform Android: Supported
+     */
+    icon?: ImageURISource | ImageRequireSource;
+    /**
+     * A string that can be used to identify this marker.
+     *
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    identifier?: string;
+    /**
+     * A custom image to be used as the marker's icon. Only local image resources are allowed to be used.
+     *
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    image?: ImageURISource | ImageRequireSource;
+    /**
+     * When true, the marker will be pre-selected.
+     * Setting this to true allows the user to drag the marker without needing to tap on it first to focus it.
+     *
+     * @default false
+     * @platform iOS: Apple Maps only
+     * @platform Android: Not supported
+     */
+    isPreselected?: boolean;
+    /**
+     * Callback that is called when the user taps the callout view.
+     *
+     * @platform iOS: Apple Maps only
+     * @platform Android: Supported
+     */
+    onCalloutPress?: (event: CalloutPressEvent) => void;
+    /**
+     * Callback that is called when the marker is deselected, before the callout is hidden.
+     *
+     * @platform iOS: Apple Maps only
+     * @platform Android: Not supported
+     */
+    onDeselect?: (event: MarkerDeselectEvent) => void;
+    /**
+     * Callback called continuously as the marker is dragged
+     *
+     * @platform iOS: Apple Maps only
+     * @platform Android: Supported
+     */
+    onDrag?: (event: MarkerDragEvent) => void;
+    /**
+     * Callback that is called when a drag on the marker finishes.
+     * This is usually the point you will want to setState on the marker's coordinate again
+     *
+     * @platform iOS: Apple Maps only
+     * @platform Android: Supported
+     */
+    onDragEnd?: (event: MarkerDragStartEndEvent) => void;
+    /**
+     * Callback that is called when the user initiates a drag on the marker (if it is draggable)
+     *
+     * @platform iOS: Apple Maps only
+     * @platform Android: Supported
+     */
+    onDragStart?: (event: MarkerDragStartEndEvent) => void;
+    /**
+     * Callback that is called when the marker is tapped by the user.
+     *
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    onPress?: (event: MarkerPressEvent) => void;
+    /**
+     * Callback that is called when the marker becomes selected.
+     * This will be called when the callout for that marker is about to be shown.
+     *
+     * @platform iOS: Apple Maps only.
+     * @platform Android: Not supported
+     */
+    onSelect?: (event: MarkerSelectEvent) => void;
+    /**
+     * The marker's opacity between 0.0 and 1.0.
+     *
+     * @default 1.0
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    opacity?: number;
+    /**
+     * If no custom marker view or custom image is provided, the platform default pin will be used, which can be customized by this color.
+     * Ignored if a custom marker is being used.<br/><br/>
+     * For Android, the set of available colors is limited. Unsupported colors will fall back to red.
+     * See [#887](https://github.com/react-community/react-native-maps/issues/887) for more information.
+     *
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    pinColor?: string;
+    /**
+     * A float number indicating marker's rotation angle, in degrees.
+     *
+     * @default 0
+     * @platform iOS: Google Maps only
+     * @platform Android: Supported
+     */
+    rotation?: number;
+    /**
+     * Sets whether this marker should propagate `onPress` events.
+     * Enabling it will stop the parent `MapView`'s `onPress` from being called.
+     *
+     * Android does not propagate `onPress` events.
+     *
+     * See [#1132](https://github.com/react-community/react-native-maps/issues/1132) for more information.
+     *
+     * @default false
+     * @platform iOS: Apple Maps only
+     * @platform Android: Not supported
+     */
+    stopPropagation?: boolean;
+    /**
+     * Sets whether marker should be tappable.
+     * If set to false, the marker will not have onPress events.
+     *
+     * @default true
+     * @platform iOS: Google Maps only
+     * @platform Android: Not supported
+     */
+    tappable?: boolean;
+    /**
+     * The title of the marker.
+     * This is only used if the <Marker /> component has no `<Callout />` children.
+     *
+     * If the marker has <Callout /> children, default callout behavior will be used,
+     * which will show both the `title` and the `description`, if provided.
+     *
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    title?: string;
+    /**
+     * Sets whether this marker should track view changes in info window.
+     * Enabling it will let marker change content of info window after first render pass, but will lead to decreased performance,
+     * so it's recommended to disable it whenever you don't need it.
+     * **Note**: iOS Google Maps only.
+     *
+     * @default false
+     * @platform iOS: Google Maps only
+     * @platform Android: Not supported
+     */
+    tracksInfoWindowChanges?: boolean;
+    /**
+     * Sets whether this marker should track view changes.
+     * It's recommended to turn it off whenever it's possible to improve custom marker performance.
+     *
+     * @default true
+     * @platform iOS: Google Maps only
+     * @platform Android: Supported
+     */
+    tracksViewChanges?: boolean;
+    /**
+     * The order in which this tile overlay is drawn with respect to other overlays.
+     * An overlay with a larger z-index is drawn over overlays with smaller z-indices.
+     * The order of overlays with the same z-index is arbitrary.
+     *
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    zIndex?: number;
+};
+declare type OmittedProps = Omit<Props, 'stopPropagation'>;
+declare type NativeProps = Modify<OmittedProps, {
+    icon?: string;
+    image?: Props['image'] | string;
+}> & {
+    ref: React.RefObject<View>;
+};
+export declare class MapMarker extends React.Component<Props> {
+    context: React.ContextType<typeof ProviderContext>;
+    getNativeComponent: () => NativeComponent<NativeProps>;
+    getMapManagerCommand: (name: string) => MapManagerCommand;
+    getUIManagerCommand: (name: string) => UIManagerCommand;
+    static Animated: Animated.AnimatedComponent<typeof MapMarker>;
+    private marker;
+    constructor(props: Props);
+    setNativeProps(props: Partial<NativeProps>): void;
+    showCallout(): void;
+    hideCallout(): void;
+    redrawCallout(): void;
+    animateMarkerToCoordinate(coordinate: LatLng, duration?: number): void;
+    redraw(): void;
+    _getHandle(): number | null;
+    _runCommand(name: NativeCommandName, args: any[]): void;
+    render(): JSX.Element;
+}
+declare const _default: typeof MapMarker;
+export default _default;
+declare type NativeCommandName = 'showCallout' | 'hideCallout' | 'redrawCallout' | 'animateMarkerToCoordinate' | 'redraw';