@platform-blocks/ui 0.1.1

package/lib/core/providers/DirectionProvider.d.ts

@@ -0,0 +1,88 @@
+import React, { ReactNode } from 'react';
+/**
+ * Direction type - left-to-right or right-to-left
+ */
+export type Direction = 'ltr' | 'rtl';
+/**
+ * Direction context value interface
+ */
+export interface DirectionContextValue {
+    /** Current text direction */
+    dir: Direction;
+    /** Whether current direction is RTL */
+    isRTL: boolean;
+    /** Set the text direction */
+    setDirection: (direction: Direction) => void;
+    /** Toggle between LTR and RTL */
+    toggleDirection: () => void;
+}
+/**
+ * Storage controller interface for persisting direction preference
+ */
+export interface StorageController {
+    getItem: (key: string) => Promise<string | null>;
+    setItem: (key: string, value: string) => Promise<void>;
+}
+/**
+ * DirectionProvider props
+ */
+export interface DirectionProviderProps {
+    /** Initial direction. If not provided, will auto-detect from platform */
+    initialDirection?: Direction;
+    /** Optional storage controller for persisting direction */
+    storage?: StorageController;
+    /** Storage key for persisting direction preference */
+    storageKey?: string;
+    /** Children to render */
+    children: ReactNode;
+}
+/**
+ * Direction Context
+ */
+declare const DirectionContext: React.Context<DirectionContextValue | null>;
+/**
+ * DirectionProvider Component
+ *
+ * Provides direction context for the entire app. Manages LTR/RTL state
+ * and syncs with platform-specific direction settings.
+ *
+ * @example
+ * ```tsx
+ * import { DirectionProvider } from '@platform-blocks/ui';
+ *
+ * function App() {
+ *   return (
+ *     <DirectionProvider initialDirection="ltr">
+ *       <YourApp />
+ *     </DirectionProvider>
+ *   );
+ * }
+ * ```
+ */
+export declare const DirectionProvider: React.FC<DirectionProviderProps>;
+/**
+ * Hook to access direction context
+ *
+ * @throws Error if used outside DirectionProvider
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { dir, isRTL, setDirection, toggleDirection } = useDirection();
+ *
+ *   return (
+ *     <View style={{ flexDirection: isRTL ? 'row-reverse' : 'row' }}>
+ *       <Text>Direction: {dir}</Text>
+ *       <Button onPress={toggleDirection}>Toggle</Button>
+ *     </View>
+ *   );
+ * }
+ * ```
+ */
+export declare const useDirection: () => DirectionContextValue;
+/**
+ * Hook to safely access direction context with fallback
+ * Use this if you want to support components outside DirectionProvider
+ */
+export declare const useDirectionSafe: () => DirectionContextValue;
+export { DirectionContext };

package/lib/core/providers/OverlayProvider.d.ts

@@ -0,0 +1,40 @@
+import React, { ReactNode } from 'react';
+export interface OverlayConfig {
+    id: string;
+    content: ReactNode;
+    trigger?: 'click' | 'hover' | 'contextmenu' | 'manual';
+    placement?: 'top' | 'bottom' | 'left' | 'right' | 'auto';
+    offset?: number;
+    anchor?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    width?: number | string;
+    maxWidth?: number | string;
+    maxHeight?: number | string;
+    onClose?: () => void;
+    closeOnClickOutside?: boolean;
+    closeOnEscape?: boolean;
+    strategy?: 'absolute' | 'fixed' | 'portal';
+    zIndex?: number;
+    viewport?: {
+        padding: number;
+    };
+}
+interface OverlayApiValue {
+    openOverlay: (config: Omit<OverlayConfig, 'id'>) => string;
+    closeOverlay: (id: string) => void;
+    closeAllOverlays: () => void;
+    updateOverlay: (id: string, updates: Partial<OverlayConfig>) => void;
+}
+export declare function OverlayProvider({ children }: {
+    children: ReactNode;
+}): React.JSX.Element;
+export declare function useOverlay(): {
+    overlays: OverlayConfig[];
+} & OverlayApiValue;
+export declare function useOverlayApi(): OverlayApiValue;
+export declare function useOverlays(): OverlayConfig[];
+export {};

