@platform-blocks/ui 0.1.1

package/lib/components/SegmentedControl/SegmentedControl.d.ts

@@ -0,0 +1,6 @@
+import { View } from 'react-native';
+import type { SegmentedControlProps } from './types';
+export declare const SegmentedControl: import("../../core/factory").PlatformBlocksComponent<{
+    props: SegmentedControlProps;
+    ref: View;
+}>;

package/lib/components/SegmentedControl/index.d.ts

@@ -0,0 +1,2 @@
+export { SegmentedControl } from './SegmentedControl';
+export type { SegmentedControlProps, SegmentedControlItem, SegmentedControlData } from './types';

package/lib/components/SegmentedControl/types.d.ts

@@ -0,0 +1,62 @@
+import type { ReactNode } from 'react';
+import type { ViewStyle } from 'react-native';
+import type { SpacingProps, LayoutProps } from '../../core/utils';
+import type { BorderRadiusProps } from '../../core/theme/radius';
+import type { SizeValue } from '../../core/theme/sizes';
+export interface SegmentedControlItem {
+    /** Unique value returned in change events */
+    value: string;
+    /** Item label, string will be rendered with Text component */
+    label: ReactNode;
+    /** Disable this specific segment */
+    disabled?: boolean;
+    /** Screen reader label override */
+    ariaLabel?: string;
+    /** Optional test identifier for automation */
+    testID?: string;
+}
+export type SegmentedControlData = string | SegmentedControlItem;
+export interface SegmentedControlProps extends SpacingProps, LayoutProps, BorderRadiusProps {
+    /** Data that defines the segments */
+    data: SegmentedControlData[];
+    /** Controlled value */
+    value?: string;
+    /** Uncontrolled initial value */
+    defaultValue?: string;
+    /** Called when value changes */
+    onChange?: (value: string) => void;
+    /** Control size, maps to height and font size */
+    size?: SizeValue;
+    /** Indicator color token or hex */
+    color?: string;
+    /** Layout orientation */
+    orientation?: 'horizontal' | 'vertical';
+    /** Stretch across available width */
+    fullWidth?: boolean;
+    /** Disable entire control */
+    disabled?: boolean;
+    /** Prevent user interaction but keep visual state */
+    readOnly?: boolean;
+    /** Adjust text color automatically for filled variant */
+    autoContrast?: boolean;
+    /** Render dividers between items */
+    withItemsBorders?: boolean;
+    /** Indicator transition duration (ms) */
+    transitionDuration?: number;
+    /** Indicator transition easing */
+    transitionTimingFunction?: string;
+    /** Optional radio group name hint */
+    name?: string;
+    /** Visual style variant */
+    variant?: 'default' | 'filled';
+    /** Custom style for indicator */
+    indicatorStyle?: ViewStyle;
+    /** Custom style applied to every item */
+    itemStyle?: ViewStyle;
+    /** Style applied to the container */
+    style?: ViewStyle;
+    /** Test identifier applied to container */
+    testID?: string;
+    /** Accessibility label for the entire control */
+    accessibilityLabel?: string;
+}

package/lib/components/Select/Select.d.ts

@@ -0,0 +1,6 @@
+import type { SelectProps } from './Select.types';
+export declare const Select: import("../../core/factory/factory").PlatformBlocksComponent<{
+    props: SelectProps;
+    ref: any;
+}>;
+export default Select;

package/lib/components/Select/Select.types.d.ts

@@ -0,0 +1,31 @@
+import React from 'react';
+import { SizeValue } from '../../core/theme/sizes';
+import { LayoutProps, SpacingProps } from '../../core/utils';
+export interface SelectOption<T = any> {
+    label: string;
+    value: T;
+    disabled?: boolean;
+}
+export interface SelectProps<T = any> extends SpacingProps, LayoutProps {
+    value?: T | null;
+    defaultValue?: T | null;
+    onChange?: (value: T | null, option?: SelectOption<T> | null) => void;
+    options: SelectOption<T>[];
+    placeholder?: string;
+    size?: SizeValue;
+    radius?: any;
+    disabled?: boolean;
+    label?: string;
+    /** Optional short descriptive text shown directly under the label (above the field). */
+    description?: string;
+    helperText?: string;
+    error?: string;
+    searchable?: boolean;
+    renderOption?: (opt: SelectOption<T>, active: boolean, selected: boolean) => React.ReactNode;
+    fullWidth?: boolean;
+    maxHeight?: number;
+    closeOnSelect?: boolean;
+    clearable?: boolean;
+    clearButtonLabel?: string;
+    onClear?: () => void;
+}

