@cloudparse/up-miniapps-sdk 0.1.6 → 0.2.1

package/dist/index.d.cts

@@ -0,0 +1,1146 @@
+import React from 'react';
+import { R as RouteResponse, a as RouteStep, b as RouteRequest, c as RoutingBackendConfig } from './index-B9dDciJq.cjs';
+export { C as ClearRouteRequest, D as DrawRouteRequest, h as handleClearRoute, d as handleDrawRoute, e as handleRouteRequest } from './index-B9dDciJq.cjs';
+import { ViewState } from '@vis.gl/react-maplibre';
+import * as react_dom_client from 'react-dom/client';
+import 'maplibre-gl';
+
+interface BridgeMockerProps {
+    /** Optional appId to return in INITIALIZE response */
+    appId?: string;
+    /** Initial simulated location [lng, lat] */
+    initialLocation?: [number, number];
+    /** Whether the simulated user should be moving */
+    isMoving?: boolean;
+    /** An array of coordinates to follow. If provided, overrides random movement. */
+    simulationPath?: [number, number][];
+    /** Speed multiplier for the simulation interval. Default is 1. Higher is faster. */
+    simulationSpeed?: number;
+    /** Mock JWT token for NETWORK_REQUEST mocking */
+    mockJWTToken?: string;
+    children: React.ReactNode;
+}
+/**
+ * A utility component for Storybook that intercepts SDK bridge calls,
+ * simulates the behavior of the native shell app.
+ *
+ * NOTE: Logs are now handled by the standalone DebugConsole component.
+ */
+declare const BridgeMocker: React.FC<BridgeMockerProps>;
+
+interface DebugConsoleProps {
+    /**
+     * Whether to show the console initially.
+     * Can also be controlled via the 'debug' prop on SDKProvider.
+     */
+    isOpen?: boolean;
+    /**
+     * Optional callback when the console is closed.
+     */
+    onClose?: () => void;
+}
+/**
+ * A standalone debug console that intercepts and displays all Bridge communication.
+ * Useful for debugging both in mock mode (BridgeMocker) and on real devices.
+ */
+declare const DebugConsole: React.FC<DebugConsoleProps>;
+
+/**
+ * UP Mini-App SDK Types
+ */
+/**
+ * Represents the user's profile information.
+ */
+interface IUserProfile {
+    /** Unique identifier for the user. */
+    uuid: string;
+    /** Full legal name of the user. */
+    fullName: string;
+    /** Primary email address. */
+    email: string;
+    /** Chosen username within the UP ecosystem. */
+    username: string;
+    /** ISO country code (e.g., "FR", "US"). */
+    countryCode: string;
+    /** Phone number without country code. */
+    localNumber: string;
+}
+/**
+ * Geographic location data.
+ */
+interface ILocationData {
+    coords: {
+        /** Latitude in decimal degrees. */
+        latitude: number;
+        /** Longitude in decimal degrees. */
+        longitude: number;
+        /** Altitude in meters above the WGS 84 reference ellipsoid, or null if not available. */
+        altitude: number | null;
+        /** Accuracy of the latitude and longitude properties in meters. */
+        accuracy: number | null;
+        /** Accuracy of the altitude property in meters. */
+        altitudeAccuracy: number | null;
+        /** The direction in which the device is traveling, in degrees (0-360). */
+        heading: number | null;
+        /** The velocity of the device in meters per second. */
+        speed: number | null;
+    };
+    /** The time at which the location was retrieved (Unix timestamp). */
+    timestamp: number;
+}
+/**
+ * Request payload for triggering a payment flow.
+ */
+interface IPaymentRequest {
+    /** The specific amount to charge. */
+    amount: number;
+    /** ISO currency code (e.g., "EUR", "USD"). */
+    currency: string;
+    /** Total amount including taxes/fees. */
+    total: number;
+    /** Itemized breakdown of the purchase. */
+    items: Array<{
+        /** Name or description of the item. */
+        item: string;
+        /** Price per unit. */
+        price?: number;
+        /** Number of units. */
+        quantity?: number;
+    }>;
+}
+/**
+ * Style of haptic feedback.
+ */
+type HapticStyleType = "light" | "medium" | "heavy" | "rigid" | "soft" | "success" | "warning" | "error";
+/**
+ * Network Proxy Types
+ */
+/**
+ * The HTTP method to use as request method
+ */
+type NetworkMethodType = "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+/**
+ * Configuration for network proxy requests.
+ */
+interface INetworkOptions {
+    /** Full URL for the request. */
+    url: string;
+    /** HTTP method to use. */
+    method: NetworkMethodType;
+    /** Request body for POST/PUT/PATCH. */
+    body?: unknown;
+    /** Custom HTTP headers. */
+    headers?: Record<string, string>;
+}
+/**
+ * Response from a network proxy request.
+ */
+interface INetworkResponse<T = unknown> {
+    /** HTTP status code. */
+    status: number;
+    /** Response data payload. */
+    data: T;
+    /** Response headers. */
+    headers: Headers;
+}
+/**
+ * Fidelity & Rewards Types
+ */
+/**
+ * Fidelity program balance information.
+ */
+interface IFidelityBalance {
+    /** Current point or currency balance. */
+    balance: number;
+    /** Name or symbol of the fidelity currency (e.g., "FPoints"). */
+    currency: string;
+}
+/**
+ * Parameters for retrieving fidelity transaction history.
+ */
+interface IFidelityHistoryParams {
+    /** Maximum number of records to return. */
+    limit?: number;
+    /** Cursor for pagination; null for the first page. */
+    cursor?: string | null;
+}
+/** Type of transaction: credit (add) or debit (remove). */
+type FidelityTransactionTypeType = "credit" | "debit";
+/**
+ * A single fidelity program transaction.
+ */
+interface IFidelityTransaction {
+    /** Unique identifier for the transaction. */
+    id: string;
+    /** Amount of the transaction. */
+    amount: number;
+    /** Human-readable description. */
+    description: string;
+    /** ISO 8601 date string. */
+    date: string;
+    /** Type of transaction */
+    type: FidelityTransactionTypeType;
+}
+/**
+ * The initialization options required to set up the Mini-App SDK.
+ */
+type IInitializationOptions = {};
+/**
+ * The post initialization response
+ */
+interface IInitializationResponse<Env extends Record<string, unknown> = Record<string, unknown>, UserData extends Record<string, unknown> = Record<string, unknown>, Params extends Record<string, unknown> = Record<string, unknown>> {
+    /** The name of the mini app */
+    name: string;
+    /** The uuid of the mini app */
+    uuid: string;
+    /** The description of the mini app */
+    description: string;
+    /** The authors of the mini app */
+    authors?: string;
+    /** The current version in the registry */
+    version?: string;
+    /** The scoped profile based on the requested fields during initialization or the getUserProfile call */
+    profile: Partial<IUserProfile | null>;
+    /** The environment variables defined for the mini app in the shell's backend */
+    env: Env;
+    /** The user data passed during the initialization or the setUserData call */
+    userData: UserData;
+    /** The params passed during the initialization */
+    params: Params;
+    /** The edge insets of the mini app, representing the padding around the mini app's view within the Host Shell. */
+    insets: IEdgeInsets;
+}
+/**
+ * Events emitted by the UI module.
+ */
+declare enum UIEvent {
+    /** Triggered when the user performs a native "Pull-to-Refresh". */
+    TOP_SCROLL_MORE = "TOP_SCROLL_MORE",
+    /** Triggered when the user scrolls near the bottom of the page (within 200px threshold). */
+    BOTTOM_SCROLL_MORE = "BOTTOM_SCROLL_MORE",
+    /** Triggered when the user performs a native back gesture or presses the native back button. */
+    BACK_GESTURE = "BACK_GESTURE"
+}
+/**
+ * Events emitted by the Geolocation module.
+ */
+declare enum GeolocationEvent {
+    /** Triggered when the user's location is updated (legacy polling). */
+    LOCATION_UPDATE = "LOCATION_UPDATE",
+    /** Triggered by the continuous location stream. */
+    LOCATION_STREAM_UPDATE = "LOCATION_STREAM_UPDATE"
+}
+/**
+ * Configuration options for the location stream.
+ */
+interface LocationStreamConfig {
+    /** Polling cycle rate in milliseconds. Default: 250 */
+    interval?: number;
+    /** Distance change in meters to trigger an update. Default: 5 */
+    distanceFilter?: number;
+    /** Heading change in degrees to trigger an update. Default: 5 */
+    headingThreshold?: number;
+    /** Accelerometer delta in G-force to trigger an update. Default: 0.1 */
+    accelerometerThreshold?: number;
+}
+interface StreamLocationData {
+    coords: {
+        latitude: number;
+        longitude: number;
+        altitude: number | null;
+        accuracy: number | null;
+        altitudeAccuracy: number | null;
+        heading: number | null;
+        speed: number | null;
+    };
+    timestamp: number;
+}
+interface StreamHeadingData {
+    magneticHeading: number;
+    trueHeading: number;
+    accuracy: number;
+}
+interface StreamAccelerometerData {
+    x: number;
+    y: number;
+    z: number;
+}
+interface StreamUpdatePayload {
+    location: StreamLocationData;
+    heading: StreamHeadingData;
+    accelerometer: StreamAccelerometerData | null;
+    timestamp: number;
+}
+/**
+ * Global events emitted by the Host Shell that may affect the mini-app's context.
+ */
+declare enum GlobalEvent {
+    /** Triggered when the Host Shell sends an update event to the mini-app, indicating changes in context. */
+    UPDATE_CONTEXT = "UPDATE_CONTEXT"
+}
+/**
+ * Union type for all SDK events, allowing for both known enums and custom strings.
+ * The (string & {}) pattern preserves IntelliSense for enum members.
+ */
+type SDKEvent = UIEvent | GeolocationEvent | GlobalEvent | (string & {});
+/**
+ * Configuration for native scroll interactions managed by the Host Shell.
+ */
+interface ScrollConfig {
+    /** Configuration for Pull-to-Refresh (Top). */
+    topScrollMore?: {
+        /** Show/hide the native RefreshControl. */
+        enabled: boolean;
+        /** Set to true to show the loading spinner, false to hide it. */
+        refreshing?: boolean;
+    };
+    /** Configuration for Infinite Scroll (Bottom). */
+    bottomScrollMore?: {
+        /** Enable/disable bottom scroll detection. */
+        enabled: boolean;
+        /** If false, detection stops and the indicator is hidden. */
+        hasMore?: boolean;
+        /** Set to true to show the bottom ActivityIndicator. */
+        loadingMore?: boolean;
+    };
+}
+/**
+ * Edge insets representing padding or margins around a component, typically used for layout purposes.
+ */
+interface IEdgeInsets {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+/**
+ * The context state of the mini-app, which includes dynamic properties provided by the Host Shell, such as edge insets for layout adjustments. This type can be extended with additional properties as needed.
+ */
+type IContextState = Record<string, any> & {
+    insets: IEdgeInsets;
+};
+
+/**
+ * Internal message envelope for bridge communication.
+ * @internal
+ */
+interface IBridgeEnvelope<P = unknown, V = unknown> {
+    /** Unique identifier to match responses with requests. */
+    callbackId?: string;
+    /** The type/action of the message. */
+    type?: string;
+    /** Event name for pushed notifications (new protocol). */
+    eventName?: string;
+    /** Data payload for the message. */
+    payload?: P;
+    /** Whether the operation was successful. */
+    success?: boolean;
+    /** Error message if success is false. */
+    error?: string;
+    /** The result value for successful operations. */
+    value?: V;
+    /** Event name for pushed notifications (legacy protocol). */
+    event?: string;
+}
+/**
+ * The messages the bridge can ask for
+ */
+type BridgeMessageType = {
+    type: "STORAGE_SET";
+    payload: {
+        key: string;
+        value: string;
+    };
+    callbackId: string;
+} | {
+    type: "STORAGE_GET";
+    payload: {
+        key: string;
+    };
+    callbackId: string;
+} | {
+    type: "STORAGE_GET_ALL";
+    payload?: unknown;
+    callbackId: string;
+} | {
+    type: "GET_LOCATION";
+    payload?: unknown;
+    callbackId: string;
+} | {
+    type: "INITIALIZE";
+    payload: {
+        options: IInitializationOptions;
+    };
+    callbackId: string;
+} | {
+    type: "DEBUG_LOG";
+    payload: {
+        message: unknown[];
+    };
+    callbackId: string;
+} | {
+    type: "SECURE_SET";
+    payload: {
+        key: string;
+        value: string;
+    };
+    callbackId: string;
+} | {
+    type: "SECURE_GET";
+    payload: {
+        key: string;
+    };
+    callbackId: string;
+} | {
+    type: "PAYMENT_REQUEST";
+    payload: unknown;
+    callbackId: string;
+} | {
+    type: "START_ACTIVITY";
+    payload: unknown;
+    callbackId: string;
+} | {
+    type: "GET_USER_PROFILE";
+    payload?: {
+        fields?: string[];
+    };
+    callbackId: string;
+} | {
+    type: "SPEND_FPOINTS";
+    payload: {
+        intentUuid: string;
+    };
+    callbackId: string;
+} | {
+    type: "GET_FIDELITY_BALANCE";
+    payload?: unknown;
+    callbackId: string;
+} | {
+    type: "GET_FIDELITY_HISTORY";
+    payload: IFidelityHistoryParams;
+    callbackId: string;
+} | {
+    type: "EXIT";
+    payload?: unknown;
+    callbackId: string;
+} | {
+    type: "DATABASE_GET_USER_DATA";
+    payload?: unknown;
+    callbackId: string;
+} | {
+    type: "DATABASE_SET_USER_DATA";
+    payload: {
+        data: unknown;
+    };
+    callbackId: string;
+} | {
+    type: "REQUEST_PERMISSION";
+    payload: {
+        type: "location" | "profile";
+        fields?: string[];
+    };
+    callbackId: string;
+} | {
+    type: "TRIGGER_HAPTIC";
+    payload?: {
+        style?: HapticStyleType;
+    };
+    callbackId: string;
+} | {
+    type: "NETWORK_REQUEST";
+    payload: {
+        url: string;
+        method?: string;
+        headers?: Record<string, string>;
+        body?: unknown;
+    };
+    callbackId: string;
+} | {
+    type: "SET_SCROLL_CONFIG";
+    payload: ScrollConfig;
+    callbackId: string;
+} | {
+    type: "SDK_ROUTING_GETROUTE";
+    payload: {
+        sdkVersion: string;
+        requestId: string;
+        payload: {
+            origin: [number, number];
+            destination: [number, number];
+            waypoints?: [number, number][];
+            profile: "driving" | "cycling" | "walking";
+            language?: string;
+        };
+    };
+    callbackId: string;
+} | {
+    type: "SDK_ROUTING_DRAWROUTE";
+    payload: {
+        sdkVersion: string;
+        requestId: string;
+        payload: {
+            routeData: unknown;
+        };
+    };
+    callbackId: string;
+} | {
+    type: "SDK_ROUTING_CLEARROUTE";
+    payload: {
+        sdkVersion: string;
+        requestId: string;
+    };
+    callbackId: string;
+} | {
+    type: "UPDATE_CONTEXT";
+    payload: Record<string, unknown>;
+    callbackId: string;
+} | {
+    type: "START_LOCATION_STREAM";
+    payload?: LocationStreamConfig;
+    callbackId: string;
+} | {
+    type: "STOP_LOCATION_STREAM";
+    payload?: never;
+    callbackId: string;
+} | {
+    type: string;
+    payload: unknown;
+    callbackId: string;
+};
+
+type DrawerState = "closed" | "peek" | "full";
+interface POI {
+    id: string | number;
+    name: string;
+    longitude: number;
+    latitude: number;
+    type?: "bar" | "restaurant" | "shop" | string;
+    description?: string;
+    rating?: number;
+    metadata?: Record<string, unknown>;
+    /**
+     * Custom image URL for GL layer.
+     * If provided, the SDK will automatically load and cache this image.
+     */
+    imageUrl?: string;
+    /**
+     * Emoji character to display in GL layer (fallback if no icon).
+     */
+    emoji?: string;
+    /**
+     * Name of a sprite from the map style's sprite sheet (e.g., 'beer', 'cafe').
+     * If provided, this takes priority over emoji and default types.
+     */
+    spriteName?: string;
+    /**
+     * Whether to render as a native GL layer (performant) or a React Marker (flexible).
+     * Defaults to 'gl'.
+     */
+    displayMode?: "gl" | "marker";
+    /**
+     * Optional custom React component when displayMode is 'marker'.
+     */
+    markerComponent?: React.ReactNode;
+}
+interface MapProps {
+    /** Initial view state of the map. */
+    initialViewState?: Partial<ViewState>;
+    /** Inline styles for the map container. */
+    style?: React.CSSProperties;
+    /** Minimum and maximum bounds for the map. */
+    maxBounds?: [[number, number], [number, number]];
+    /** MapLibre style URL. Defaults to local server. */
+    mapStyle?: string;
+    /** Children components (Source, Layer, etc.) */
+    children?: React.ReactNode;
+    /** Additional CSS classes for the map container. */
+    className?: string;
+    /** Callback when the map is clicked. */
+    onClick?: (e: any) => void;
+    /** Callback when the map is clicked, but no interactive layers or POIs are hit. */
+    onMapClickMiss?: (e: any) => void;
+    /** Callback when the map is right-clicked or long-pressed. */
+    onContextMenu?: (e: any) => void;
+    /** IDs of layers that should be interactive. */
+    interactiveLayerIds?: string[];
+    /** Callback when the map is loaded. */
+    onLoad?: (e: any) => void;
+    /**
+     * Whether to show the user's current location on the map.
+     * Defaults to true.
+     */
+    showUserLocation?: boolean;
+    /**
+     * Whether the map should follow the user's location.
+     * Usually combined with showUserLocationButton for manual override.
+     * Note: The camera automatically locks when a route is provided.
+     */
+    followUser?: boolean;
+    /**
+     * Whether to show the built-in "Center on User" button.
+     * Defaults to true.
+     */
+    showUserLocationButton?: boolean;
+    /**
+     * Custom renderer for the user's location marker.
+     * If provided, overrides the default pulsating blue dot.
+     */
+    renderUserLocation?: (props: {
+        coords: [number, number];
+        heading: number | null;
+    }) => React.ReactNode;
+    /** A list of POIs to display. */
+    pois?: POI[];
+    /** Callback when a POI is clicked. */
+    onPoiClick?: (poi: POI) => void;
+    /** Route geometry to display on the map. */
+    route?: GeoJSON.LineString;
+    /** Whether to show the out-of-the-box navigation UI. */
+    showNavigationUI?: boolean;
+    /** Callback triggered when the user aborts/closes the navigation UI. */
+    onNavigationAbort?: () => void;
+    /**
+     * Integrated navigation configuration.
+     * If provided, the Map component will internally manage route calculation and tracking.
+     */
+    navigation?: {
+        /** Destination coordinates [lng, lat] */
+        destination: [number, number] | null;
+        /** Transport profile. Defaults to 'driving'. */
+        profile?: "driving" | "cycling" | "walking";
+        /** Minimum distance in meters the user must move before recalculating path geometry. Defaults to 50. */
+        recalculateThreshold?: number;
+        /** Whether to automatically show the navigation UI. Defaults to true if destination is set. */
+        showUI?: boolean;
+        /** Optional manual origin. Defaults to real-time user location. */
+        origin?: [number, number] | null;
+        /**
+         * Initial mode for the navigation.
+         * 'preview' shows the full route overview.
+         * 'navigation' starts active turn-by-turn tracking.
+         * Defaults to 'preview'.
+         */
+        mode?: "preview" | "navigation";
+    };
+    /** Callback triggered when the navigation mode changes (e.g. from preview to navigation). */
+    onNavigationModeChange?: (mode: "preview" | "navigation") => void;
+    /**
+     * The data for the navigation UI.
+     * Usually provided by the useLiveRouting hook.
+     * Note: This is automatically populated if the 'navigation' prop is used.
+     */
+    navigationData?: {
+        route: RouteResponse["data"] | null;
+        currentDistanceMeters?: number | null;
+        totalDistance?: number | null;
+        isCalculating?: boolean;
+        error?: string | null;
+        /** Current mode: 'preview' (overview) or 'navigation' (active guidance) */
+        mode?: "preview" | "navigation";
+        /** Function to transition to active navigation mode */
+        start?: () => void;
+    };
+    /** Whether to show the vertical drawer and floating right controls. Defaults to true. */
+    showControls?: boolean;
+    /** Custom menu items to display in the vertical drawer. */
+    menuItems?: MenuItem[];
+    /** Custom React node to render inside the drawer menu container instead of menuItems list. */
+    menuContent?: React.ReactNode;
+    /** Programmatically control the drawer state. */
+    drawerState?: DrawerState;
+    /** Ref to the drawer's scrollable container. */
+    drawerContentRef?: React.Ref<HTMLDivElement>;
+    /** Custom controls (e.g. buttons) to display floating above the recenter button. */
+    controlProps?: MapControlsProps;
+    /** Whether to enable touch drag gestures for the bottom sheet drawer. Defaults to false. */
+    enableTouchDrag?: boolean;
+}
+interface MenuItem {
+    id: string;
+    label: string;
+    icon: React.ReactNode;
+    onPress: () => void;
+    badge?: string | number;
+    disabled?: boolean;
+}
+interface CustomControl {
+    id: string;
+    icon: React.ReactNode;
+    onPress: () => void;
+    position: "above-recenter" | "below-recenter";
+    tooltip?: string;
+    activeState?: boolean;
+}
+interface EtaData {
+    etaMins: number;
+    distanceRemainingKm: number;
+    label?: string;
+    progress?: number;
+    mode?: "preview" | "navigation";
+    onAbort?: () => void;
+    onStart?: () => void;
+    isCalculating?: boolean;
+    error?: string | null;
+}
+
+interface MapInsets {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+}
+interface MapControlsState {
+    isFollowing: boolean;
+    setIsFollowing: (following: boolean) => void;
+    centerOnUser: (params?: CenterCallbackParams) => void;
+    bearing: number;
+    setBearing: (bearing: number) => void;
+    pitch: number;
+    setPitch: (pitch: number) => void;
+    resetBearing: (params?: CenterCallbackParams) => void;
+    etaData?: EtaData;
+    setEtaData: (data?: EtaData) => void;
+    hasControls: boolean;
+    setHasControls: (hasControls: boolean) => void;
+    drawerState: DrawerState;
+    setDrawerState: (state: DrawerState) => void;
+    /** Stable ref to the drawer's scrollable container. Always available. */
+    drawerContentRef: React.RefObject<HTMLDivElement | null>;
+    insets: MapInsets;
+    setInsets: (insets: Partial<MapInsets>) => void;
+}
+interface CenterCallbackParams {
+    pitch?: number;
+}
+interface MapControlsContextType extends MapControlsState {
+    _registerCenterCallback: (cb: (params?: CenterCallbackParams) => void) => void;
+    _registerResetBearingCallback: (cb: (params?: CenterCallbackParams) => void) => void;
+}
+declare const MapControlsContext: React.Context<MapControlsContextType | null>;
+declare const SDKMapProvider: React.FC<{
+    children: React.ReactNode;
+}>;
+declare const useMapControls: () => MapControlsState;
+
+interface MapControlsProps {
+    menuItems?: MenuItem[];
+    drawerSide?: "left" | "bottom";
+    defaultState?: DrawerState;
+    menuContent?: React.ReactNode;
+    children?: React.ReactNode;
+    customControls?: CustomControl[];
+    etaBarHeight?: number;
+    onRecenter?: (params?: CenterCallbackParams) => void;
+    isMapCentered?: boolean;
+    mapBearing?: number;
+    initialViewState?: Partial<ViewState>;
+    onResetBearing?: (params?: CenterCallbackParams) => void;
+    etaData?: EtaData;
+    customRecenterButton?: React.ReactNode;
+    customCompassButton?: React.ReactNode;
+    drawerPeekHeight?: string | number;
+    drawerFullHeight?: string | number;
+    drawerContentRef?: React.Ref<HTMLDivElement>;
+    enableTouchDrag?: boolean;
+    showScrollToTopButton?: boolean;
+    scrollToTopThreshold?: number;
+    isInternal?: boolean;
+}
+declare const MapControls: React.FC<MapControlsProps>;
+
+interface MapMenuProps {
+    children?: React.ReactNode;
+}
+declare const MapMenu: React.FC<MapMenuProps>;
+interface MapMenuItemProps {
+    id: string;
+    label: string;
+    icon?: React.ReactNode;
+    onPress?: () => void;
+    badge?: string | number;
+    disabled?: boolean;
+    children?: React.ReactNode;
+}
+declare const MapMenuItem: React.FC<MapMenuItemProps>;
+interface MapMenuTitleProps {
+    children: React.ReactNode;
+    className?: string;
+    showDivider?: boolean;
+}
+declare const MapMenuTitle: React.FC<MapMenuTitleProps>;
+interface MapMenuDividerProps {
+    className?: string;
+}
+declare const MapMenuDivider: React.FC<MapMenuDividerProps>;
+interface MapMenuFooterProps {
+    children: React.ReactNode;
+    className?: string;
+}
+declare const MapMenuFooter: React.FC<MapMenuFooterProps>;
+
+interface LiveRoutingOptions {
+    /** Origin coordinates [lng, lat]. If not provided, uses device location. */
+    origin?: [number, number] | null;
+    /** Destination coordinates [lng, lat] */
+    destination: [number, number] | null;
+    /** Transport profile. Defaults to 'driving'. */
+    profile?: "driving" | "cycling" | "walking";
+    /** Minimum distance in meters the user must move before recalculating path geometry. Defaults to 50. */
+    recalculateThreshold?: number;
+    /** Whether live routing is active. */
+    enabled?: boolean;
+    /** Initial mode: 'preview' or 'navigation'. Defaults to 'preview'. */
+    initialMode?: "preview" | "navigation";
+}
+interface LiveRoutingResult {
+    /** The calculated route data from the last API call */
+    route: RouteResponse["data"] | null;
+    /** Real-time distance to destination in meters */
+    currentDistanceMeters: number | null;
+    /** The initial total distance when the destination was first set */
+    totalDistance: number | null;
+    /** Whether a new calculation is in progress */
+    isCalculating: boolean;
+    /** Any error message from the routing service */
+    error: string | null;
+    /** Force a manual recalculation */
+    recalculate: () => void;
+    /** Current mode: 'preview' (overview) or 'navigation' (active guidance) */
+    mode: "preview" | "navigation";
+    /** Start active navigation (switch mode to 'navigation') */
+    start: () => void;
+}
+declare const useLiveRouting: ({ origin: manualOrigin, destination, profile, recalculateThreshold, enabled, initialMode, }: LiveRoutingOptions) => LiveRoutingResult;
+/**
+ * A simple hook to fetch a route once between two points.
+ * Does not automatically recalculate or track user location.
+ */
+declare const useRoute: (origin: [number, number] | null, destination: [number, number] | null, profile?: "driving" | "cycling" | "walking") => {
+    error: string | null;
+    isCalculating: boolean;
+    route: {
+        geometry: GeoJSON.LineString;
+        distanceMeters: number;
+        durationSeconds: number;
+        steps?: RouteStep[];
+    } | null | undefined;
+};
+
+/**
+ * Slices a LineString to start at the point closest to the provided coordinates.
+ * This removes the "already traveled" portion of the route.
+ */
+declare const useTrimmedRoute: (route: GeoJSON.LineString | undefined, userLocation: [number, number] | null) => GeoJSON.LineString | undefined;
+
+interface UserLocationState {
+    coords: [number, number] | null;
+    heading: number | null;
+    accuracy: number | null;
+}
+declare const useUserLocation: () => UserLocationState;
+
+interface RouteLayerProps {
+    /** The route geometry as a GeoJSON LineString */
+    geometry?: GeoJSON.LineString;
+    /** Color of the route line. Defaults to #3b82f6 (blue-500). */
+    color?: string;
+    /** Width of the route line. Defaults to 5. */
+    width?: number;
+    /** Opacity of the route line. Defaults to 0.8. */
+    opacity?: number;
+}
+declare const RouteLayer: React.FC<RouteLayerProps>;
+
+declare const Map: React.FC<MapProps>;
+
+/**
+ * Renders the Map component into a DOM element.
+ * Useful for non-React environments (UMD/IIFE).
+ *
+ * @param containerId The ID of the HTML element where the map should be rendered.
+ * @param props The props to pass to the Map component.
+ * @returns The React root instance.
+ */
+declare function renderMap(containerId: string, props?: MapProps): react_dom_client.Root;
+
+/**
+ * Hook to check if the SDK is currently running in mock mode (browser)
+ * or native mode (shell app).
+ */
+declare const useIsMocked: () => boolean;
+interface SDKProviderProps extends Partial<Omit<BridgeMockerProps, "children">> {
+    children: React.ReactNode;
+    /**
+     * If true, shows the standalone DebugConsole for bridge traffic.
+     */
+    debug?: boolean;
+}
+/**
+ * A wrapper component that automatically enables the BridgeMocker
+ * when running outside the native shell app.
+ */
+declare const SDKProvider: React.FC<SDKProviderProps>;
+
+declare class MiniAppSDK {
+    /**
+     * Map services.
+     * Provides access to MapLibre-based mapping components.
+     */
+    readonly maps: Readonly<{
+        /**
+         * Renders a MapLibre map into a DOM element.
+         * Useful for non-React environments.
+         */
+        render: typeof renderMap;
+    }>;
+    private bridge;
+    /**
+     * Local SQLite Storage.
+     * Data is persisted on the device and is isolated per Mini-App.
+     */
+    readonly storage: Readonly<{
+        /** Retrieves a value by key. */
+        get: (key: string) => Promise<string | null>;
+        /** Retrieves all key-value pairs stored for this Mini-App. */
+        getAll: () => Promise<Record<string, string>>;
+        /** Sets a value for a specific key. */
+        set: (key: string, value: string) => Promise<void>;
+    }>;
+    /**
+     * Hardware-level Secure Storage.
+     * Data is stored in the device's secure enclave (Keychain/Keystore) and is isolated per Mini-App.
+     */
+    readonly secureStore: Readonly<{
+        /** Retrieves a value by key from secure storage. */
+        get: (key: string) => Promise<string | null>;
+        /** Sets a value for a specific key in secure storage. */
+        set: (key: string, value: string) => Promise<void>;
+    }>;
+    /**
+     * Database Storage.
+     * Access to user-app specific persistent database storage.
+     */
+    readonly database: Readonly<{
+        /** Retrieves the user data stored in the backend database. */
+        getUserData: <T = unknown>() => Promise<T>;
+        /** Updates the user data stored in the backend database. */
+        setUserData: <T = unknown>(data: T) => Promise<void>;
+    }>;
+    /**
+     * Device Location services.
+     */
+    readonly location: Readonly<{
+        /**
+         * Retrieves the current GPS position of the device.
+         */
+        getCurrentPosition: () => Promise<ILocationData>;
+        /**
+         * Starts the continuous location and sensor stream.
+         * @param config Optional configuration for thresholds and intervals.
+         */
+        startStream: (config?: LocationStreamConfig) => Promise<void>;
+        /**
+         * Stops the continuous location and sensor stream.
+         */
+        stopStream: () => Promise<void>;
+    }>;
+    /**
+     * Identity & Profile management.
+     */
+    readonly user: Readonly<{
+        /**
+         * Fetch user profile data.
+         * @param fields Optional list of specific fields to retrieve (e.g., ['fullName', 'username']).
+         */
+        getProfile: <T extends keyof IUserProfile>(fields?: T[]) => Promise<Partial<IUserProfile>>;
+    }>;
+    /**
+     * Explicit Permission Management.
+     * Allows requesting access to sensitive device features or user data.
+     */
+    readonly permission: Readonly<{
+        /**
+         * Explicitly request access to sensitive data.
+         * @param type The type of permission to request ('location' or 'profile').
+         * @param fields If requesting 'profile', the specific fields required.
+         */
+        request: {
+            (type: "location"): Promise<boolean>;
+            (type: "profile", fields: (keyof IUserProfile)[]): Promise<boolean>;
+        };
+    }>;
+    /**
+     * Payments integration.
+     */
+    readonly payment: Readonly<{
+        /**
+         * Triggers the native payment flow.
+         * @param payload Amount, currency, and itemized list for the payment.
+         */
+        request: (payload: IPaymentRequest) => Promise<{
+            success: true;
+            transactionId: string;
+        }>;
+    }>;
+    /**
+     * Live Activities & Notifications.
+     * Allows the Mini-App to display real-time updates in the host shell.
+     */
+    readonly activity: Readonly<{
+        /**
+         * Starts a new live activity.
+         * @param id Unique identifier for the activity.
+         * @param title Display title for the activity.
+         * @param status Initial status message.
+         */
+        start: (id: string, title: string, status: string) => Promise<void>;
+    }>;
+    /**
+     * Haptic feedback.
+     */
+    readonly haptic: Readonly<{
+        /**
+         * Triggers a haptic vibration on the device.
+         * @param style The style of haptic feedback (e.g., 'light', 'medium', 'heavy', 'success', 'warning', 'error').
+         */
+        trigger: (style: HapticStyleType) => Promise<void>;
+    }>;
+    /**
+     * Network Proxy.
+     * Allows the Mini-App to make network requests through the host shell to bypass CORS or use host-level authentication.
+     */
+    readonly network: Readonly<{
+        /**
+         * Performs a network request via the host shell.
+         * @param options Request method, URL, headers, and body.
+         */
+        request: <T = unknown>(options: INetworkOptions) => Promise<INetworkResponse<T>>;
+    }>;
+    /**
+     * Navigation and Journey controls.
+     * Allows programmatically starting itineraries and managing navigation state.
+     */
+    readonly navigation: Readonly<{
+        /**
+         * Aborts the current navigation journey.
+         */
+        abort: () => void;
+        /**
+         * Creates a new itinerary preview.
+         * @param options Destination and routing options.
+         */
+        createJourney: (options: {
+            destination: [number, number];
+            origin?: [number, number];
+            profile?: "driving" | "cycling" | "walking";
+        }) => void;
+        /**
+         * Starts the active navigation (active guidance).
+         */
+        start: () => void;
+    }>;
+    /**
+     * Fidelity & Rewards program integration.
+     */
+    readonly fidelity: Readonly<{
+        /** Returns current fidelity balance. */
+        getFidelityBalance: () => Promise<IFidelityBalance>;
+        /**
+         * Retrieves fidelity transaction history.
+         * @param params Filtering and pagination parameters.
+         */
+        getFidelityHistory: (params?: IFidelityHistoryParams) => Promise<IFidelityTransaction[]>;
+        /**
+         * Triggers the native fidelity history view.
+         */
+        showHistory: () => Promise<void>;
+        /**
+         * Authorize spending fidelity points (FPoints) via Two-Phase Authorization.
+         * @param intentUuid UUID generated by your backend for the transaction.
+         */
+        spendFPoints: (intentUuid: string) => Promise<{
+            success: boolean;
+            transactionId: string;
+        }>;
+    }>;
+    /**
+     * UI and Navigation controls.
+     */
+    readonly ui: Readonly<{
+        /** Closes the Mini-App and returns to the host shell. */
+        exit: () => Promise<void>;
+        /**
+         * Configures native scroll behaviors like Pull-to-Refresh and Infinite Scroll.
+         * @param config Scroll configuration for top/bottom detection.
+         */
+        setScrollConfig: (config: ScrollConfig) => Promise<void>;
+    }>;
+    /**
+     * Debug controls
+     */
+    readonly debug: Readonly<{
+        /**
+         * Log to the shell app
+         * @param message
+         */
+        log: (...message: unknown[]) => Promise<unknown>;
+    }>;
+    /**
+     * Routing integration (OSRM / Valhalla).
+     * Provides access to route calculation and rendering on the host map.
+     */
+    readonly routing: Readonly<{
+        /**
+         * Clears the currently rendered route.
+         */
+        clearRoute: () => Promise<void>;
+        /**
+         * Draws the calculated route on the host map.
+         * @param routeData The route data returned by getRoute.
+         */
+        drawRoute: (routeData: NonNullable<RouteResponse["data"]>) => Promise<void>;
+        /**
+         * Calculates a route between points.
+         * @param payload Request payload containing origin, destination, and options.
+         */
+        getRoute: (payload: RouteRequest["payload"]) => Promise<NonNullable<RouteResponse["data"]>>;
+    }>;
+    constructor();
+    /**
+     * Configures global SDK settings.
+     */
+    config(options: {
+        routingBackend?: RoutingBackendConfig;
+    }): void;
+    /**
+     * Updates the global context shared between the Mini-App and the native shell.
+     * Useful for synchronizing state like theme preferences, UI flags, or custom app-specific context.
+     * @param context Partial context object to merge into the existing shell context.
+     */
+    updateContext(context: Record<string, unknown>): Promise<void>;
+    /**
+     * The starting point for the Mini-App. Must be called before any other SDK methods.
+     * @param options The options to provide to the shell app
+     */
+    initialize(options: IInitializationOptions): Promise<IInitializationResponse>;
+    /**
+     * Registers a callback for a specific event from the native shell.
+     * @param event The name of the event to listen for.
+     * @param callback The function to execute when the event is triggered.
+     * @returns A function to unregister the listener.
+     */
+    on<T = unknown>(event: SDKEvent, callback: (data: T) => void): () => void;
+    /**
+     * Unregisters a previously registered event listener.
+     * @param event The name of the event.
+     * @param callback The callback function to remove.
+     */
+    off<T = unknown>(event: SDKEvent, callback: (data: T) => void): void;
+}
+/**
+ * Singleton instance of the MiniAppSDK.
+ * Frozen to prevent tampering.
+ */
+declare const sdk: MiniAppSDK;
+
+export { type BridgeMessageType, BridgeMocker, type BridgeMockerProps, type CenterCallbackParams, type CustomControl, DebugConsole, type DebugConsoleProps, type DrawerState, type EtaData, type FidelityTransactionTypeType, GeolocationEvent, GlobalEvent, type HapticStyleType, type IBridgeEnvelope, type IContextState, type IEdgeInsets, type IFidelityBalance, type IFidelityHistoryParams, type IFidelityTransaction, type IInitializationOptions, type IInitializationResponse, type ILocationData, type INetworkOptions, type INetworkResponse, type IPaymentRequest, type IUserProfile, type LiveRoutingOptions, type LiveRoutingResult, type LocationStreamConfig, Map, MapControls, MapControlsContext, type MapControlsProps, type MapControlsState, type MapInsets, MapMenu, MapMenuDivider, type MapMenuDividerProps, MapMenuFooter, type MapMenuFooterProps, MapMenuItem, type MapMenuItemProps, type MapMenuProps, MapMenuTitle, type MapMenuTitleProps, type MapProps, type MenuItem, MiniAppSDK, type NetworkMethodType, type POI, RouteLayer, type RouteLayerProps, RouteRequest, RouteResponse, RouteStep, type SDKEvent, SDKMapProvider, SDKProvider, type SDKProviderProps, type ScrollConfig, type StreamAccelerometerData, type StreamHeadingData, type StreamLocationData, type StreamUpdatePayload, UIEvent, type UserLocationState, sdk as default, renderMap, sdk, useIsMocked, useLiveRouting, useMapControls, useRoute, useTrimmedRoute, useUserLocation };