package/lib/core/providers/OverlayRenderer.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { ViewStyle } from 'react-native';
+export interface OverlayRendererProps {
+    /** Additional styles for the overlay container */
+    style?: ViewStyle;
+}
+export declare function OverlayRenderer({ style }?: OverlayRendererProps): React.JSX.Element | null;

package/lib/core/providers/index.d.ts

@@ -0,0 +1,5 @@
+export { OverlayProvider, useOverlay } from './OverlayProvider';
+export { OverlayRenderer } from './OverlayRenderer';
+export type { OverlayConfig } from './OverlayProvider';
+export { DirectionProvider, useDirection, useDirectionSafe, DirectionContext } from './DirectionProvider';
+export type { Direction, DirectionContextValue, DirectionProviderProps, StorageController } from './DirectionProvider';

package/lib/core/responsive/index.d.ts

@@ -0,0 +1,22 @@
+export type Breakpoint = 'base' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+declare const BREAKPOINTS: {
+    readonly base: 0;
+    readonly xs: 480;
+    readonly sm: 576;
+    readonly md: 768;
+    readonly lg: 992;
+    readonly xl: 1200;
+};
+export type ResponsiveValue<T> = T | Partial<Record<Breakpoint, T>>;
+export type ResponsiveSize = ResponsiveValue<number>;
+export type ResponsiveString = ResponsiveValue<string>;
+export type ResponsiveBoolean = ResponsiveValue<boolean>;
+declare const useBreakpoint: () => Breakpoint;
+declare const useIsMobile: () => boolean;
+declare const resolveResponsiveValue: <T>(value: ResponsiveValue<T>, currentBreakpoint: Breakpoint) => T;
+declare const useResponsiveValue: <T>(value: ResponsiveValue<T>) => T;
+declare const createResponsiveStyle: <T extends Record<string, any>>(styleValue: ResponsiveValue<T>, breakpoint: Breakpoint) => T;
+declare const isResponsiveValue: <T>(value: ResponsiveValue<T>) => value is Partial<Record<Breakpoint, T>>;
+declare const createResponsiveCSS: <T>(property: string, value: ResponsiveValue<T>, unit?: string) => Record<string, any>;
+declare const getResponsiveSpacing: (value: ResponsiveValue<number | string>, breakpoint: Breakpoint, multiplier?: number) => number;
+export { BREAKPOINTS, useBreakpoint, useIsMobile, resolveResponsiveValue, useResponsiveValue, createResponsiveStyle, isResponsiveValue, createResponsiveCSS, getResponsiveSpacing, };

package/lib/core/sound/context.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+import type { SoundContextType, SoundAsset, HapticFeedbackOptions } from './types';
+interface SoundProviderProps {
+    children: React.ReactNode;
+    /** Initial sound assets to register */
+    initialSounds?: SoundAsset[];
+    /** Whether to enable audio mode on iOS */
+    enableAudioMode?: boolean;
+}
+export declare const SoundProvider: React.FC<SoundProviderProps>;
+/**
+ * Hook to access the sound context
+ */
+export declare const useSound: () => SoundContextType;
+/**
+ * Hook for haptic feedback
+ */
+export declare const useHaptics: () => {
+    triggerHaptic: (options?: HapticFeedbackOptions) => Promise<void>;
+};
+export {};

package/lib/core/sound/hooks.d.ts

