react-native-maps 1.26.10 → 1.26.12

package/dist/src/MapView.types.d.ts

@@ -0,0 +1,160 @@
+import type { ClickEvent, LatLng, Point, Region } from './sharedTypes';
+import type { NativeSyntheticEvent } from 'react-native';
+export type Camera = {
+    /**
+     * Apple Maps
+     */
+    altitude?: number;
+    center: LatLng;
+    heading: number;
+    pitch: number;
+    /**
+     * Google Maps
+     */
+    zoom?: number;
+};
+export type MapStyleElement = {
+    featureType?: string;
+    elementType?: string;
+    stylers: object[];
+};
+export type EdgePadding = {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+};
+export type MapType = 'hybrid' | 'mutedStandard' | 'none' | 'satellite' | 'standard' | 'terrain' | 'satelliteFlyover' | 'hybridFlyover';
+export type MapTypes = {
+    STANDARD: 'standard';
+    SATELLITE: 'satellite';
+    HYBRID: 'hybrid';
+    TERRAIN: 'terrain';
+    NONE: 'none';
+    MUTEDSTANDARD: 'mutedStandard';
+    SATELLITE_FLYOVER: 'satelliteFlyover';
+    HYBRID_FLYOVER: 'hybridFlyover';
+};
+export type IndoorLevel = {
+    index: number;
+    name: string;
+    shortName: string;
+};
+export type ActiveIndoorLevel = {
+    activeLevelIndex: number;
+    name: string;
+    shortName: string;
+};
+export type IndoorLevelActivatedEvent = NativeSyntheticEvent<{
+    indoorLevel: ActiveIndoorLevel;
+}>;
+export type IndoorBuilding = {
+    underground: boolean;
+    activeLevelIndex: number;
+    levels: IndoorLevel[];
+};
+export type IndoorBuildingEvent = NativeSyntheticEvent<{
+    IndoorBuilding: IndoorBuilding;
+}>;
+export type KmlMarker = {
+    id: string;
+    title: string;
+    description: string;
+    coordinate: LatLng;
+    position: Point;
+};
+export type KmlMapEvent = NativeSyntheticEvent<{
+    markers: KmlMarker[];
+}>;
+export type LongPressEvent = ClickEvent<{
+    /**
+     * @platform Android
+     */
+    action?: 'long-press';
+}>;
+export type PanDragEvent = ClickEvent;
+export type PoiClickEvent = NativeSyntheticEvent<{
+    placeId: string;
+    name: string;
+    coordinate: LatLng;
+    /**
+     * @platform Android
+     */
+    position?: Point;
+}>;
+export type MapPressEvent = ClickEvent<{
+    /**
+     * @platform Android
+     */
+    action?: 'press' | 'marker-press';
+}>;
+export type Details = {
+    isGesture?: boolean;
+};
+export type UserLocationChangeEvent = NativeSyntheticEvent<{
+    coordinate?: LatLng & {
+        altitude: number;
+        timestamp: number;
+        accuracy: number;
+        speed: number;
+        heading: number;
+        /**
+         * @platform iOS
+         */
+        altitudeAccuracy?: number;
+        /**
+         * @platform Android
+         */
+        isFromMockProvider?: boolean;
+    };
+    /**
+     * @platform iOS
+     */
+    error?: {
+        message: string;
+    };
+}>;
+export type ChangeEvent = NativeSyntheticEvent<{
+    region: Region;
+    isGesture?: boolean;
+}>;
+export type FitToOptions = {
+    edgePadding?: EdgePadding;
+    animated?: boolean;
+};
+export type BoundingBox = {
+    northEast: LatLng;
+    southWest: LatLng;
+};
+export type SnapshotOptions = {
+    /** optional, when omitted the view-width is used */
+    width?: number;
+    /** optional, when omitted the view-height is used */
+    height?: number;
+    /** __iOS only__, optional region to render */
+    region?: Region;
+    /** image formats, defaults to 'png' */
+    format?: 'png' | 'jpg';
+    /** image quality: 0..1 (only relevant for jpg, default: 1) */
+    quality?: number;
+    /** result types, defaults to 'file' */
+    result?: 'file' | 'base64';
+};
+export type Address = {
+    administrativeArea: string;
+    country: string;
+    countryCode: string;
+    locality: string;
+    name: string;
+    postalCode: string;
+    subAdministrativeArea: string;
+    subLocality: string;
+    thoroughfare: string;
+    subThoroughfare?: string;
+};
+export type CameraZoomRange = {
+    minCenterCoordinateDistance?: number;
+    maxCenterCoordinateDistance?: number;
+    animated?: boolean;
+};
+export type NativeCommandName = 'animateCamera' | 'animateToRegion' | 'coordinateForPoint' | 'fitToCoordinates' | 'fitToElements' | 'fitToSuppliedMarkers' | 'getAddressFromCoordinates' | 'getCamera' | 'getMapBoundaries' | 'getMarkersFrames' | 'pointForCoordinate' | 'setCamera' | 'setIndoorActiveLevelIndex' | 'setMapBoundaries' | 'takeSnapshot';