package/lib/components/Select/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Select';
+export type { SelectProps, SelectOption } from './Select.types';

package/lib/components/Select/types.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+import { SizeValue } from '../../core/theme/sizes';
+export interface SelectOption<T = any> {
+    label: string;
+    value: T;
+    disabled?: boolean;
+}
+export interface SelectProps<T = any> {
+    value?: T;
+    defaultValue?: T;
+    onChange?: (value: T, option: SelectOption<T>) => void;
+    options: SelectOption<T>[];
+    placeholder?: string;
+    size?: SizeValue;
+    radius?: any;
+    disabled?: boolean;
+    label?: string;
+    helperText?: string;
+    error?: string;
+    searchable?: boolean;
+    renderOption?: (opt: SelectOption<T>, active: boolean, selected: boolean) => React.ReactNode;
+    fullWidth?: boolean;
+    maxHeight?: number;
+    closeOnSelect?: boolean;
+}

package/lib/components/ShimmerText/ShimmerText.d.ts

@@ -0,0 +1,33 @@
+import React from 'react';
+import { type TextProps } from '../Text';
+type ShimmerDirection = 'ltr' | 'rtl';
+export interface ShimmerTextProps extends Omit<TextProps, 'children' | 'color' | 'onLayout'> {
+    children?: React.ReactNode;
+    text?: string;
+    /** Base text color rendered underneath the shimmer */
+    color?: string;
+    /** Optional gradient stops override */
+    colors?: string[];
+    /** Primary shimmering color used to derive stops when `colors` not provided */
+    shimmerColor?: string;
+    /** Duration in seconds for a single sweep */
+    duration?: number;
+    /** Delay in seconds before the first sweep starts */
+    delay?: number;
+    /** Additional pause in seconds between repeated sweeps */
+    repeatDelay?: number;
+    /** Whether the shimmer should loop */
+    repeat?: boolean;
+    /** Run the shimmer exactly once */
+    once?: boolean;
+    /** Direction the shimmer should travel */
+    direction?: ShimmerDirection;
+    /** Multiplier that controls how wide the gradient band is relative to the text width */
+    spread?: number;
+    /** Enable verbose logging for debugging */
+    debug?: boolean;
+    /** Called with the layout of the text */
+    onLayout?: TextProps['onLayout'];
+}
+export declare function ShimmerText(props: ShimmerTextProps): React.JSX.Element;
+export {};

package/lib/components/ShimmerText/index.d.ts

@@ -0,0 +1,2 @@
+export { ShimmerText } from './ShimmerText';
+export type { ShimmerTextProps } from './types';

package/lib/components/ShimmerText/types.d.ts

@@ -0,0 +1,33 @@
+import type { TextProps } from '../Text/Text';
+export interface ShimmerTextProps extends Omit<TextProps, 'children' | 'value' | 'color'> {
+    /** Text node children. Overrides `text` when provided */
+    children?: React.ReactNode;
+    /** Text content to render when not using children */
+    text?: string;
+    /** Base text color. Falls back to the current theme text color */
+    color?: string;
+    /** Highlight color used for the shimmer pass */
+    shimmerColor?: string;
+    /** Length multiplier for the shimmer sweep (higher = wider highlight) */
+    spread?: number;
+    /** Duration of a single shimmer cycle in seconds */
+    duration?: number;
+    /** Delay before the shimmer starts (seconds) */
+    delay?: number;
+    /** Whether the shimmer should repeat indefinitely */
+    repeat?: boolean;
+    /** Delay between shimmer repetitions (seconds) */
+    repeatDelay?: number;
+    /** Start shimmering once the component enters the viewport (web only) */
+    startOnView?: boolean;
+    /** Animate only once after becoming visible */
+    once?: boolean;
+    /** Custom IntersectionObserver margin (web only) */
+    inViewMargin?: string;
+    /** Direction of shimmer movement */
+    direction?: 'ltr' | 'rtl';
+    /** Optional container style */
+    containerStyle?: any;
+    /** Optional test identifier */
+    testID?: string;
+}

package/lib/components/Skeleton/Skeleton.d.ts

@@ -0,0 +1,2 @@
+import { SkeletonFactoryPayload } from './types';
+export declare const Skeleton: import("../../core/factory").PlatformBlocksComponent<SkeletonFactoryPayload>;