@@ -0,0 +1,214 @@
+import type { SoundOptions, HapticFeedbackOptions } from './types';
+/**
+ * Default sound IDs for common UI interactions
+ * Apps can override these by providing different IDs to the hooks
+ */
+export declare const DEFAULT_SOUND_IDS: {
+    BUTTON_PRESS: string;
+    BUTTON_HOVER: string;
+    NAVIGATION_FORWARD: string;
+    NAVIGATION_BACK: string;
+    SUCCESS: string;
+    ERROR: string;
+    WARNING: string;
+    INPUT_FOCUS: string;
+    INPUT_TYPE: string;
+    NOTIFICATION: string;
+    MESSAGE_RECEIVED: string;
+    MODAL_OPEN: string;
+    MODAL_CLOSE: string;
+    SELECT: string;
+    DESELECT: string;
+    LOADING_START: string;
+    LOADING_COMPLETE: string;
+};
+/**
+ * Hook for button interaction sounds and haptics
+ */
+export declare const useButtonFeedback: (soundIds?: {
+    press?: string;
+    hover?: string;
+}) => {
+    onPress: (options?: {
+        sound?: SoundOptions;
+        haptic?: HapticFeedbackOptions;
+        playSound?: boolean;
+        playHaptic?: boolean;
+    }) => Promise<void>;
+    onHover: (options?: SoundOptions) => Promise<void>;
+};
+/**
+ * Hook for form input feedback
+ */
+export declare const useInputFeedback: (soundIds?: {
+    focus?: string;
+    type?: string;
+    error?: string;
+    success?: string;
+}) => {
+    onFocus: (options?: SoundOptions) => Promise<void>;
+    onType: (options?: SoundOptions) => Promise<void>;
+    onValidationError: (options?: {
+        sound?: SoundOptions;
+        haptic?: HapticFeedbackOptions;
+    }) => Promise<void>;
+    onValidationSuccess: (options?: {
+        sound?: SoundOptions;
+        haptic?: HapticFeedbackOptions;
+    }) => Promise<void>;
+};
+/**
+ * Hook for navigation feedback
+ */
+export declare const useNavigationFeedback: (soundIds?: {
+    forward?: string;
+    back?: string;
+}) => {
+    onNavigateForward: (options?: {
+        sound?: SoundOptions;
+        haptic?: HapticFeedbackOptions;
+    }) => Promise<void>;
+    onNavigateBack: (options?: {
+        sound?: SoundOptions;
+        haptic?: HapticFeedbackOptions;
+    }) => Promise<void>;
+};
+/**
+ * Hook for modal/dialog feedback
+ */
+export declare const useModalFeedback: (soundIds?: {
+    open?: string;
+    close?: string;
+}) => {
+    onOpen: (options?: {
+        sound?: SoundOptions;
+        haptic?: HapticFeedbackOptions;
+    }) => Promise<void>;
+    onClose: (options?: {
+        sound?: SoundOptions;
+        haptic?: HapticFeedbackOptions;
+    }) => Promise<void>;
+};
+/**
+ * Hook for selection feedback
+ */
+export declare const useSelectionFeedback: (soundIds?: {
+    select?: string;
+    deselect?: string;
+}) => {
+    onSelect: (options?: {
+        sound?: SoundOptions;
+        haptic?: HapticFeedbackOptions;
+    }) => Promise<void>;
+    onDeselect: (options?: {
+        sound?: SoundOptions;
+        haptic?: HapticFeedbackOptions;
+    }) => Promise<void>;
+};
+/**
+ * Hook for loading state feedback
+ */
+export declare const useLoadingFeedback: (soundIds?: {
+    start?: string;
+    complete?: string;
+}) => {
+    onStart: (options?: SoundOptions) => Promise<void>;
+    onComplete: (options?: {
+        sound?: SoundOptions;
+        haptic?: HapticFeedbackOptions;
+    }) => Promise<void>;
+};
+/**
+ * Hook for notification feedback
+ */
+export declare const useNotificationFeedback: (soundIds?: {
+    notification?: string;
+    success?: string;
+    warning?: string;
+    error?: string;
+    messageReceived?: string;
+}) => {
+    onNotification: (options?: {
+        sound?: SoundOptions;
+        haptic?: HapticFeedbackOptions;
+        type?: "info" | "success" | "warning" | "error";
+    }) => Promise<void>;
+    onMessageReceived: (options?: {
+        sound?: SoundOptions;
+        haptic?: HapticFeedbackOptions;
+    }) => Promise<void>;
+};
+/**
+ * Combined hook for all UI feedback types
+ */
+export declare const useUIFeedback: () => {
+    button: {
+        onPress: (options?: {
+            sound?: SoundOptions;
+            haptic?: HapticFeedbackOptions;
+            playSound?: boolean;
+            playHaptic?: boolean;
+        }) => Promise<void>;
+        onHover: (options?: SoundOptions) => Promise<void>;
+    };
+    input: {
+        onFocus: (options?: SoundOptions) => Promise<void>;
+        onType: (options?: SoundOptions) => Promise<void>;
+        onValidationError: (options?: {
+            sound?: SoundOptions;
+            haptic?: HapticFeedbackOptions;
+        }) => Promise<void>;
+        onValidationSuccess: (options?: {
+            sound?: SoundOptions;
+            haptic?: HapticFeedbackOptions;
+        }) => Promise<void>;
+    };
+    navigation: {
+        onNavigateForward: (options?: {
+            sound?: SoundOptions;
+            haptic?: HapticFeedbackOptions;
+        }) => Promise<void>;
+        onNavigateBack: (options?: {
+            sound?: SoundOptions;
+            haptic?: HapticFeedbackOptions;
+        }) => Promise<void>;
+    };
+    modal: {
+        onOpen: (options?: {
+            sound?: SoundOptions;
+            haptic?: HapticFeedbackOptions;
+        }) => Promise<void>;
+        onClose: (options?: {
+            sound?: SoundOptions;
+            haptic?: HapticFeedbackOptions;
+        }) => Promise<void>;
+    };
+    selection: {
+        onSelect: (options?: {
+            sound?: SoundOptions;
+            haptic?: HapticFeedbackOptions;
+        }) => Promise<void>;
+        onDeselect: (options?: {
+            sound?: SoundOptions;
+            haptic?: HapticFeedbackOptions;
+        }) => Promise<void>;
+    };
+    loading: {
+        onStart: (options?: SoundOptions) => Promise<void>;
+        onComplete: (options?: {
+            sound?: SoundOptions;
+            haptic?: HapticFeedbackOptions;
+        }) => Promise<void>;
+    };
+    notification: {
+        onNotification: (options?: {
+            sound?: SoundOptions;
+            haptic?: HapticFeedbackOptions;
+            type?: "info" | "success" | "warning" | "error";
+        }) => Promise<void>;
+        onMessageReceived: (options?: {
+            sound?: SoundOptions;
+            haptic?: HapticFeedbackOptions;
+        }) => Promise<void>;
+    };
+};