package/dist/src/MapView.web.d.ts

@@ -0,0 +1 @@
+export { default } from 'react-native-web/dist/modules/UnimplementedView';

package/dist/src/MapViewNativeComponent.d.ts

@@ -0,0 +1,17 @@
+import type { HostComponent } from 'react-native';
+import type { NativeProps } from './MapView';
+import type { Camera, EdgePadding } from './MapView.types';
+import type { LatLng, Region } from './sharedTypes';
+export type MapViewNativeComponentType = HostComponent<NativeProps>;
+interface NativeCommands {
+    animateToRegion: (viewRef: NonNullable<React.RefObject<MapViewNativeComponentType>['current']>, region: Region, duration: number) => void;
+    setCamera: (viewRef: NonNullable<React.RefObject<MapViewNativeComponentType>['current']>, camera: Partial<Camera>) => void;
+    animateCamera: (viewRef: NonNullable<React.RefObject<MapViewNativeComponentType>['current']>, camera: Partial<Camera>, duration: number) => void;
+    fitToElements: (viewRef: NonNullable<React.RefObject<MapViewNativeComponentType>['current']>, edgePadding: EdgePadding, animated: boolean) => void;
+    fitToSuppliedMarkers: (viewRef: NonNullable<React.RefObject<MapViewNativeComponentType>['current']>, markers: string[], edgePadding: EdgePadding, animated: boolean) => void;
+    fitToCoordinates: (viewRef: NonNullable<React.RefObject<MapViewNativeComponentType>['current']>, coordinates: LatLng[], edgePadding: EdgePadding, animated: boolean) => void;
+    setMapBoundaries: (viewRef: NonNullable<React.RefObject<MapViewNativeComponentType>['current']>, northEast: LatLng, southWest: LatLng) => void;
+    setIndoorActiveLevelIndex: (viewRef: NonNullable<React.RefObject<MapViewNativeComponentType>['current']>, activeLevelIndex: number) => void;
+}
+export declare const Commands: NativeCommands;
+export {};

package/dist/src/MapWMSTile.d.ts