package/lib/components/Skeleton/index.d.ts

@@ -0,0 +1,2 @@
+export { Skeleton } from './Skeleton';
+export type { SkeletonProps, SkeletonShape } from './types';

package/lib/components/Skeleton/types.d.ts

@@ -0,0 +1,30 @@
+import { DimensionValue, ViewStyle, View } from 'react-native';
+import { SpacingProps } from '../../core/utils';
+import { SizeValue } from '../../core/theme/sizes';
+export type SkeletonShape = 'text' | 'chip' | 'avatar' | 'button' | 'card' | 'circle' | 'rectangle' | 'rounded';
+export interface SkeletonProps extends SpacingProps {
+    /** Shape of the skeleton placeholder */
+    shape?: SkeletonShape;
+    /** Width of the skeleton component */
+    width?: DimensionValue;
+    /** Height of the skeleton component */
+    height?: DimensionValue;
+    /** Size of the skeleton component (overrides width/height) */
+    size?: SizeValue;
+    /** Border radius for rectangle/rounded shapes */
+    radius?: SizeValue | number;
+    /** Whether to show the loading animation */
+    animate?: boolean;
+    /** Duration of the loading animation in milliseconds */
+    animationDuration?: number;
+    /** Gradient colors for the shimmer effect */
+    colors?: [string, string];
+    /** Style overrides for the skeleton container */
+    style?: ViewStyle;
+    /** Optional test identifier */
+    testID?: string;
+}
+export interface SkeletonFactoryPayload {
+    props: SkeletonProps;
+    ref: View;
+}

package/lib/components/Slider/Slider.d.ts

@@ -0,0 +1,10 @@
+import { View } from 'react-native';
+import type { SliderProps, RangeSliderProps } from './types';
+export declare const Slider: import("../../core/factory").PlatformBlocksComponent<{
+    props: SliderProps;
+    ref: View;
+}>;
+export declare const RangeSlider: import("../../core/factory").PlatformBlocksComponent<{
+    props: RangeSliderProps;
+    ref: View;
+}>;

package/lib/components/Slider/SliderCore.d.ts

@@ -0,0 +1,57 @@
+import React from 'react';
+import type { SliderTick, SliderTrackProps, SliderThumbProps, SliderTicksProps, SliderLabelProps, SliderValueLabelProps } from './types';
+export declare const SLIDER_CONSTANTS: {
+    THUMB_SIZE: {
+        sm: number;
+        md: number;
+        lg: number;
+    };
+    TRACK_HEIGHT: {
+        sm: number;
+        md: number;
+        lg: number;
+    };
+    CONTAINER_HEIGHT: number;
+    CONTAINER_WIDTH: number;
+    LABEL_OFFSET: number;
+};
+export declare const getOrientationProps: (orientation?: "horizontal" | "vertical", containerSize?: number) => {
+    isVertical: boolean;
+    trackDimension: string;
+    thumbDimension: string;
+    crossDimension: string;
+    mainAxis: string;
+    crossAxis: string;
+    mainSize: string;
+    crossSize: string;
+    containerWidth: number;
+    containerHeight: number;
+    trackStart: string;
+    trackEnd: string;
+    thumbPosition: string;
+    crossPosition: string;
+};
+export declare const sliderUtils: {
+    clamp: (value: number, min: number, max: number) => number;
+    roundToStep: (value: number, step: number) => number;
+    roundToTicks: (value: number, ticks: SliderTick[]) => number;
+    valueToPercentage: (value: number, min: number, max: number) => number;
+    percentageToValue: (percentage: number, min: number, max: number) => number;
+    positionToPercentage: (position: number, trackLength: number) => number;
+};
+export declare const useSliderTicks: (ticks: SliderTick[] | undefined, showTicks: boolean, min: number, max: number, step: number, trackLength: number, isRange?: boolean, rangeValues?: [number, number]) => {
+    position: number;
+    isActive: boolean;
+    value: number;
+    label?: string;
+    style?: any;
+}[];
+export declare const useSliderValue: (value: number | [number, number], min: number, max: number, step: number, restrictToTicks: boolean, ticks: SliderTick[] | undefined, isRange?: boolean) => number | [number, number];
+export declare const useSliderGesture: (min: number, max: number, step: number, restrictToTicks: boolean, ticks: SliderTick[] | undefined, disabled: boolean) => {
+    calculateNewValue: (position: number, trackLength: number) => number;
+};
+export declare const SliderTrack: React.FC<SliderTrackProps>;
+export declare const SliderTicks: React.FC<SliderTicksProps>;
+export declare const SliderThumb: React.FC<SliderThumbProps>;
+export declare const SliderLabel: React.FC<SliderLabelProps>;
+export declare const SliderValueLabel: React.FC<SliderValueLabelProps>;