package/lib/core/sound/index.d.ts

@@ -0,0 +1,5 @@
+export * from './types';
+export * from './sounds';
+export * from './hooks';
+export { SoundProvider, useSound, useHaptics } from './context';
+export * from './mockContext';

package/lib/core/sound/mockContext.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+import type { SoundContextType, SoundAsset, HapticFeedbackOptions } from './types';
+interface MockSoundProviderProps {
+    children: React.ReactNode;
+    /** Initial sound assets to register */
+    initialSounds?: SoundAsset[];
+    /** Whether to log sound actions to console */
+    enableLogging?: boolean;
+}
+export declare const MockSoundProvider: React.FC<MockSoundProviderProps>;
+/**
+ * Hook to access the mock sound context
+ */
+export declare const useMockSound: () => SoundContextType;
+/**
+ * Mock haptic feedback hook
+ */
+export declare const useMockHaptics: () => {
+    triggerHaptic: (options?: HapticFeedbackOptions) => Promise<void>;
+};
+export {};

package/lib/core/sound/sounds.d.ts

@@ -0,0 +1,17 @@
+import type { SoundAsset } from './types';
+/**
+ * Utility functions for working with sound collections
+ * These are used by apps to organize their own sound configurations
+ */
+/**
+ * Get all sounds from a sound collection as an array
+ */
+export declare const getAllSounds: (sounds: Record<string, SoundAsset>) => SoundAsset[];
+/**
+ * Get sounds by category from a sound collection
+ */
+export declare const getSoundsByCategory: (sounds: Record<string, SoundAsset>, category: SoundAsset["category"]) => SoundAsset[];
+/**
+ * Create a sound asset with sensible defaults
+ */
+export declare const createSound: (id: string, source: any, options: Partial<Omit<SoundAsset, "id" | "source">>) => SoundAsset;

package/lib/core/sound/types.d.ts