@@ -0,0 +1,116 @@
+import * as React from 'react';
+import type { ViewProps } from 'react-native';
+import { ProviderContext, type NativeComponent, type MapManagerCommand, type UIManagerCommand } from './decorateMapComponent';
+export type MapWMSTileProps = ViewProps & {
+    /**
+     * The maximum native zoom level for this tile overlay i.e. the highest zoom level that the tile server provides.
+     * Tiles are auto-scaled for higher zoom levels.
+     *
+     * @platform iOS: Apple Maps only
+     * @platform Android: Supported
+     */
+    maximumNativeZ?: number;
+    /**
+     * The maximum zoom level for this tile overlay.
+     *
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    maximumZ?: number;
+    /**
+     * The minimum zoom level for this tile overlay.
+     *
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    minimumZ?: number;
+    /**
+     * In offline-mode tiles are not fetched from the tile servers, rather only tiles stored in the cache directory are used.
+     * Furthermore, automated tile scaling is activated: if tile at a desired zoom level is not found from the cache directory,
+     * then lower zoom level tile is used (up to 4 levels lower) and scaled.
+     *
+     * @default false
+     * @platform iOS: Apple Maps only
+     * @platform Android: Supported
+     */
+    offlineMode?: boolean;
+    /**
+     * Map layer opacity. Value between 0 - 1, with 0 meaning fully transparent.
+     *
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    opacity?: number;
+    /**
+     * Corresponds to MKTileOverlay canReplaceMapContent i.e. if true then underlying iOS basemap is not shown.
+     *
+     * @default false
+     * @platform iOS: Apple Maps only
+     * @platform Android: Not supported
+     */
+    shouldReplaceMapContent?: boolean;
+    /**
+     * Defines maximum age in seconds for a cached tile before it's refreshed.
+     *
+     * NB! Refresh logic is "serve-stale-while-refresh"
+     * i.e. to ensure map availability a stale (over max age) tile is served
+     * while a tile refresh process is started in the background.
+     *
+     * @platform iOS: Apple Maps only
+     * @platform Android: Supported
+     */
+    tileCacheMaxAge?: number;
+    /**
+     * Enable caching of tiles in the specified directory.
+     * Directory can be specified either as a normal path or in URL format (`file://`).
+     *
+     * Tiles are stored in tileCachePath directory as `/{z}/{x}/{y}` i.e. in sub-directories 2-levels deep,
+     * filename is tile y-coordinate without any filetype-extension.
+     *
+     * NB! All cache management needs to be implemented by client e.g. deleting tiles to manage use of storage space etc.
+     *
+     * @platform iOS: Apple Maps only
+     * @platform Android: Supported
+     */
+    tileCachePath?: string;
+    /**
+     * Tile size, default size is 256 (for tiles of 256 _ 256 pixels).
+     * High-res (aka 'retina') tiles are 512 (tiles of 512 _ 512 pixels)
+     *
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    tileSize?: number;
+    /**
+     * The url template of the map tileserver.
+     * (URLTile) The patterns {x} {y} {z} will be replaced at runtime.
+     * For example, http://c.tile.openstreetmap.org/{z}/{x}/{y}.png.
+     *
+     * It is also possible to refer to tiles in local filesystem with file:///top-level-directory/sub-directory/{z}/{x}/{y}.png URL-format.
+     * (WMSTile) The patterns {minX} {maxX} {minY} {maxY} {width} {height} will be replaced at runtime according to EPSG:900913 specification bounding box.
+     * For example, https://demo.geo-solutions.it/geoserver/tiger/wms?service=WMS&version=1.1.0&request=GetMap&layers=tiger:poi&styles=&bbox={minX},{minY},{maxX},{maxY}&width={width}&height={height}&srs=EPSG:900913&format=image/png&transparent=true&format_options=dpi:213.
+     *
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    urlTemplate: string;
+    /**
+     * 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: Google Maps only
+     * @platform Android: Supported
+     */
+    zIndex?: number;
+};
+type NativeProps = MapWMSTileProps;
+export declare class MapWMSTile extends React.Component<MapWMSTileProps> {
+    context: React.ContextType<typeof ProviderContext>;
+    getNativeComponent: () => NativeComponent<NativeProps>;
+    getMapManagerCommand: (name: string) => MapManagerCommand;
+    getUIManagerCommand: (name: string) => UIManagerCommand;
+    render(): React.JSX.Element;
+}
+declare const _default: typeof MapWMSTile;
+export default _default;

package/dist/src/ProviderConstants.d.ts

@@ -0,0 +1,2 @@
+export declare const PROVIDER_DEFAULT: any;
+export declare const PROVIDER_GOOGLE = "google";