package/lib/components/Slider/index.d.ts

@@ -0,0 +1,2 @@
+export { Slider, RangeSlider } from './Slider';
+export type { SliderProps, RangeSliderProps, SliderStyleProps } from './types';

package/lib/components/Slider/types.d.ts

@@ -0,0 +1,133 @@
+import React from 'react';
+import { BaseInputProps } from '../Input/types';
+import { ColorValue, SizeValue } from '../../core/theme/types';
+export interface SliderTick {
+    /** Tick value */
+    value: number;
+    /** Optional label for the tick */
+    label?: string;
+    /** Optional style for the tick */
+    style?: any;
+}
+export interface SliderProps extends Omit<BaseInputProps, 'value' | 'onChangeText' | 'label'> {
+    /** Slider value */
+    value?: number;
+    /** Uncontrolled initial value */
+    defaultValue?: number;
+    /** Change handler */
+    onChange?: (value: number) => void;
+    /** Minimum value */
+    min?: number;
+    /** Maximum value */
+    max?: number;
+    /** Step increment */
+    step?: number;
+    /** Slider orientation */
+    orientation?: 'horizontal' | 'vertical';
+    /** Track color */
+    trackColor?: ColorValue;
+    /** Active track color */
+    activeTrackColor?: ColorValue;
+    /** Thumb color */
+    thumbColor?: ColorValue;
+    /** Track height/width */
+    trackSize?: number;
+    /** Thumb size */
+    thumbSize?: number;
+    /** Input label (above the slider) */
+    label?: React.ReactNode;
+    /** Value label formatter function, set to null to disable value label */
+    valueLabel?: ((value: number) => string) | null;
+    /** If true, value label will always be displayed */
+    valueLabelAlwaysOn?: boolean;
+    /** Value label position */
+    valueLabelPosition?: 'top' | 'bottom' | 'left' | 'right';
+    /** Show min/max labels */
+    showMarks?: boolean;
+    /** Custom ticks/marks to display on the slider */
+    ticks?: SliderTick[];
+    /** Slider container size (width for horizontal, height for vertical) */
+    containerSize?: number;
+    /** Whether to show automatic tick marks based on step */
+    showTicks?: boolean;
+    /** Restrict value changes to only tick positions */
+    restrictToTicks?: boolean;
+    /** Inverted slider (right-to-left or top-to-bottom) */
+    inverted?: boolean;
+    /** Precision for value display */
+    precision?: number;
+    /** Tooltip visibility */
+    tooltip?: 'always' | 'hover' | 'never';
+    /** Make slider stretch to fill parent width/height */
+    fullWidth?: boolean;
+}
+export interface RangeSliderProps extends Omit<SliderProps, 'value' | 'onChange' | 'valueLabel' | 'defaultValue'> {
+    /** Range value [min, max] */
+    value?: [number, number];
+    /** Uncontrolled initial range value */
+    defaultValue?: [number, number];
+    /** Change handler */
+    onChange?: (value: [number, number]) => void;
+    /** Value label formatter function for range values */
+    valueLabel?: ((value: number, index: number) => string) | null;
+    /** Minimum distance between thumbs */
+    minRange?: number;
+    /** Allow thumbs to cross */
+    allowCross?: boolean;
+    /** Whether thumbs should push each other when they overlap (default: true) */
+    pushOnOverlap?: boolean;
+    /** Labels for range values */
+    rangeLabels?: [string, string];
+}
+export interface SliderStyleProps {
+    error?: boolean;
+    disabled?: boolean;
+    focused?: boolean;
+    size: SizeValue;
+    orientation: 'horizontal' | 'vertical';
+    containerSize: number;
+    trackSize: number;
+    thumbSize: number;
+}
+export interface SliderTrackProps {
+    disabled: boolean;
+    theme: any;
+    size: 'sm' | 'md' | 'lg';
+    orientation: 'horizontal' | 'vertical';
+    activeWidth?: number;
+    activeLeft?: number;
+    isRange?: boolean;
+}
+export interface SliderTicksProps {
+    ticks: Array<{
+        value: number;
+        position: number;
+        isActive: boolean;
+        label?: string;
+    }>;
+    disabled: boolean;
+    theme: any;
+    size: 'sm' | 'md' | 'lg';
+    orientation: 'horizontal' | 'vertical';
+    keyPrefix?: string;
+}
+export interface SliderThumbProps {
+    position: number;
+    disabled: boolean;
+    theme: any;
+    size: 'sm' | 'md' | 'lg';
+    orientation: 'horizontal' | 'vertical';
+    isDragging: boolean;
+    zIndex?: number;
+    panHandlers?: any;
+}
+export interface SliderLabelProps {
+    label: React.ReactNode;
+}
+export interface SliderValueLabelProps {
+    value: string | number;
+    position: number;
+    size: 'sm' | 'md' | 'lg';
+    orientation: 'horizontal' | 'vertical';
+    isCard?: boolean;
+}