@@ -0,0 +1,79 @@
+export interface SoundOptions {
+    /** Volume level (0.0 to 1.0) */
+    volume?: number;
+    /** Whether to loop the sound */
+    loop?: boolean;
+    /** Playback rate (0.5 to 2.0) */
+    rate?: number;
+    /** Delay before playing (in milliseconds) */
+    delay?: number;
+    /** Seek to specific position before playing (in seconds) */
+    seekTo?: number;
+}
+export interface SoundAsset {
+    /** Unique identifier for the sound */
+    id: string;
+    /** Path to the sound file */
+    source: any;
+    /** Default options for this sound */
+    defaultOptions?: SoundOptions;
+    /** Human-readable name */
+    name?: string;
+    /** Category for organization */
+    category?: SoundCategory;
+    /** Whether this sound respects reduced motion preferences */
+    respectsReducedMotion?: boolean;
+}
+export type SoundCategory = 'ui' | 'feedback' | 'notification' | 'alert' | 'success' | 'error' | 'navigation' | 'ambient' | 'custom';
+export interface SoundContextType {
+    /** Whether sounds are globally enabled */
+    enabled: boolean;
+    /** Global volume (0.0 to 1.0) */
+    volume: number;
+    /** Whether reduced motion preference affects sounds */
+    respectsReducedMotion: boolean;
+    /** Play a sound by ID */
+    playSound: (soundId: string, options?: SoundOptions) => Promise<void>;
+    /** Stop a specific sound */
+    stopSound: (soundId: string) => Promise<void>;
+    /** Stop all sounds */
+    stopAllSounds: () => Promise<void>;
+    /** Preload sounds for better performance */
+    preloadSounds: (soundIds: string[]) => Promise<void>;
+    /** Register a new sound asset */
+    registerSound: (sound: SoundAsset) => void;
+    /** Unregister a sound asset */
+    unregisterSound: (soundId: string) => Promise<void>;
+    /** Enable/disable sounds globally */
+    setEnabled: (enabled: boolean) => void;
+    /** Set global volume */
+    setVolume: (volume: number) => void;
+    /** Set reduced motion respect */
+    setRespectsReducedMotion: (respects: boolean) => void;
+    /** Get current sound state */
+    getSoundState: (soundId: string) => SoundState | null;
+}
+export interface SoundState {
+    /** Whether the sound is currently playing */
+    playing: boolean;
+    /** Whether the sound is loaded and ready to play */
+    isLoaded: boolean;
+    /** Current position in seconds */
+    currentTime: number;
+    /** Duration in seconds */
+    duration: number;
+    /** Current volume */
+    volume: number;
+    /** Whether the sound is muted */
+    muted: boolean;
+    /** Whether the sound is looping */
+    loop: boolean;
+    /** Current playback rate */
+    playbackRate: number;
+}
+export interface HapticFeedbackOptions {
+    /** Type of haptic feedback */
+    type?: 'light' | 'medium' | 'heavy' | 'success' | 'warning' | 'error' | 'selection';
+    /** Whether to respect reduced motion preferences */
+    respectsReducedMotion?: boolean;
+}

package/lib/core/style-factory.d.ts

@@ -0,0 +1,23 @@
+import { ViewStyle, TextStyle } from 'react-native';
+import { PlatformBlocksTheme, SizeValue } from './theme/types';
+/**
+ * Factory for creating consistent component styles
+ * This centralizes styling logic and ensures consistency across components
+ */
+export interface StyleFactoryConfig {
+    component: 'input' | 'button' | 'card' | 'badge' | 'select' | 'generic';
+    variant?: string;
+    size?: SizeValue;
+    disabled?: boolean;
+    error?: boolean;
+    focused?: boolean;
+    radius?: any;
+}
+/**
+ * Base component style factory
+ */
+export declare function createComponentStyles(theme: PlatformBlocksTheme, config: StyleFactoryConfig): {
+    container: ViewStyle;
+    content: ViewStyle;
+    text: TextStyle;
+};

package/lib/core/theme/CSSVariables.d.ts

@@ -0,0 +1,9 @@
+interface CSSVariablesProps {
+    /** CSS selector where variables should be applied */
+    selector?: string;
+}
+/**
+ * Component that injects CSS variables based on the current theme
+ */
+export declare function CSSVariables({ selector }: CSSVariablesProps): null;
+export {};

package/lib/core/theme/PlatformBlocksProvider.d.ts