package/dist/src/createFabricMap.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+import type { LatLng, Point, Region } from './sharedTypes';
+import type { Address, Camera, EdgePadding, SnapshotOptions } from './MapView.types';
+import { type MapBoundaries } from './specs/NativeAirMapsModule';
+import FabricMapView, { Commands as FabricCommands, type MapFabricNativeProps } from './specs/NativeComponentMapView';
+import GoogleMapView, { Commands as GoogleCommands, type MapFabricNativeProps as GoogleMapFabricNativeProps } from './specs/NativeComponentGoogleMapView';
+export type MapViewProps = MapFabricNativeProps | GoogleMapFabricNativeProps;
+export interface FabricMapHandle {
+    getCamera: () => Promise<Camera>;
+    setCamera: (camera: Partial<Camera>) => void;
+    animateToRegion: (region: Region, duration: number) => void;
+    animateCamera: (camera: Partial<Camera>, duration: number) => void;
+    getMarkersFrames: (onlyVisible: boolean) => Promise<unknown>;
+    fitToElements: (edgePadding: EdgePadding, animated: boolean) => void;
+    fitToSuppliedMarkers: (markers: string[], edgePadding: EdgePadding, animated: boolean) => void;
+    fitToCoordinates: (coordinates: LatLng[], edgePadding: EdgePadding, animated: boolean) => void;
+    getMapBoundaries: () => Promise<MapBoundaries>;
+    takeSnapshot: (config: SnapshotOptions) => Promise<string>;
+    getAddressFromCoordinates: (coordinate: LatLng) => Promise<Address>;
+    getPointForCoordinate: (coordinate: LatLng) => Promise<Point>;
+    getCoordinateForPoint: (point: Point) => Promise<LatLng>;
+    setIndoorActiveLevelIndex: (activeLevelIndex: number) => void;
+}
+declare const createFabricMap: (ViewComponent: typeof GoogleMapView | typeof FabricMapView, Commands: typeof FabricCommands | typeof GoogleCommands) => React.ForwardRefExoticComponent<MapViewProps & React.RefAttributes<FabricMapHandle | null>>;
+export default createFabricMap;

package/dist/src/decorateMapComponent.d.ts

@@ -0,0 +1,35 @@
+import { type HostComponent } from 'react-native';
+import type { Provider } from './sharedTypes';
+import { MapCallout } from './MapCallout';
+import { MapOverlay } from './MapOverlay';
+import { MapCalloutSubview } from './MapCalloutSubview';
+import { MapCircle } from './MapCircle';
+import { MapHeatmap } from './MapHeatmap';
+import { MapLocalTile } from './MapLocalTile';
+import { MapMarker } from './MapMarker';
+import { MapPolygon } from './MapPolygon';
+import { MapPolyline } from './MapPolyline';
+import { MapUrlTile } from './MapUrlTile';
+import { MapWMSTile } from './MapWMSTile';
+import { Commands } from './MapViewNativeComponent';
+export declare const SUPPORTED: ImplementationStatus;
+export declare const USES_DEFAULT_IMPLEMENTATION: ImplementationStatus;
+export declare const NOT_SUPPORTED: ImplementationStatus;
+export declare const ProviderContext: import("react").Context<Provider>;
+export declare function getNativeMapName(provider: Provider): "AIRMap" | "AIRGoogleMap";
+export declare const createNotSupportedComponent: (message: string) => (() => null);
+export declare const googleMapIsInstalled: boolean;
+export default function decorateMapComponent<Type extends Component>(Component: Type, componentName: ComponentName, providers: Providers): Type;
+type ImplementationStatus = 'SUPPORTED' | 'USES_DEFAULT_IMPLEMENTATION' | 'NOT_SUPPORTED';
+type Providers = {
+    google: {
+        ios: ImplementationStatus;
+        android: ImplementationStatus;
+    };
+};
+export type UIManagerCommand = number;
+export type MapManagerCommand = keyof typeof Commands;
+export type NativeComponent<H = unknown> = HostComponent<H> | ReturnType<typeof createNotSupportedComponent>;
+type Component = typeof MapCallout | typeof MapCalloutSubview | typeof MapCircle | typeof MapHeatmap | typeof MapLocalTile | typeof MapMarker | typeof MapOverlay | typeof MapPolygon | typeof MapPolyline | typeof MapUrlTile | typeof MapWMSTile;
+type ComponentName = 'Callout' | 'CalloutSubview' | 'Circle' | 'Heatmap' | 'LocalTile' | 'Marker' | 'Overlay' | 'Polygon' | 'Polyline' | 'UrlTile' | 'WMSTile';
+export {};