package/lib/components/Space/Space.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { View } from 'react-native';
+import type { SpaceProps } from './types';
+export declare const Space: React.ForwardRefExoticComponent<SpaceProps & React.RefAttributes<View>>;

package/lib/components/Space/index.d.ts

@@ -0,0 +1,2 @@
+export { Space } from './Space';
+export type { SpaceProps } from './types';

package/lib/components/Space/types.d.ts

@@ -0,0 +1,17 @@
+import type { StyleProp, ViewProps, ViewStyle } from 'react-native';
+import type { SizeValue } from '../../core/theme/sizes';
+export interface SpaceProps extends Omit<ViewProps, 'style'> {
+    /** Height of the spacer. Accepts theme spacing tokens or raw numbers. */
+    h?: SizeValue;
+    /** Width of the spacer. Accepts theme spacing tokens or raw numbers. */
+    w?: SizeValue;
+    /**
+     * Fallback size when neither `h` nor `w` is provided.
+     * Defaults to `md` so the component always occupies some space.
+     */
+    size?: SizeValue;
+    /** Optional style overrides. */
+    style?: StyleProp<ViewStyle>;
+    /** Space is presentational only, so children are not supported. */
+    children?: never;
+}

package/lib/components/Spoiler/Spoiler.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { SpoilerProps } from './types';
+/** Simple height-based spoiler (collapsible) component */
+export declare const Spoiler: React.FC<SpoilerProps>;
+export default Spoiler;

package/lib/components/Spoiler/index.d.ts

@@ -0,0 +1,2 @@
+export { Spoiler } from './Spoiler';
+export type { SpoilerProps } from './types';

package/lib/components/Spoiler/types.d.ts

@@ -0,0 +1,40 @@
+import React from 'react';
+import { SpacingProps } from '../../core/utils';
+import { SizeValue } from '../../core/theme/sizes';
+export interface SpoilerProps extends SpacingProps {
+    /** Content to hide/show */
+    children: React.ReactNode;
+    /** Max height (in px) when collapsed */
+    maxHeight?: number;
+    /** Whether component starts initially opened */
+    initiallyOpen?: boolean;
+    /** Label for show more */
+    showLabel?: string;
+    /** Label for hide */
+    hideLabel?: string;
+    /** Transition duration ms */
+    transitionDuration?: number;
+    /** Size token influences padding / font */
+    size?: SizeValue;
+    /** Optional controlled open state */
+    opened?: boolean;
+    /** Callback when toggle */
+    onToggle?: (opened: boolean) => void;
+    /** Disable toggle */
+    disabled?: boolean;
+    /** Optional style */
+    style?: any;
+    /** Render custom control */
+    renderControl?: (args: {
+        opened: boolean;
+        toggle: () => void;
+        showLabel: string;
+        hideLabel: string;
+    }) => React.ReactNode;
+    /** If true (default) fade bottom of clamped content to transparent using CSS mask on web */
+    transparentFade?: boolean;
+    /** Fallback overlay gradient end color (used only when transparentFade=false) */
+    fadeColor?: string;
+    /** Disable gradient fade animation (debug / perf). Default false (animation enabled). */
+    disableFadeAnimation?: boolean;
+}