@@ -0,0 +1,52 @@
+import React from 'react';
+import { PlatformBlocksThemeProviderProps } from './ThemeProvider';
+import { ThemeModeConfig } from './ThemeModeProvider';
+export interface PlatformBlocksProviderProps extends Omit<PlatformBlocksThemeProviderProps, 'children'> {
+    /** Your application */
+    children: React.ReactNode;
+    /** Whether to inject CSS variables */
+    withCSSVariables?: boolean;
+    /** CSS selector where variables should be applied */
+    cssVariablesSelector?: string;
+    /**
+     * Color scheme mode:
+     * - 'auto': automatically follows OS preference
+     * - 'light': force light mode
+     * - 'dark': force dark mode
+     */
+    colorSchemeMode?: 'auto' | 'light' | 'dark';
+    /** Whether to enable overlay system (menus, tooltips, etc.) */
+    withOverlays?: boolean;
+    /** Whether to inject global CSS for universal props (lightHidden/darkHidden) */
+    withGlobalCSS?: boolean;
+    /** Enhanced theme mode configuration */
+    themeModeConfig?: ThemeModeConfig;
+    /** Lazily mount Spotlight search UI at library level (opt-in) */
+    withSpotlight?: boolean;
+    /** Configure Spotlight behavior at provider level */
+    spotlightConfig?: {
+        shortcut?: string | string[] | null;
+        actions?: any[];
+        placeholder?: string;
+        limit?: number;
+        highlightQuery?: boolean;
+        /** Render Spotlight even when no actions provided (useful to inject later) */
+        alwaysMount?: boolean;
+    };
+    /** i18n: initial active locale */
+    locale?: string;
+    /** i18n: fallback locale */
+    fallbackLocale?: string;
+    /** i18n: resources map */
+    i18nResources?: Record<string, {
+        translation: Record<string, any>;
+    }>;
+}
+/**
+ * Main provider component for Platform Blocks library
+ * Provides theme context and injects CSS variables
+ */
+export declare function PlatformBlocksProvider({ children, theme, inherit, withCSSVariables, cssVariablesSelector, colorSchemeMode, withOverlays, withSpotlight, withGlobalCSS, themeModeConfig, spotlightConfig, locale, fallbackLocale, i18nResources }: PlatformBlocksProviderProps): React.JSX.Element;
+export declare namespace PlatformBlocksProvider {
+    var displayName: string;
+}

package/lib/core/theme/ThemeModeProvider.d.ts

@@ -0,0 +1,42 @@
+import React from 'react';
+export type ColorSchemeMode = 'light' | 'dark' | 'auto';
+export interface ThemeModeConfig {
+    /** Initial color scheme mode */
+    initialMode?: ColorSchemeMode;
+    /** Custom persistence functions (optional) */
+    persistence?: {
+        get: () => ColorSchemeMode | null;
+        set: (mode: ColorSchemeMode) => void;
+    };
+    /** Custom DOM manipulation (web only, optional) */
+    domConfig?: {
+        selector: string;
+        lightClass: string;
+        darkClass: string;
+        attribute: string;
+    };
+}
+interface ThemeModeContextValue {
+    mode: ColorSchemeMode;
+    setMode: (mode: ColorSchemeMode) => void;
+    cycleMode: () => void;
+    actualColorScheme: 'light' | 'dark';
+}
+/**
+ * Enhanced theme mode provider that manages color scheme with persistence
+ */
+export declare function ThemeModeProvider({ children, config }: {
+    children: React.ReactNode;
+    config?: ThemeModeConfig;
+}): React.JSX.Element;
+/**
+ * Hook to access theme mode context
+ */
+export declare function useThemeMode(): ThemeModeContextValue;
+/**
+ * Hook to get only the resolved color scheme for theming
+ */
+export declare function useColorScheme(): 'light' | 'dark';
+export declare function useOptionalThemeMode(): ThemeModeContextValue | null;
+export declare function useOptionalColorScheme(): 'light' | 'dark' | null;
+export {};

package/lib/core/theme/ThemeProvider.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+import { PlatformBlocksTheme, PlatformBlocksThemeOverride } from './types';
+export interface PlatformBlocksThemeProviderProps {
+    /** Theme override object */
+    theme?: PlatformBlocksThemeOverride;
+    /** Whether to inherit theme from parent provider */
+    inherit?: boolean;
+    /** Children to render */
+    children: React.ReactNode;
+}
+export declare function PlatformBlocksThemeProvider({ theme, inherit, children }: PlatformBlocksThemeProviderProps): React.JSX.Element;
+/**
+ * Hook to access the current theme
+ */
+export declare function useTheme(): PlatformBlocksTheme;
+/**
+ * Hook that safely returns theme or default theme
+ */
+export declare function useSafePlatformBlocksTheme(): PlatformBlocksTheme;