react-native-maps 1.26.10 → 1.26.12

package/dist/src/specs/NativeComponentGoogleMapView.d.ts

@@ -0,0 +1,709 @@
+import type { HostComponent, ViewProps, ColorValue } from 'react-native';
+import type { Double, Int32, WithDefault, Float, DirectEventHandler, BubblingEventHandler } from 'react-native/Libraries/Types/CodegenTypes';
+import GoogleMapView from './NativeComponentGoogleMapView';
+export type EdgePadding = Readonly<{
+    top: Double;
+    right: Double;
+    bottom: Double;
+    left: Double;
+}>;
+export type ActionType = 'callout-press' | 'press' | 'marker-press' | 'long-press' | 'marker-deselect' | 'marker-select';
+export type Frame = Readonly<{
+    x: Double;
+    y: Double;
+    width: Double;
+    height: Double;
+}>;
+export type ClickEvent = BubblingEventHandler<Readonly<{
+    coordinate: {
+        latitude: Double;
+        longitude: Double;
+    };
+    position: {
+        x: Double;
+        y: Double;
+    };
+}>>;
+export type KmlMarker = {
+    id: string;
+    title: string;
+    description: string;
+    coordinate: {
+        latitude: Double;
+        longitude: Double;
+    };
+    position: {
+        x: Double;
+        y: Double;
+    };
+};
+export type LongPressEventHandler = BubblingEventHandler<Readonly<{
+    coordinate: {
+        latitude: Double;
+        longitude: Double;
+    };
+    position: {
+        x: Double;
+        y: Double;
+    };
+    action?: string;
+}>>;
+export type MarkerDeselectEventHandler = BubblingEventHandler<Readonly<{
+    action?: string;
+    id: string;
+    coordinate: {
+        latitude: Double;
+        longitude: Double;
+    };
+}>>;
+export type MarkerSelectEventHandler = BubblingEventHandler<Readonly<{
+    action?: string;
+    id: string;
+    coordinate: {
+        latitude: Double;
+        longitude: Double;
+    };
+}>>;
+export type CalloutPressEvent = BubblingEventHandler<{
+    action?: string;
+    /**
+     * @platform iOS
+     */
+    frame?: {
+        x: Double;
+        y: Double;
+        width: Double;
+        height: Double;
+    };
+    /**
+     * @platform iOS
+     */
+    id?: string;
+    /**
+     * @platform iOS
+     */
+    point?: {
+        x: Double;
+        y: Double;
+    };
+    /**
+     * @platform Android
+     */
+    coordinate?: {
+        latitude: Double;
+        longitude: Double;
+    };
+    /**
+     * @platform Android
+     */
+    position?: {
+        x: Double;
+        y: Double;
+    };
+}>;
+export type CalloutPressEventHandler = DirectEventHandler<CalloutPressEvent>;
+export type Camera = Readonly<{
+    /**
+     * Apple Maps
+     */
+    altitude?: Double;
+    center: LatLng;
+    heading: Double;
+    pitch: Double;
+    /**
+     * Google Maps
+     */
+    zoom?: Float;
+}>;
+export type LatLng = Readonly<{
+    latitude: Double;
+    longitude: Double;
+}>;
+export type Point = Readonly<{
+    x: Double;
+    y: Double;
+}>;
+export type Region = Readonly<LatLng & {
+    latitudeDelta: Double;
+    longitudeDelta: Double;
+}>;
+export type IndoorLevel = Readonly<{
+    index: Int32;
+    name: string;
+    shortName: string;
+}>;
+export type IndoorLevelActivatedEventHandler = DirectEventHandler<Readonly<{
+    activeLevelIndex: Int32;
+    name: string;
+    shortName: string;
+}>>;
+export type IndoorBuilding = Readonly<{
+    underground: boolean;
+    activeLevelIndex: Int32;
+    levels: ReadonlyArray<IndoorLevel>;
+}>;
+export type IndoorBuildingEventHandler = DirectEventHandler<Readonly<{
+    underground: boolean;
+    activeLevelIndex: Int32;
+    levels: string;
+}>>;
+export type KmlMapEventHandler = DirectEventHandler<Readonly<{}>>;
+export type MapLoadedEventHandler = DirectEventHandler<Readonly<{}>>;
+export type MapReadyEventHandler = DirectEventHandler<Readonly<{}>>;
+export type Details = Readonly<{
+    isGesture?: boolean;
+}>;
+export type MarkerDragEventHandler = BubblingEventHandler<Readonly<{
+    coordinate: {
+        latitude: Double;
+        longitude: Double;
+    };
+    position: {
+        x: Double;
+        y: Double;
+    };
+    id?: string;
+}>>;
+export type MarkerDragStartEndEventHandler = BubblingEventHandler<Readonly<{
+    coordinate: {
+        latitude: Double;
+        longitude: Double;
+    };
+    id?: string;
+    position?: {
+        x: Double;
+        y: Double;
+    };
+}>>;
+export type MarkerPressEventHandler = BubblingEventHandler<Readonly<{
+    action?: string;
+    id: string;
+    coordinate: {
+        latitude: Double;
+        longitude: Double;
+    };
+    position?: {
+        x: Double;
+        y: Double;
+    };
+}>>;
+export type PanDragEventHandler = BubblingEventHandler<Readonly<{
+    coordinate: {
+        latitude: Double;
+        longitude: Double;
+    };
+    position: {
+        x: Double;
+        y: Double;
+    };
+}>>;
+export type PoiClickEventHandler = BubblingEventHandler<Readonly<{
+    placeId: string;
+    name: string;
+    coordinate: {
+        latitude: Double;
+        longitude: Double;
+    };
+    position?: {
+        x: Double;
+        y: Double;
+    };
+}>>;
+export type MapPressEventHandler = BubblingEventHandler<Readonly<{
+    coordinate: {
+        latitude: Double;
+        longitude: Double;
+    };
+    position: {
+        x: Double;
+        y: Double;
+    };
+    action?: string;
+}>>;
+export type RegionChangeStartEventHandler = DirectEventHandler<Details>;
+export type RegionChangeEvent = Readonly<{
+    region: {
+        latitude: Double;
+        longitude: Double;
+        latitudeDelta: Double;
+        longitudeDelta: Double;
+    };
+    isGesture?: boolean;
+}>;
+export type RegionChangeEventHandler = BubblingEventHandler<RegionChangeEvent>;
+export type UserLocationChangeEvent = Readonly<{
+    coordinate?: {
+        latitude: Double;
+        longitude: Double;
+        altitude: Double;
+        timestamp: Double;
+        accuracy: Float;
+        speed: Float;
+        heading: Float;
+        /**
+         * @platform iOS
+         */
+        altitudeAccuracy?: Float;
+        /**
+         * @platform Android
+         */
+        isFromMockProvider?: boolean;
+    };
+    /**
+     * @platform iOS
+     */
+    error?: Readonly<{
+        message: string;
+    }>;
+}>;
+export type UserLocationChangeEventHandler = DirectEventHandler<UserLocationChangeEvent>;
+export type CameraZoomRange = Readonly<{
+    minCenterCoordinateDistance?: Double;
+    maxCenterCoordinateDistance?: Double;
+    animated?: boolean;
+}>;
+export interface MapFabricNativeProps extends ViewProps {
+    /**
+     * The camera view the map should display.
+     *
+     * Use the camera system, instead of the region system, if you need control over
+     * the pitch or heading. Using this will ignore the `region` property.
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    camera?: Camera;
+    /**
+     * The initial camera view the map should use.  Use this prop instead of `camera`
+     * only if you don't want to control the camera of the map besides the initial view.
+     *
+     * Use the camera system, instead of the region system, if you need control over
+     * the pitch or heading.
+     *
+     * Changing this prop after the component has mounted will not result in a camera change.
+     *
+     * This is similar to the `initialValue` prop of a text input.
+     *
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    initialCamera?: Camera;
+    /**
+     * The initial region to be displayed by the map.  Use this prop instead of `region`
+     * only if you don't want to control the viewport of the map besides the initial region.
+     *
+     * Changing this prop after the component has mounted will not result in a region change.
+     *
+     * This is similar to the `initialValue` prop of a text input.
+     *
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    initialRegion?: Region;
+    /**
+     * The URL for KML file.
+     *
+     * @platform iOS: Google Maps only
+     * @platform Android: Supported
+     */
+    kmlSrc?: string;
+    /**
+     * https://developers.google.com/maps/documentation/get-map-id
+     * google cloud mapId to enable cloud styling and more
+     */
+    googleMapId?: string;
+    /**
+     * Sets loading background color.
+     *
+     * @default `#FFFFFF`
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    loadingBackgroundColor?: ColorValue;
+    /**
+     * Adds custom padding to each side of the map. Useful when map elements/markers are obscured.
+     *
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    mapPadding?: EdgePadding;
+    /**
+     * The map type to be displayed
+     *
+     * @default `standard`
+     * @platform iOS: hybrid | mutedStandard | satellite | standard | terrain | hybridFlyover | satelliteFlyover
+     * @platform Android: hybrid | none | satellite | standard | terrain
+     */
+    mapType?: WithDefault<'hybrid' | 'mutedStandard' | 'none' | 'satellite' | 'standard' | 'terrain' | 'satelliteFlyover' | 'hybridFlyover', 'standard'>;
+    /**
+     * Maximum zoom value for the map, must be between 0 and 20
+     *
+     * @default 20
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     * @deprecated on Apple Maps, use `cameraZoomRange` instead
+     */
+    maxZoom?: Float;
+    /**
+     * Minimum zoom value for the map, must be between 0 and 20
+     *
+     * @default 0
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     * @deprecated on Apple Maps, use `cameraZoomRange` instead
+     */
+    minZoom?: Float;
+    /**
+     * Callback that is called when an indoor building is focused/unfocused
+     *
+     * @platform iOS: Google Maps only
+     * @platform Android: Supported
+     */
+    onIndoorBuildingFocused?: IndoorBuildingEventHandler;
+    /**
+     * Callback that is called when a level on indoor building is activated
+     *
+     * @platform iOS: Google Maps only
+     * @platform Android: Supported
+     */
+    onIndoorLevelActivated?: IndoorLevelActivatedEventHandler;
+    /**
+     * Callback that is called once the kml is fully loaded.
+     *
+     * @platform iOS: Google Maps only
+     * @platform Android: Supported
+     */
+    onKmlReady?: KmlMapEventHandler;
+    /**
+     * Callback that is called when user makes a "long press" somewhere on the map.
+     *
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    onLongPress?: LongPressEventHandler;
+    /**
+     * Callback that is called when the map has finished rendering all tiles.
+     *
+     * @platform iOS: Google Maps only
+     * @platform Android: Supported
+     */
+    onMapLoaded?: MapLoadedEventHandler;
+    /**
+     * Callback that is called once the map is ready.
+     *
+     * Event is optional, as the first onMapReady callback is intercepted
+     * on Android, and the event is not passed on.
+     *
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    onMapReady?: MapReadyEventHandler;
+    /**
+     * Callback that is called when a marker on the map becomes deselected.
+     * This will be called when the callout for that marker is about to be hidden.
+     *
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    onMarkerDeselect?: MarkerDeselectEventHandler;
+    /**
+     * Callback called continuously as a marker is dragged
+     *
+     * @platform iOS: Apple Maps only
+     * @platform Android: Supported
+     */
+    onMarkerDrag?: MarkerDragEventHandler;
+    /**
+     * Callback that is called when a drag on a 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
+     */
+    onMarkerDragEnd?: MarkerDragStartEndEventHandler;
+    /**
+     * Callback that is called when the user initiates a drag on a marker (if it is draggable)
+     *
+     * @platform iOS: Apple Maps only
+     * @platform Android: Supported
+     */
+    onMarkerDragStart?: MarkerDragStartEndEventHandler;
+    /**
+     * Callback that is called when a marker on the map is tapped by the user.
+     *
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    onMarkerPress?: MarkerPressEventHandler;
+    /**
+     * Callback that is called when a marker on the map becomes selected.
+     * This will be called when the callout for that marker is about to be shown.
+     *
+     * @platform iOS: Supported.
+     * @platform Android: Supported
+     */
+    onMarkerSelect?: MarkerSelectEventHandler;
+    /**
+     * Callback that is called when user presses and drags the map.
+     * **NOTE**: for iOS `scrollEnabled` should be set to false to trigger the event
+     *
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    onPanDrag?: PanDragEventHandler;
+    /**
+     * Callback that is called when user click on a POI.
+     *
+     * @platform iOS: Google Maps only
+     * @platform Android: Supported
+     */
+    onPoiClick?: PoiClickEventHandler;
+    /**
+     * Callback that is called when user taps on the map.
+     *
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    onPress?: MapPressEventHandler;
+    /**
+     * Callback that is called once before the region changes, such as when the user starts moving the map.
+     * `isGesture` property indicates if the move was from the user (true) or an animation (false).
+     * **Note**: `isGesture` is supported by Google Maps only.
+     *
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    onRegionChangeStart?: RegionChangeEventHandler;
+    /**
+     * Callback that is called continuously when the region changes, such as when a user is dragging the map.
+     * `isGesture` property indicates if the move was from the user (true) or an animation (false).
+     * **Note**: `isGesture` is supported by Google Maps only.
+     *
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    onRegionChange?: RegionChangeEventHandler;
+    /**
+     * Callback that is called once when the region changes, such as when the user is done moving the map.
+     * `isGesture` property indicates if the move was from the user (true) or an animation (false).
+     * **Note**: `isGesture` is supported by Google Maps only.
+     *
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    onRegionChangeComplete?: RegionChangeEventHandler;
+    /**
+     * Callback that is called when the underlying map figures our users current location
+     * (coordinate also includes isFromMockProvider value for Android API 18 and above).
+     * Make sure **showsUserLocation** is set to *true*.
+     *
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    onUserLocationChange?: UserLocationChangeEventHandler;
+    /**
+     * Indicates how/when to affect padding with safe area insets
+     *
+     * @platform iOS: Google Maps only
+     * @platform Android: Not supported
+     */
+    paddingAdjustmentBehavior?: WithDefault<'always' | 'automatic' | 'never', 'never'>;
+    /**
+     * If `false` the user won't be able to adjust the camera’s pitch angle.
+     *
+     * @default true
+     * @platform iOS: Google Maps only
+     * @platform Android: Supported
+     */
+    pitchEnabled?: WithDefault<boolean, true>;
+    /**
+     * The region to be displayed by the map.
+     * The region is defined by the center coordinates and the span of coordinates to display.
+     *
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    region?: Region;
+    /**
+     * If `false` the user won't be able to adjust the camera’s pitch angle.
+     *
+     * @default true
+     * @platform iOS: Google Maps only
+     * @platform Android: Supported
+     */
+    rotateEnabled?: WithDefault<boolean, true>;
+    /**
+     * If `false` the map will stay centered while rotating or zooming.
+     *
+     * @default true
+     * @platform iOS: Google Maps only
+     * @platform Android: Supported
+     */
+    scrollDuringRotateOrZoomEnabled?: WithDefault<boolean, true>;
+    /**
+     * If `false` the user won't be able to change the map region being displayed.
+     *
+     * @default true
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    scrollEnabled?: WithDefault<boolean, true>;
+    /**
+     * A Boolean indicating whether the map displays extruded building information.
+     *
+     * @default true
+     * @platform iOS: Not supported
+     * @platform Android: Supported
+     */
+    showsBuildings?: WithDefault<boolean, true>;
+    /**
+     * If `false` compass won't be displayed on the map.
+     *
+     * @default true
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    showsCompass?: boolean;
+    /**
+     * A Boolean indicating whether indoor level picker should be enabled.
+     *
+     * @default false
+     * @platform iOS: Google Maps only
+     * @platform Android: Supported
+     */
+    showsIndoorLevelPicker?: boolean;
+    /**
+     * A Boolean indicating whether indoor maps should be enabled.
+     *
+     * @default true
+     * @platform iOS: Google Maps only
+     * @platform Android: Supported
+     */
+    showsIndoors?: WithDefault<boolean, true>;
+    /**
+     * If `false` hide the button to move the map to the current user's location.
+     *
+     * @default false
+     * @platform iOS: Google Maps only
+     * @platform Android: Supported
+     */
+    showsMyLocationButton?: boolean;
+    /**
+     * A Boolean indicating whether the map shows scale information.
+     *
+     * @default true
+     * @platform iOS: Apple Maps only
+     * @platform Android: Not supported
+     */
+    showsScale?: boolean;
+    /**
+     * A Boolean value indicating whether the map displays traffic information.
+     *
+     * @default false
+     * @platform iOS: Supported
+     * @platform Android: Not supported?
+     */
+    showsTraffic?: boolean;
+    /**
+     * If `true` the users location will be displayed on the map.
+     *
+     * This will cause iOS to ask for location permissions.
+     * For iOS see: [DOCS](https://github.com/react-native-maps/react-native-maps/blob/master/docs/installation.md#set-the-usage-description-property)
+     * @default false
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    showsUserLocation?: boolean;
+    /**
+     * Sets the map to the style selected.
+     *
+     * @default System setting
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    userInterfaceStyle?: WithDefault<'system' | 'light' | 'dark', 'system'>;
+    /**
+     * Adds custom styling to the map component.
+     * See [README](https://github.com/react-native-maps/react-native-maps#customizing-the-map-style) for more information.
+     *
+     * @platform iOS: Google Maps only
+     * @platform Android: Supported
+     */
+    customMapStyleString?: string;
+    /**
+     * If `true` clicking user location will show the default callout for userLocation annotation.
+     *
+     * @default false
+     * @platform iOS: Apple Maps only
+     * @platform Android: Not supported
+     */
+    userLocationCalloutEnabled?: boolean;
+    /**
+     * Fastest interval the application will actively acquire locations.
+     *
+     * See [Google APIs documentation](https://developers.google.com/android/reference/com/google/android/gms/location/LocationRequest.html)
+     *
+     * @default 5000
+     * @platform iOS: Not supported
+     * @platform Android: Supported
+     */
+    userLocationFastestInterval?: Int32;
+    /**
+     * Set power priority of user location tracking.
+     *
+     * See [Google APIs documentation](https://developers.google.com/android/reference/com/google/android/gms/location/LocationRequest.html)
+     *
+     * @default `high`
+     * @platform iOS: Not supported
+     * @platform Android: Supported
+     */
+    userLocationPriority?: WithDefault<'balanced' | 'high' | 'low' | 'passive', 'high'>;
+    /**
+     * Interval of user location updates in milliseconds.
+     *
+     * See [Google APIs documentation](https://developers.google.com/android/reference/com/google/android/gms/location/LocationRequest.html)
+     *
+     * @default 5000
+     * @platform iOS: Not supported
+     * @platform Android: Supported
+     */
+    userLocationUpdateInterval?: Int32;
+    /**
+     * If `false` the zoom control at the bottom right of the map won't be visible.
+     *
+     * @default true
+     * @platform iOS: Not supported
+     * @platform Android: Supported
+     */
+    zoomControlEnabled?: boolean;
+    /**
+     * If `false` the user won't be able to pinch/zoom the map.
+     *
+     * TODO: Why is the Android reactprop defaultvalue set to false?
+     *
+     * @default true
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    zoomEnabled?: WithDefault<boolean, true>;
+    /**
+     * If `false` the user won't be able to double tap to zoom the map.
+     * **Note:** But it will greatly decrease delay of tap gesture recognition.
+     *
+     * @default true
+     * @platform iOS: Google Maps only
+     * @platform Android: Not supported
+     */
+    zoomTapEnabled?: WithDefault<boolean, true>;
+}
+interface NativeCommands {
+    animateToRegion: (viewRef: React.ElementRef<typeof GoogleMapView>, regionJSON: string, duration: Int32) => void;
+    setCamera: (viewRef: React.ElementRef<typeof GoogleMapView>, cameraJSON: string) => void;
+    animateCamera: (viewRef: React.ElementRef<typeof GoogleMapView>, cameraJSON: string, duration: Int32) => void;
+    fitToElements: (viewRef: React.ElementRef<typeof GoogleMapView>, edgePaddingJSON: string, animated: boolean) => void;
+    fitToSuppliedMarkers: (viewRef: React.ElementRef<typeof GoogleMapView>, markersJSON: string, edgePaddingJSON: string, animated: boolean) => void;
+    fitToCoordinates: (viewRef: React.ElementRef<typeof GoogleMapView>, coordinatesJSON: string, edgePaddingJSON: string, animated: boolean) => void;
+    setIndoorActiveLevelIndex: (viewRef: React.ElementRef<typeof GoogleMapView>, activeLevelIndex: Int32) => void;
+}
+export declare const Commands: NativeCommands;
+declare const _default: HostComponent<MapFabricNativeProps>;
+export default _default;