package/lib/components/Spotlight/DirectSpotlightState.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Global Spotlight Hook for Direct State Access
+ *
+ * This hook bypasses the SpotlightProvider context and uses the global state directly.
+ * This should be used in the GlobalSpotlight component to avoid provider re-mounting issues.
+ */
+import { SpotlightState } from './SpotlightStore';
+interface GlobalSpotlightState {
+    opened: boolean;
+    query: string;
+    selectedIndex: number;
+}
+type SpotlightStateListener = (state: GlobalSpotlightState) => void;
+declare class DirectSpotlightStateManager {
+    private state;
+    private listeners;
+    getState(): GlobalSpotlightState;
+    setState(updates: Partial<GlobalSpotlightState>): void;
+    open(query?: string): void;
+    close(): void;
+    setQuery(query: string): void;
+    toggle(): void;
+    subscribe(listener: SpotlightStateListener): () => void;
+    private notifyListeners;
+}
+export declare const directSpotlightStateManager: DirectSpotlightStateManager;
+export declare function useDirectSpotlightState(): {
+    state: SpotlightState;
+    open: (query?: string) => void;
+    close: () => void;
+    toggle: () => void;
+    setQuery: (query: string) => void;
+};
+export declare const directSpotlight: {
+    open: (query?: string) => void;
+    close: () => void;
+    toggle: () => void;
+    setQuery: (query: string) => void;
+    getState: () => GlobalSpotlightState;
+};
+export {};

package/lib/components/Spotlight/Spotlight.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+import type { SpotlightProps, SpotlightRootProps, SpotlightSearchProps, SpotlightActionsListProps, SpotlightActionProps, SpotlightActionsGroupProps, SpotlightEmptyProps } from './types';
+declare function SpotlightRoot({ query, onQueryChange, children, opened, onClose, shortcut, style, }: SpotlightRootProps): React.JSX.Element;
+declare function SpotlightSearch({ value, onChangeText, leftSection, placeholder, onNavigateUp, onNavigateDown, onSelectAction, onClose, ...props }: SpotlightSearchProps): React.JSX.Element;
+declare function SpotlightActionsList({ children, scrollable, maxHeight, style, scrollRef, onScrollChange, }: SpotlightActionsListProps): React.JSX.Element;
+declare function SpotlightAction({ label, description, leftSection, rightSection, onPress, disabled, selected, children, style, innerRef, }: SpotlightActionProps): React.JSX.Element;
+declare function SpotlightActionsGroup({ label, children, style, }: SpotlightActionsGroupProps): React.JSX.Element;
+declare function SpotlightEmpty({ children, style }: SpotlightEmptyProps): React.JSX.Element;
+export declare function Spotlight({ actions, nothingFound, highlightQuery, limit, scrollable, maxHeight, // Remove default - let it be calculated dynamically
+shortcut, searchProps, store, variant, width, height, }: SpotlightProps): React.JSX.Element;
+export declare namespace Spotlight {
+    var Root: typeof SpotlightRoot;
+    var Search: typeof SpotlightSearch;
+    var ActionsList: typeof SpotlightActionsList;
+    var Action: typeof SpotlightAction;
+    var ActionsGroup: typeof SpotlightActionsGroup;
+    var Empty: typeof SpotlightEmpty;
+}
+export default Spotlight;

package/lib/components/Spotlight/SpotlightController.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+interface SpotlightControllerProps {
+    config?: {
+        shortcut?: string | string[] | null;
+        actions?: any[];
+        alwaysMount?: boolean;
+        highlightQuery?: boolean;
+        limit?: number;
+        placeholder?: string;
+    };
+}
+export declare const SpotlightController: React.NamedExoticComponent<SpotlightControllerProps>;
+export {};

package/lib/components/Spotlight/SpotlightStore.d.ts

@@ -0,0 +1,32 @@
+import React, { ReactNode } from 'react';
+type SpotlightRequestListener = () => void;
+export declare function onSpotlightRequested(listener: SpotlightRequestListener): () => void;
+export interface SpotlightState {
+    opened: boolean;
+    query: string;
+    selectedIndex: number;
+}
+export interface SpotlightStore {
+    state: SpotlightState;
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+    setQuery: (query: string) => void;
+    setSelectedIndex: (index: number) => void;
+    navigateUp: () => void;
+    navigateDown: () => void;
+}
+export interface SpotlightProviderProps {
+    children: ReactNode;
+}
+export declare function SpotlightProvider({ children }: SpotlightProviderProps): React.JSX.Element;
+export declare function useSpotlightStore(): SpotlightStore;
+export declare function useSpotlightStoreInstance(): [SpotlightStore, SpotlightStore];
+export declare const createSpotlightStore: typeof useSpotlightStoreInstance;
+export declare const spotlight: {
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+};
+export declare function setDefaultSpotlightStore(store: SpotlightStore | null): void;
+export {};