package/dist/src/fixImageProp.d.ts

@@ -0,0 +1,4 @@
+import { type ImageSourcePropType } from 'react-native';
+export declare function fixImageProp(image: ImageSourcePropType): {
+    uri: string;
+} | ImageSourcePropType;

package/dist/src/index.d.ts

@@ -0,0 +1,38 @@
+import MapView, { AnimatedMapView as Animated, MAP_TYPES, type MapViewProps } from './MapView';
+import Marker from './MapMarker';
+export { MapMarker } from './MapMarker';
+export type { MapMarkerProps } from './MapMarker';
+import Overlay from './MapOverlay';
+export { MapOverlay } from './MapOverlay';
+export type { MapOverlayProps } from './MapOverlay';
+export { default as Polyline, MapPolyline } from './MapPolyline';
+export type { MapPolylineProps } from './MapPolyline';
+export { default as Heatmap, MapHeatmap } from './MapHeatmap';
+export type { MapHeatmapProps } from './MapHeatmap';
+export { default as Polygon, MapPolygon } from './MapPolygon';
+export type { MapPolygonProps } from './MapPolygon';
+export { default as Circle, MapCircle } from './MapCircle';
+export type { MapCircleProps } from './MapCircle';
+export { default as UrlTile, MapUrlTile } from './MapUrlTile';
+export type { MapUrlTileProps } from './MapUrlTile';
+export { default as WMSTile, MapWMSTile } from './MapWMSTile';
+export type { MapWMSTileProps } from './MapWMSTile';
+export { default as LocalTile, MapLocalTile } from './MapLocalTile';
+export type { MapLocalTileProps } from './MapLocalTile';
+export { default as Callout, MapCallout } from './MapCallout';
+export type { MapCalloutProps } from './MapCallout';
+export { default as CalloutSubview, MapCalloutSubview, } from './MapCalloutSubview';
+export type { MapCalloutSubviewProps } from './MapCalloutSubview';
+export { default as AnimatedRegion } from './AnimatedRegion';
+export { default as Geojson } from './Geojson';
+export type { GeojsonProps } from './Geojson';
+export { Marker, Overlay };
+export type { MapViewProps };
+export { Animated, MAP_TYPES };
+export * from './ProviderConstants';
+export * from './MapView.types';
+export * from './MapPolygon.types';
+export * from './sharedTypes';
+export declare const MarkerAnimated: import("react-native").Animated.AnimatedComponent<typeof import("./MapMarker").MapMarker>;
+export declare const OverlayAnimated: import("react-native").Animated.AnimatedComponent<typeof import("./MapOverlay").MapOverlay>;
+export default MapView;

package/dist/src/sharedTypes.d.ts

