@texturehq/edges 1.2.1 → 1.3.1

package/dist/{server-C1hypeJ9.d.cts → server-Utz6Sv9w.d.cts}

@@ -628,221 +628,489 @@ interface LogoProps {
  */
 declare const Logo: ({ className, showWordmark, width, fill }: LogoProps) => react_jsx_runtime.JSX.Element;
 
-interface MapPoint {
+/**
+ * Layer System Types
+ *
+ * A clean, developer-friendly API for defining map layers that abstracts
+ * away Mapbox jargon while supporting vector tiles, GeoJSON, and custom markers.
+ */
+/**
+ * Color specification - supports design tokens, hex values, or property-based mapping
+ */
+type ColorSpec = {
+    token: string;
+} | {
+    hex: string;
+} | {
+    by: string;
+    mapping: Record<string, ColorSpec>;
+};
+/**
+ * Zoom-based interpolation for numeric values
+ */
+type ZoomStops<T extends number | string> = {
+    byZoom: [zoom: number, value: T][];
+};
+/**
+ * Numeric value that can be static or zoom-based
+ */
+type NumericValue = number | ZoomStops<number>;
+/**
+ * Color value that can be static, token-based, or property-driven
+ */
+type ColorValue = ColorSpec | string;
+/**
+ * Style configuration for rendering layers
+ */
+interface LayerStyle {
+    /** Line/border/fill color */
+    color?: ColorValue;
+    /** Line width in pixels */
+    width?: NumericValue;
+    /** Circle radius in pixels */
+    radius?: NumericValue;
+    /** Overall opacity (0-1) */
+    opacity?: number;
+    /** Fill opacity for polygons (0-1) */
+    fillOpacity?: number;
+    /** Border width for fills */
+    borderWidth?: number;
+    /** Border color for fills */
+    borderColor?: ColorValue;
+}
+/**
+ * How to render the layer geometry
+ */
+type RenderType = "line" | "fill" | "circle" | "symbol" | "heatmap";
+/**
+ * Base properties common to all layer types
+ */
+interface BaseLayerSpec {
+    /** Unique identifier for this layer */
     id: string;
-    latitude: number;
-    longitude: number;
-    properties?: Record<string, any>;
+    /** Z-index for layer ordering (higher = on top) */
+    z?: number;
+    /** Whether layer is currently visible */
+    visible?: boolean;
+    /** Minimum zoom level to show layer */
+    minZoom?: number;
+    /** Maximum zoom level to show layer */
+    maxZoom?: number;
+    /** Legend configuration for UI */
+    legend?: {
+        label: string;
+        swatch: "line" | "dot" | "polygon" | "pin";
+        /** Color for the swatch (hex string or design token) */
+        color?: string;
+        /** Optional grouping for organizing layers in the control */
+        group?: string;
+    };
+    /** Event handlers for user interactions */
+    events?: {
+        /** Called when a feature in this layer is clicked */
+        onClick?: (feature: LayerFeature) => void;
+        /** Called when mouse enters a feature in this layer */
+        onMouseEnter?: (feature: LayerFeature) => void;
+        /** Called when mouse leaves a feature in this layer */
+        onMouseLeave?: () => void;
+    };
+    /** Tooltip configuration for this layer */
+    tooltip?: {
+        /** When to show the tooltip */
+        trigger: "hover" | "click";
+        /** Tooltip content - can be a function or static ReactNode */
+        content: ((feature: LayerFeature) => React.ReactNode) | React.ReactNode;
+    };
+}
+/**
+ * Feature data passed to event handlers
+ */
+interface LayerFeature {
+    id: string | number | undefined;
+    lngLat: [number, number];
+    properties: Record<string, any>;
+    layerId: string;
 }
-
 /**
- * Map style configuration for all map components
- * Centralized configuration for theme and color mode handling
+ * Vector tile layer (Mapbox Vector Tiles)
  */
+interface VectorLayerSpec extends BaseLayerSpec {
+    kind: "vector";
+    /** Mapbox tileset URL (mapbox://...) or HTTP template */
+    tileset: string;
+    /** Source layer name within the tileset */
+    sourceLayer: string;
+    /** How to render the geometry */
+    renderAs: RenderType;
+    /** Visual styling */
+    style?: LayerStyle;
+    /** Mapbox filter expression (escape hatch for advanced filtering) */
+    filter?: any;
+}
+/**
+ * GeoJSON layer (client-side data or URL)
+ */
+interface GeoJsonLayerSpec extends BaseLayerSpec {
+    kind: "geojson";
+    /** GeoJSON object or URL returning GeoJSON */
+    data: GeoJSON.FeatureCollection | GeoJSON.Feature | string;
+    /** How to render the geometry */
+    renderAs: RenderType;
+    /** Visual styling */
+    style?: LayerStyle;
+    /** Whether to cluster point features */
+    cluster?: {
+        enabled: boolean;
+        radius?: number;
+        maxZoom?: number;
+    };
+}
+/**
+ * Custom marker layer using React components
+ */
+interface CustomPinsSpec<T = any> extends BaseLayerSpec {
+    kind: "customPins";
+    /**
+     * Array of data items to render as pins
+     * Note: Async functions are not yet supported - fetch data in your component
+     */
+    data: T[];
+    /** Extract [lng, lat] from data item */
+    getPosition: (item: T) => [number, number];
+    /** React component to render for each marker */
+    pin: React.ComponentType<any>;
+    /** Props to pass to pin component */
+    pinProps?: (item: T) => Record<string, any>;
+    /** Client-side clustering configuration */
+    cluster?: {
+        enabled: boolean;
+        radius?: number;
+        maxZoom?: number;
+    };
+}
 /**
- * MAPBOX_THEMES
+ * Raster layer (images from tile servers)
  *
- * Semantic map style themes that automatically adapt to light/dark mode.
- * The visual appearance (light/dark) is determined by the global ColorModeProvider.
+ * Used for satellite imagery, weather overlays, heatmaps from tile servers, etc.
  */
-declare const MAPBOX_THEMES$1: {
-    readonly streets: "mapbox://styles/mapbox/streets-v12";
-    readonly satellite: "mapbox://styles/mapbox/satellite-streets-v12";
-    readonly neutral: "mapbox://styles/mapbox/light-v11";
+interface RasterLayerSpec extends BaseLayerSpec {
+    kind: "raster";
+    /**
+     * Raster tileset URL or tile template
+     * Examples:
+     * - "mapbox://mapbox.satellite"
+     * - "https://tile.openweathermap.org/map/temp_new/{z}/{x}/{y}.png?appid=..."
+     */
+    tileset: string;
+    /** Tile size in pixels (256 or 512) */
+    tileSize?: 256 | 512;
+    /** Raster-specific styling */
+    style?: {
+        /** Overall opacity (0-1) */
+        opacity?: number;
+        /** Minimum brightness (-1 to 1, default 0) */
+        brightnessMin?: number;
+        /** Maximum brightness (-1 to 1, default 1) */
+        brightnessMax?: number;
+        /** Contrast adjustment (-1 to 1, default 0) */
+        contrast?: number;
+        /** Saturation adjustment (-1 to 1, default 0) */
+        saturation?: number;
+        /** Hue rotation in degrees (0-360) */
+        hueRotate?: number;
+        /** Fade duration when new tiles appear (ms, default 300) */
+        fadeDuration?: number;
+    };
+}
+/**
+ * Union of all layer types
+ */
+type LayerSpec = VectorLayerSpec | GeoJsonLayerSpec | CustomPinsSpec | RasterLayerSpec;
+
+/**
+ * Unified map style configuration for all map components
+ *
+ * This module provides semantic map types (streets, satellite, neutral) that
+ * automatically adapt to light/dark mode based on the global ColorModeProvider.
+ */
+/**
+ * Semantic map types available for both InteractiveMap and StaticMap
+ * These are map TYPES, not themes - the actual light/dark theme is determined
+ * automatically by the ColorModeProvider.
+ */
+declare const MAP_TYPES: {
+    readonly streets: "streets";
+    readonly satellite: "satellite";
+    readonly neutral: "neutral";
 };
+/**
+ * Map type - represents the visual style of the map (roads vs satellite vs minimal)
+ */
+type MapType = keyof typeof MAP_TYPES;
 
-interface InteractiveMapProps {
-    data?: MapPoint[];
-    initialViewState?: ViewState;
-    viewState?: ViewState;
-    onViewStateChange?: (viewState: ViewState) => void;
-    onPointClick?: (pointId: string) => void;
-    selectedPointId?: string | null;
-    onCloseDrawer?: () => void;
-    drawerComponent?: React__default.ReactNode;
-    scrollEnabled?: boolean;
+/**
+ * Control position type
+ */
+type ControlPosition = "top-left" | "top-right" | "bottom-left" | "bottom-right";
+/**
+ * Base control configuration
+ */
+interface BaseControl {
+    /**
+     * Optional unique identifier for the control
+     * Useful when rendering multiple controls of the same type
+     * @default auto-generated from type and index
+     */
+    id?: string;
+    /**
+     * Position of the control on the map
+     * @default varies by control type
+     */
+    position?: ControlPosition;
+    /**
+     * Custom inline styles for the control
+     */
+    style?: React.CSSProperties;
+    /**
+     * Additional CSS classes
+     */
     className?: string;
-    previewMode?: boolean;
-    previewModeCta?: React__default.ReactNode;
-    onPreviewModePress?: () => void;
-    workspaceId?: string;
-    mapFilters?: {
-        city?: string[];
-        state?: string[];
-        search?: string;
-    };
-    serverSideClusteringEnabled?: boolean;
+}
+/**
+ * Navigation control configuration (compass + geolocate + optional reset zoom)
+ */
+interface NavigationControl extends BaseControl {
+    type: "navigation";
     /**
-     * Semantic map theme - automatically adapts to light/dark mode
-     * @default "streets"
+     * Show compass button (mobile only)
+     * @default true
      */
-    theme?: keyof typeof MAPBOX_THEMES$1;
-    mapboxAccessToken?: string;
-    transformRequest?: (url: string, resourceType?: string) => {
-        url: string;
-        headers?: Record<string, string>;
-    };
+    showCompass?: boolean;
     /**
-     * Show loading state
+     * Show geolocate button
+     * @default true
+     */
+    showGeolocate?: boolean;
+    /**
+     * Show reset zoom button at the top of the control group
      * @default false
      */
-    isLoading?: boolean;
+    showResetZoom?: boolean;
     /**
-     * Map controls configuration
+     * Callback when reset zoom is clicked
      */
-    controls?: {
-        /**
-         * Show navigation control (compass and geolocate)
-         * @default true
-         */
-        navigation?: boolean;
-        /**
-         * Show layers control
-         * @default false
-         */
-        layers?: boolean;
-        /**
-         * Show search control
-         * @default false
-         */
-        search?: boolean;
-        /**
-         * Show list control
-         * @default false
-         */
-        list?: boolean;
-        /**
-         * Show reset zoom control
-         * @default true
-         */
-        resetZoom?: boolean;
-    };
+    onResetZoom?: () => void;
     /**
-     * Available map layers for the layers control
+     * Callback when compass is clicked
      */
-    mapLayers?: Array<{
-        id: string;
-        name: string;
-        visible: boolean;
-        onToggle: (id: string, visible: boolean) => void;
-    }>;
+    onCompassClick?: () => void;
     /**
-     * List items for the list control
+     * Callback when geolocate is clicked
      */
-    listItems?: Array<{
-        id: string;
-        name: string;
-        onClick: () => void;
-    }>;
+    onGeolocateClick?: () => void;
+}
+/**
+ * Layers control configuration (map type + layer toggles)
+ */
+interface LayersControl extends BaseControl {
+    type: "layers";
     /**
-     * Callback when search is triggered
+     * Current map type
      */
-    onSearch?: (query: string) => void;
+    currentMapType?: MapType;
     /**
-     * Callback when list toggle is clicked
+     * Callback when map type is changed
      */
-    onListToggle?: (isOpen: boolean) => void;
+    onMapTypeChange?: (mapType: MapType) => void;
     /**
-     * Callback when map theme is changed
+     * Layers with legend definitions that should appear in the control
+     * Only layers with a `legend` property will be shown
      */
-    onThemeChange?: (theme: keyof typeof MAPBOX_THEMES$1) => void;
+    layers?: LayerSpec[];
     /**
-     * ISO RTO regions visibility
+     * Callback when a layer's visibility is toggled
      */
-    isoRtoVisible?: boolean;
+    onLayerToggle?: (layerId: string) => void;
+}
+/**
+ * Search control configuration
+ */
+interface SearchControl extends BaseControl {
+    type: "search";
     /**
-     * Callback when ISO RTO regions visibility changes
+     * Callback when search is triggered
      */
-    onIsoRtoToggle?: (visible: boolean) => void;
+    onSearch?: (query: string) => void;
     /**
-     * Vermont substations visibility
+     * Placeholder text for search input
+     * @default "Search places..."
      */
-    vermontSubstationsVisible?: boolean;
+    placeholder?: string;
     /**
-     * Callback when Vermont substations visibility changes
+     * Show search input field
+     * @default true
      */
-    onVermontSubstationsToggle?: (visible: boolean) => void;
+    showSearchInput?: boolean;
+}
+/**
+ * List toggle control configuration
+ */
+interface ListControl extends BaseControl {
+    type: "list";
     /**
-     * Transformers visibility
+     * Callback when list toggle button is clicked
      */
-    transformersVisible?: boolean;
+    onToggle?: () => void;
     /**
-     * Callback when transformers visibility changes
+     * Whether the list view is currently active (for visual feedback)
+     * @default false
      */
-    onTransformersToggle?: (visible: boolean) => void;
+    isActive?: boolean;
+}
+/**
+ * Custom control configuration
+ */
+interface CustomControl extends BaseControl {
+    type: "custom";
     /**
-     * Feeders visibility
+     * Custom render function for the control
      */
-    feedersVisible?: boolean;
+    render: (context: {
+        mapRef: React.RefObject<any>;
+    }) => React.ReactNode;
+}
+/**
+ * Map control discriminated union
+ *
+ * Use this type to configure which controls appear on the map.
+ * Each control type has its own specific configuration options.
+ *
+ * @example
+ * const controls: MapControl[] = [
+ *   { type: 'navigation', position: 'bottom-right', showResetZoom: true },
+ *   { type: 'search', position: 'top-left', onSearch: handleSearch },
+ *   { type: 'list', position: 'top-right', onToggle: toggleList }
+ * ];
+ */
+type MapControl = NavigationControl | LayersControl | SearchControl | ListControl | CustomControl;
+
+interface InteractiveMapProps {
     /**
-     * Callback when feeders visibility changes
+     * Initial camera position
      */
-    onFeedersToggle?: (visible: boolean) => void;
+    initialViewState?: Partial<ViewState>;
     /**
-     * Spans visibility
+     * Controlled view state (for controlled component pattern)
      */
-    spansVisible?: boolean;
+    viewState?: ViewState;
     /**
-     * Callback when spans visibility changes
+     * Callback when view state changes
      */
-    onSpansToggle?: (visible: boolean) => void;
+    onViewStateChange?: (viewState: ViewState) => void;
     /**
-     * Minimum zoom level to show substations
-     * @default 8
+     * Enable/disable scroll zoom
+     * @default true
      */
-    substationsMinZoom?: number;
+    scrollEnabled?: boolean;
     /**
-     * Minimum zoom level to show transformers
-     * @default 12
+     * Container CSS class
      */
-    transformersMinZoom?: number;
+    className?: string;
     /**
-     * Minimum zoom level to show feeders
-     * @default 12
+     * Preview mode - disables all interactions and shows overlay CTA
+     * @default false
      */
-    feedersMinZoom?: number;
+    previewMode?: boolean;
     /**
-     * Minimum zoom level to show spans
-     * @default 12
+     * CTA component to show in preview mode
      */
-    spansMinZoom?: number;
+    previewModeCta?: React__default.ReactNode;
     /**
-     * Placeholder text for search input
-     * @default "Search places..."
+     * Click handler for preview mode
      */
-    searchPlaceholder?: string;
+    onPreviewModePress?: () => void;
     /**
-     * Custom positioning for controls
+     * Map type - the visual style of the map
+     * Automatically adapts to light/dark mode via ColorModeProvider
+     *
+     * - "streets": Street map with roads and labels
+     * - "satellite": Satellite imagery with street overlays
+     * - "neutral": Minimal/clean map design
+     *
+     * @default "streets"
      */
-    controlStyles?: {
-        navigation?: React__default.CSSProperties;
-        layers?: React__default.CSSProperties;
-        search?: React__default.CSSProperties;
-        list?: React__default.CSSProperties;
-    };
+    mapType?: MapType;
+    /**
+     * Layers to render on the map
+     *
+     * Use the layers API for clean, type-safe layer configuration:
+     *
+     * @example
+     * ```tsx
+     * import { layer } from '@texturehq/edges';
+     *
+     * <InteractiveMap
+     *   layers={[
+     *     layer.vector({
+     *       id: 'feeders',
+     *       tileset: 'mapbox://texture.feeders',
+     *       sourceLayer: 'feeders',
+     *       renderAs: 'line',
+     *       style: { color: { token: 'brand-primary' } },
+     *       z: 10
+     *     })
+     *   ]}
+     * />
+     * ```
+     */
+    layers?: LayerSpec[];
     /**
-     * Custom Mapbox tileset to render
+     * Mapbox access token
+     * @default getMapboxTokenFromEnv()
      */
-    customTileset?: {
-        id: string;
+    mapboxAccessToken?: string;
+    /**
+     * Custom request transform function
+     */
+    transformRequest?: (url: string, resourceType?: string) => {
         url: string;
-        sourceLayer?: string;
-        layers?: Array<{
-            id: string;
-            type: "circle" | "fill" | "line" | "symbol" | "raster";
-            paint?: Record<string, any>;
-            layout?: Record<string, any>;
-        }>;
+        headers?: Record<string, string>;
     };
+    /**
+     * Show loading state overlay
+     * @default false
+     */
+    isLoading?: boolean;
+    /**
+     * Map controls configuration
+     *
+     * Configure which controls appear on the map and their behavior.
+     * - Pass an array of control configs for full customization
+     * - Pass "default" or omit for sensible defaults (navigation + reset-zoom)
+     * - Pass false or empty array to hide all controls
+     *
+     * @default "default"
+     *
+     * @example
+     * // Use defaults
+     * controls="default"
+     *
+     * @example
+     * // Custom controls
+     * controls={[
+     *   { type: 'navigation', position: 'bottom-right' },
+     *   { type: 'search', position: 'top-left', onSearch: handleSearch },
+     *   { type: 'layers', position: 'bottom-left', onMapTypeChange: setMapType }
+     * ]}
+     *
+     * @example
+     * // No controls
+     * controls={false}
+     */
+    controls?: MapControl[] | "default" | false;
 }
-declare function InteractiveMap({ data, initialViewState, onViewStateChange, onPointClick, selectedPointId, onCloseDrawer, drawerComponent, scrollEnabled, className, previewMode, previewModeCta, onPreviewModePress, workspaceId, mapFilters, serverSideClusteringEnabled, theme, mapboxAccessToken, transformRequest, isLoading, controls, mapLayers: layersData, listItems, onSearch, onListToggle, onThemeChange, isoRtoVisible: propIsoRtoVisible, onIsoRtoToggle, vermontSubstationsVisible: propVermontSubstationsVisible, onVermontSubstationsToggle, transformersVisible: propTransformersVisible, onTransformersToggle, feedersVisible: propFeedersVisible, onFeedersToggle, spansVisible: propSpansVisible, onSpansToggle, substationsMinZoom, transformersMinZoom, feedersMinZoom, spansMinZoom, searchPlaceholder, controlStyles, customTileset, }: InteractiveMapProps): react_jsx_runtime.JSX.Element;
+declare function InteractiveMap({ initialViewState, viewState, onViewStateChange, scrollEnabled, className, previewMode, previewModeCta, onPreviewModePress, mapType, layers, mapboxAccessToken, transformRequest, isLoading, controls, }: InteractiveMapProps): react_jsx_runtime.JSX.Element;
 
-declare const MAPBOX_THEMES: {
-    dark: string;
-    light: string;
-    streets: string;
-    satellite: string;
-};
 interface StaticMapProps {
     /**
      * Map width
@@ -857,22 +1125,48 @@ interface StaticMapProps {
     /**
      * Initial viewport configuration
      */
-    initialViewState?: {
-        longitude: number;
-        latitude: number;
-        zoom: number;
-    };
+    initialViewState?: Partial<ViewState>;
     /**
      * Show loading skeleton
      */
     isLoading?: boolean;
     /**
-     * Map theme
+     * Map type - the visual style of the map
+     * Automatically adapts to light/dark mode via ColorModeProvider
+     *
+     * - "streets": Street map with roads and labels
+     * - "satellite": Satellite imagery with street overlays
+     * - "neutral": Minimal/clean map design
+     *
      * @default "streets"
      */
-    theme?: keyof typeof MAPBOX_THEMES;
+    mapType?: MapType;
+    /**
+     * Layers to render on the map
+     *
+     * Use the layers API for clean, type-safe layer configuration.
+     * Same API as InteractiveMap for consistency.
+     *
+     * @example
+     * ```tsx
+     * import { layer } from '@texturehq/edges';
+     *
+     * <StaticMap
+     *   layers={[
+     *     layer.geojson({
+     *       id: 'points',
+     *       data: myGeoJson,
+     *       renderAs: 'circle',
+     *       style: { color: { token: 'brand-primary' } }
+     *     })
+     *   ]}
+     * />
+     * ```
+     */
+    layers?: LayerSpec[];
     /**
      * Mapbox access token
+     * @default getMapboxTokenFromEnv()
      */
     mapboxAccessToken?: string;
     /**
@@ -890,8 +1184,18 @@ interface StaticMapProps {
  *
  * A non-interactive map component for displaying a location.
  * Perfect for showing addresses, store locations, or any single point of interest.
+ *
+ * Automatically adapts to light/dark mode using the global ColorModeProvider.
  */
-declare function StaticMap({ width, height, initialViewState, isLoading, theme, mapboxAccessToken, showMarker, className, }: StaticMapProps): react_jsx_runtime.JSX.Element;
+declare function StaticMap({ width, height, initialViewState, isLoading, mapType, layers, mapboxAccessToken, showMarker, className, }: StaticMapProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Represents a geographic point with coordinates
+ */
+interface MapPoint {
+    latitude: number;
+    longitude: number;
+}
 
 interface MeterProps extends MeterProps$1 {
     /** Label displayed above the meter */
@@ -1009,15 +1313,15 @@ interface TextLinkProps {
  */
 declare const TextLink: ({ href, children, className, external, title, variant, onClick, asButton, onPress, showArrow, }: TextLinkProps) => react_jsx_runtime.JSX.Element;
 
-/**
- * Color utilities for the edges design system
- * Provides theme-aware color resolution and management
- */
 /**
  * Resolves a CSS variable to its computed color value
- * Supports both var(--name) format and plain --name format
+ * Supports multiple formats and automatically adds the color- prefix if needed
  *
- * @param variableName - CSS variable name (e.g., "--brand-primary" or "var(--brand-primary)")
+ * @param variableName - CSS variable name in any of these formats:
+ *   - "brand-primary" → resolves to --color-brand-primary
+ *   - "color-brand-primary" → resolves to --color-brand-primary
+ *   - "--color-brand-primary" → used as-is
+ *   - "var(--color-brand-primary)" → unwrapped and used
  * @returns Resolved color value or fallback
  */
 declare const getResolvedColor: (variableName: string, fallback?: string) => string;
@@ -1052,4 +1356,4 @@ declare const isLightColor: (color: string) => boolean;
  */
 declare const getContrastingTextColor: (backgroundColor: string) => string;
 
-export { defaultMargin as $, type ActionItem as A, type BaseDataPoint as B, type CardProps as C, type DateFieldProps as D, type SegmentOption as E, type FileUploadProps as F, SegmentedControl as G, Heading as H, Icon as I, type SideNavItem as J, type SideNavProps as K, Loader as L, type MapPoint as M, SideNav as N, TextLink as O, type TopNavProps as P, TopNav as Q, type RichTextEditorProps as R, type StaticMapProps as S, type TooltipData as T, type TooltipSeries as U, ChartContext as V, useChartContext as W, type ChartMargin as X, type YFormatType as Y, createXScale as Z, createYScale as _, type IconName as a, getYFormatSettings as a0, type YFormatSettings as a1, clearColorCache as a2, createCategoryColorMap as a3, getContrastingTextColor as a4, getDefaultChartColor as a5, getDefaultColors as a6, getResolvedColor as a7, getThemeCategoricalColors as a8, isLightColor as a9, type ActionMenuProps as b, ActionMenu as c, type AppShellProps as d, AppShell as e, type AvatarProps as f, Avatar as g, type BadgeProps as h, Badge as i, type CardVariant as j, Card as k, type CodeEditorProps as l, type CodeLanguage as m, type CodeTheme as n, CodeEditor as o, DateField as p, FileUpload as q, Logo as r, type InteractiveMapProps as s, InteractiveMap as t, MAPBOX_THEMES as u, StaticMap as v, type MeterProps as w, Meter as x, RichTextEditor as y, type SegmentedControlProps as z };
+export { SideNav as $, type ActionItem as A, type BaseDataPoint as B, type CustomPinsSpec as C, type DateFieldProps as D, MAP_TYPES as E, type FileUploadProps as F, type GeoJsonLayerSpec as G, Heading as H, Icon as I, StaticMap as J, type MeterProps as K, type LayerSpec as L, type MapPoint as M, Meter as N, type RichTextEditorProps as O, RichTextEditor as P, type SegmentedControlProps as Q, type RasterLayerSpec as R, type StaticMapProps as S, type TooltipData as T, type SegmentOption as U, type VectorLayerSpec as V, SegmentedControl as W, type SideNavItem as X, type YFormatType as Y, type ZoomStops as Z, type SideNavProps as _, type IconName as a, TextLink as a0, type TopNavProps as a1, TopNav as a2, type TooltipSeries as a3, ChartContext as a4, useChartContext as a5, type ChartMargin as a6, createXScale as a7, createYScale as a8, defaultMargin as a9, getYFormatSettings as aa, type YFormatSettings as ab, clearColorCache as ac, createCategoryColorMap as ad, getContrastingTextColor as ae, getDefaultChartColor as af, getDefaultColors as ag, getResolvedColor as ah, getThemeCategoricalColors as ai, isLightColor as aj, type ActionMenuProps as b, ActionMenu as c, type AppShellProps as d, AppShell as e, type AvatarProps as f, Avatar as g, type BadgeProps as h, Badge as i, type CardProps as j, type CardVariant as k, Card as l, type CodeEditorProps as m, type CodeLanguage as n, type CodeTheme as o, CodeEditor as p, DateField as q, FileUpload as r, Loader as s, Logo as t, type ColorSpec as u, type InteractiveMapProps as v, type LayerFeature as w, type LayerStyle as x, type RenderType as y, InteractiveMap as z };