@@ -0,0 +1,87 @@
+import type { NativeSyntheticEvent } from 'react-native';
+export type Provider = 'google' | undefined;
+export type LatLng = {
+    latitude: number;
+    longitude: number;
+};
+export type Point = {
+    x: number;
+    y: number;
+};
+export type Region = LatLng & {
+    latitudeDelta: number;
+    longitudeDelta: number;
+};
+export type Frame = Point & {
+    height: number;
+    width: number;
+};
+export type CalloutPressEvent = NativeSyntheticEvent<{
+    action: 'callout-press';
+    /**
+     * @platform iOS
+     */
+    frame?: Frame;
+    /**
+     * @platform iOS
+     */
+    id?: string;
+    /**
+     * @platform iOS
+     */
+    point?: Point;
+    /**
+     * @platform Android
+     */
+    coordinate?: LatLng;
+    /**
+     * @platform Android
+     */
+    position?: Point;
+}>;
+export type LineCapType = 'butt' | 'round' | 'square';
+export type LineJoinType = 'miter' | 'round' | 'bevel';
+export type ClickEvent<T = {}> = NativeSyntheticEvent<{
+    coordinate: LatLng;
+    position: Point;
+} & T>;
+export type MarkerDeselectEvent = Omit<ClickEvent<{
+    action: 'marker-deselect';
+    id: string;
+}>, 'position'>;
+export type MarkerSelectEvent = Omit<ClickEvent<{
+    id: string;
+    action: 'marker-select';
+}>, 'position'>;
+export type MarkerDragEvent = ClickEvent<{
+    /**
+     * @platform iOS
+     */
+    id?: string;
+}>;
+export type MarkerDragStartEndEvent = NativeSyntheticEvent<{
+    coordinate: LatLng;
+    /**
+     * @platform iOS
+     */
+    id?: string;
+    /**
+     * @platform Android
+     */
+    position?: Point;
+}>;
+export type MarkerPressEvent = NativeSyntheticEvent<{
+    id: string;
+    action: 'marker-press';
+    coordinate: LatLng;
+    /**
+     * @platform Android
+     */
+    position?: Point;
+}>;
+/**
+ * Represents the available categories for points of interest on the Apple Maps.
+ * Use an array of these strings for the `pointsOfInterestFilter` prop.
+ * More: https://developer.apple.com/documentation/mapkit/mkpointofinterestcategory
+ */
+export type MKPointOfInterestCategoryType = 'museum' | 'musicVenue' | 'theater' | 'library' | 'planetarium' | 'school' | 'university' | 'movieTheater' | 'nightlife' | 'fireStation' | 'hospital' | 'pharmacy' | 'police' | 'castle' | 'fortress' | 'landmark' | 'nationalMonument' | 'bakery' | 'brewery' | 'cafe' | 'distillery' | 'foodMarket' | 'restaurant' | 'winery' | 'animalService' | 'atm' | 'automotiveRepair' | 'bank' | 'beauty' | 'evCharger' | 'fitnessCenter' | 'laundry' | 'mailbox' | 'postOffice' | 'restroom' | 'spa' | 'store' | 'amusementPark' | 'aquarium' | 'beach' | 'campground' | 'fairground' | 'marina' | 'nationalPark' | 'park' | 'rvPark' | 'zoo' | 'baseball' | 'basketball' | 'bowling' | 'goKart' | 'golf' | 'hiking' | 'miniGolf' | 'rockClimbing' | 'skatePark' | 'skating' | 'skiing' | 'soccer' | 'stadium' | 'tennis' | 'volleyball' | 'airport' | 'carRental' | 'conventionCenter' | 'gasStation' | 'hotel' | 'parking' | 'publicTransport' | 'fishing' | 'kayaking' | 'surfing' | 'swimming';

package/dist/src/sharedTypesInternal.d.ts

@@ -0,0 +1 @@
+export type Modify<T, R> = Omit<T, keyof R> & R;

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

@@ -0,0 +1,31 @@
+import type { TurboModule } from 'react-native';
+import type { Double } from 'react-native/Libraries/Types/CodegenTypes';
+import type { Camera } from './NativeComponentMapView';
+import type { Address } from '../MapView.types';
+type LatLng = {
+    latitude: Double;
+    longitude: Double;
+};
+type Point = Readonly<{
+    x: Double;
+    y: Double;
+}>;
+export type Region = Readonly<LatLng & {
+    latitudeDelta: Double;
+    longitudeDelta: Double;
+}>;
+export type MapBoundaries = {
+    northEast: LatLng;
+    southWest: LatLng;
+};
+export interface Spec extends TurboModule {
+    getCamera(tag: Double): Promise<Camera>;
+    getMarkersFrames(tag: Double, onlyVisible: boolean): Promise<unknown>;
+    getMapBoundaries(tag: Double): Promise<MapBoundaries>;
+    takeSnapshot(tag: Double, config: string): Promise<string>;
+    getAddressFromCoordinates(tag: Double, coordinate: LatLng): Promise<Address>;
+    getPointForCoordinate(tag: Double, coordinate: LatLng): Promise<Point>;
+    getCoordinateForPoint(tag: Double, point: Point): Promise<LatLng>;
+}
+declare const _default: Spec;
+export default _default;

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

@@ -0,0 +1,46 @@
+import type { HostComponent, ViewProps } from 'react-native';
+import type { Double, BubblingEventHandler } from 'react-native/Libraries/Types/CodegenTypes';
+export type LatLng = Readonly<{
+    latitude: Double;
+    longitude: Double;
+}>;
+export type CalloutPressEvent = BubblingEventHandler<Readonly<{
+    action?: string;
+    id: string;
+    coordinate: {
+        latitude: Double;
+        longitude: Double;
+    };
+    position?: {
+        x: Double;
+        y: Double;
+    };
+}>>;
+export interface CalloutFabricNativeProps extends ViewProps {
+    /**
+     * If `true`, clicks on transparent areas in callout will be passed to map.
+     *
+     * @default false
+     * @platform iOS: Supported
+     * @platform Android: Not supported
+     */
+    alphaHitTest?: boolean;
+    /**
+     * Callback that is called when the user presses on the callout
+     *
+     * @platform iOS: Apple Maps only
+     * @platform Android: Supported
+     */
+    onPress?: CalloutPressEvent;
+    /**
+     * If `false`, a default "tooltip" bubble window will be drawn around this callouts children.
+     * If `true`, the child views can fully customize their appearance, including any "bubble" like styles.
+     *
+     * @default false
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    tooltip?: boolean;
+}
+declare const _default: HostComponent<CalloutFabricNativeProps>;
+export default _default;

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

@@ -0,0 +1,74 @@
+import type { HostComponent, ViewProps, ColorValue } from 'react-native';
+import type { Double, Float, BubblingEventHandler, WithDefault } from 'react-native/Libraries/Types/CodegenTypes';
+export type LatLng = Readonly<{
+    latitude: Double;
+    longitude: Double;
+}>;
+export type CirclePressEventHandler = BubblingEventHandler<Readonly<{
+    action?: string;
+    id: string;
+    coordinate: {
+        latitude: Double;
+        longitude: Double;
+    };
+    position?: {
+        x: Double;
+        y: Double;
+    };
+}>>;
+export interface CircleFabricNativeProps extends ViewProps {
+    /**
+     * The coordinates of the center of the circle.
+     *
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    center: LatLng;
+    /**
+     * The stroke color to use for the path.
+     *
+     * @default `#000`, `rgba(r,g,b,0.5)`
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    fillColor?: ColorValue;
+    /**
+     * The radius of the circle to be drawn (in meters)
+     *
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    radius: Double;
+    /**
+     * The stroke color to use for the path.
+     *
+     * @default `#000`, `rgba(r,g,b,0.5)`
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    strokeColor?: ColorValue;
+    /**
+     * Callback that is called when user taps on the map.
+     *
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    onPress?: CirclePressEventHandler;
+    /**
+     * The stroke width to use for the path.
+     *
+     * @default 1
+     * @platform iOS: Supported
+     * @platform Android: Supported
+     */
+    strokeWidth?: WithDefault<Float, 1.0>;
+    /**
+     * Boolean to allow a polygon to be tappable and use the onPress function.
+     *
+     * @platform iOS: Google Maps only
+     * @platform Android: Supported
+     */
+    tappable?: boolean;
+}
+declare const _default: HostComponent<CircleFabricNativeProps>;
+export default _default;