@exyconn/common 1.0.0 → 2.1.0

package/dist/index-bvvCev9Q.d.mts

@@ -0,0 +1,2946 @@
+import { ApiResponse, HttpClientOptions, PaginatedResponse, createHttpClient, isForbidden, isNotFound, isServerError, isStatusError, isSuccess, isUnauthorized, parseError, parseFullResponse, parseResponse, withAbortSignal, withFormData, withTimeout } from './client/http/index.mjs';
+import { ClientLogger, ClientLoggerConfig, LogLevel, clientLogger, createClientLogger } from './client/logger/index.mjs';
+import { ApiUrlBuilder, ApiUrlConfig, EventEmitter, NpmRegistryResponse, PackageCheckResult, PackageJson, PackageVersion, addDays, appEvents, camelToKebab, capitalize, capitalizeWords, checkPackage, copyToClipboard, createApiEndpoints, createApiUrlBuilder, createEmptyPaginationMeta, createErrorResponse, createEventEmitter, createSuccessResponse, endOfDay, formatDate, formatDateForInput, formatDateTime, formatDateTimeForInput, formatPackageCheckResult, formatRelativeTime, generateNcuCommand, getErrorMessage, getNextPage, getPrevPage, getResponseData, hasData, hasMorePages, isClipboardAvailable, isErrorResponse, isFuture, isPast, isSuccessResponse, isToday, kebabToCamel, packageCheck, readFromClipboard, slugify, slugifyUnique, startOfDay, truncate, truncateWords, unslugify } from './client/utils/index.mjs';
+import React$1, { RefObject } from 'react';
+import * as Yup from 'yup';
+
+interface UseToggleReturn {
+    /** Current boolean value */
+    value: boolean;
+    /** Toggle the value */
+    toggle: () => void;
+    /** Set to true */
+    setTrue: () => void;
+    /** Set to false */
+    setFalse: () => void;
+    /** Set to specific value */
+    setValue: (value: boolean) => void;
+}
+/**
+ * Hook to manage boolean state with toggle functionality
+ * @param initialValue - Initial boolean value (default: false)
+ */
+declare function useToggle(initialValue?: boolean): UseToggleReturn;
+
+interface UseCounterOptions {
+    /** Minimum value */
+    min?: number;
+    /** Maximum value */
+    max?: number;
+    /** Step value for increment/decrement */
+    step?: number;
+}
+interface UseCounterReturn {
+    /** Current count value */
+    count: number;
+    /** Increment by step */
+    increment: () => void;
+    /** Decrement by step */
+    decrement: () => void;
+    /** Set to specific value */
+    set: (value: number) => void;
+    /** Reset to initial value */
+    reset: () => void;
+}
+/**
+ * Hook to manage numeric counter with min/max bounds
+ * @param initialValue - Initial counter value (default: 0)
+ * @param options - Configuration options
+ */
+declare function useCounter(initialValue?: number, options?: UseCounterOptions): UseCounterReturn;
+
+/**
+ * Hook that returns a default value when state is null or undefined
+ * @param initialValue - Initial value (can be null/undefined)
+ * @param defaultValue - Default value to use when state is null/undefined
+ */
+declare function useDefault<T>(initialValue: T | null | undefined, defaultValue: T): [T, (value: T | null | undefined) => void];
+
+/**
+ * Hook to get the previous value of a state or prop
+ * @param value - Current value to track
+ * @param initialValue - Optional initial previous value
+ */
+declare function usePrevious<T>(value: T, initialValue?: T): T | undefined;
+
+type ObjectStateUpdate<T> = Partial<T> | ((prevState: T) => Partial<T>);
+interface UseObjectStateReturn<T extends object> {
+    /** Current state object */
+    state: T;
+    /** Update state with partial object (merges with existing) */
+    setState: (update: ObjectStateUpdate<T>) => void;
+    /** Reset to initial state */
+    resetState: () => void;
+    /** Set a single property */
+    setProperty: <K extends keyof T>(key: K, value: T[K]) => void;
+    /** Remove a property (sets to undefined) */
+    removeProperty: <K extends keyof T>(key: K) => void;
+}
+/**
+ * Hook to manage object state with partial updates
+ * @param initialState - Initial state object
+ */
+declare function useObjectState<T extends object>(initialState: T): UseObjectStateReturn<T>;
+
+interface UseHistoryStateReturn<T> {
+    /** Current state value */
+    state: T;
+    /** Set new state (adds to history) */
+    setState: (value: T | ((prev: T) => T)) => void;
+    /** Undo to previous state */
+    undo: () => void;
+    /** Redo to next state */
+    redo: () => void;
+    /** Clear all history and reset to current or initial */
+    clear: (value?: T) => void;
+    /** Can undo? */
+    canUndo: boolean;
+    /** Can redo? */
+    canRedo: boolean;
+    /** Full history array */
+    history: T[];
+    /** Current position in history */
+    pointer: number;
+    /** Go to specific position in history */
+    go: (index: number) => void;
+}
+interface UseHistoryStateOptions {
+    /** Maximum history length (default: 100) */
+    maxLength?: number;
+}
+/**
+ * Hook to manage state with undo/redo functionality
+ * @param initialValue - Initial state value
+ * @param options - Configuration options
+ */
+declare function useHistoryState<T>(initialValue: T, options?: UseHistoryStateOptions): UseHistoryStateReturn<T>;
+
+interface UseQueueReturn<T> {
+    /** Current queue items */
+    queue: T[];
+    /** Add item to end of queue */
+    enqueue: (item: T) => void;
+    /** Add multiple items to end of queue */
+    enqueueAll: (items: T[]) => void;
+    /** Remove and return first item */
+    dequeue: () => T | undefined;
+    /** Peek at first item without removing */
+    peek: () => T | undefined;
+    /** Clear the queue */
+    clear: () => void;
+    /** Queue size */
+    size: number;
+    /** Is queue empty? */
+    isEmpty: boolean;
+    /** First item in queue */
+    first: T | undefined;
+    /** Last item in queue */
+    last: T | undefined;
+}
+/**
+ * Hook to manage a FIFO queue
+ * @param initialValue - Initial queue items (default: [])
+ */
+declare function useQueue<T>(initialValue?: T[]): UseQueueReturn<T>;
+
+interface UseListReturn<T> {
+    /** Current list items */
+    list: T[];
+    /** Set entire list */
+    set: (newList: T[]) => void;
+    /** Add item to end */
+    push: (item: T) => void;
+    /** Add item to beginning */
+    unshift: (item: T) => void;
+    /** Remove item at index */
+    removeAt: (index: number) => void;
+    /** Remove first matching item */
+    remove: (item: T) => void;
+    /** Remove items matching predicate */
+    removeWhere: (predicate: (item: T) => boolean) => void;
+    /** Update item at index */
+    updateAt: (index: number, item: T) => void;
+    /** Update item at index with function */
+    updateWhere: (predicate: (item: T) => boolean, updater: (item: T) => T) => void;
+    /** Insert item at index */
+    insertAt: (index: number, item: T) => void;
+    /** Move item from one index to another */
+    move: (fromIndex: number, toIndex: number) => void;
+    /** Clear the list */
+    clear: () => void;
+    /** Reset to initial value */
+    reset: () => void;
+    /** Filter items */
+    filter: (predicate: (item: T) => boolean) => void;
+    /** Sort items */
+    sort: (compareFn?: (a: T, b: T) => number) => void;
+    /** Reverse items */
+    reverse: () => void;
+    /** List size */
+    size: number;
+    /** Is list empty? */
+    isEmpty: boolean;
+    /** First item */
+    first: T | undefined;
+    /** Last item */
+    last: T | undefined;
+}
+/**
+ * Hook to manage array/list with utility methods
+ * @param initialValue - Initial list items (default: [])
+ */
+declare function useList<T>(initialValue?: T[]): UseListReturn<T>;
+
+interface UseMapReturn<K, V> {
+    /** Current map */
+    map: Map<K, V>;
+    /** Get value by key */
+    get: (key: K) => V | undefined;
+    /** Set key-value pair */
+    set: (key: K, value: V) => void;
+    /** Set multiple entries */
+    setAll: (entries: Iterable<[K, V]>) => void;
+    /** Check if key exists */
+    has: (key: K) => boolean;
+    /** Delete by key */
+    remove: (key: K) => void;
+    /** Delete multiple keys */
+    removeAll: (keys: K[]) => void;
+    /** Clear the map */
+    clear: () => void;
+    /** Reset to initial value */
+    reset: () => void;
+    /** Map size */
+    size: number;
+    /** All keys */
+    keys: K[];
+    /** All values */
+    values: V[];
+    /** All entries */
+    entries: [K, V][];
+    /** Is map empty? */
+    isEmpty: boolean;
+}
+/**
+ * Hook to manage Map state with utility methods
+ * @param initialValue - Initial entries (default: [])
+ */
+declare function useMap<K, V>(initialValue?: Iterable<[K, V]>): UseMapReturn<K, V>;
+
+interface UseSetReturn<T> {
+    /** Current set */
+    set: Set<T>;
+    /** Add item to set */
+    add: (item: T) => void;
+    /** Add multiple items */
+    addAll: (items: Iterable<T>) => void;
+    /** Check if item exists */
+    has: (item: T) => boolean;
+    /** Remove item from set */
+    remove: (item: T) => void;
+    /** Remove multiple items */
+    removeAll: (items: Iterable<T>) => void;
+    /** Toggle item (add if not exists, remove if exists) */
+    toggle: (item: T) => void;
+    /** Clear the set */
+    clear: () => void;
+    /** Reset to initial value */
+    reset: () => void;
+    /** Set size */
+    size: number;
+    /** All values as array */
+    values: T[];
+    /** Is set empty? */
+    isEmpty: boolean;
+}
+/**
+ * Hook to manage Set state with utility methods
+ * @param initialValue - Initial items (default: [])
+ */
+declare function useSet<T>(initialValue?: Iterable<T>): UseSetReturn<T>;
+
+/**
+ * Debounce a value with configurable delay
+ * @param value - Value to debounce
+ * @param delay - Delay in milliseconds (default: 500)
+ */
+declare function useDebounce<T>(value: T, delay?: number): T;
+
+/**
+ * Throttle a value with configurable interval
+ * @param value - Value to throttle
+ * @param interval - Minimum interval between updates in milliseconds (default: 500)
+ */
+declare function useThrottle<T>(value: T, interval?: number): T;
+
+interface UseTimeoutReturn {
+    /** Reset the timeout */
+    reset: () => void;
+    /** Clear/cancel the timeout */
+    clear: () => void;
+}
+/**
+ * Hook to manage setTimeout declaratively
+ * @param callback - Function to call after timeout
+ * @param delay - Delay in milliseconds (null to disable)
+ */
+declare function useTimeout(callback: () => void, delay: number | null): UseTimeoutReturn;
+
+/**
+ * Run a callback on an interval
+ * @param callback - Function to call on each interval
+ * @param delay - Interval delay in ms (null to pause)
+ */
+declare function useInterval(callback: () => void, delay: number | null): void;
+
+/**
+ * Hook to run interval conditionally
+ * @param callback - Function to call on each interval
+ * @param delay - Interval delay in milliseconds
+ * @param when - Condition to run the interval
+ * @param immediate - Run callback immediately when condition becomes true
+ */
+declare function useIntervalWhen(callback: () => void, delay: number, when: boolean, immediate?: boolean): void;
+
+/**
+ * Hook to run callback at random intervals
+ * @param callback - Function to call on each interval
+ * @param minDelay - Minimum delay in milliseconds
+ * @param maxDelay - Maximum delay in milliseconds
+ * @param enabled - Whether the interval is enabled (default: true)
+ */
+declare function useRandomInterval(callback: () => void, minDelay: number, maxDelay: number, enabled?: boolean): void;
+
+interface UseCountdownOptions {
+    /** Interval in milliseconds (default: 1000) */
+    interval?: number;
+    /** Callback when countdown reaches zero */
+    onComplete?: () => void;
+    /** Auto-start the countdown (default: false) */
+    autoStart?: boolean;
+}
+interface UseCountdownReturn {
+    /** Current countdown value in milliseconds */
+    count: number;
+    /** Start the countdown */
+    start: () => void;
+    /** Pause the countdown */
+    pause: () => void;
+    /** Resume the countdown */
+    resume: () => void;
+    /** Reset to initial value */
+    reset: (newCount?: number) => void;
+    /** Is countdown running? */
+    isRunning: boolean;
+    /** Is countdown complete? */
+    isComplete: boolean;
+    /** Formatted time { days, hours, minutes, seconds } */
+    formatted: {
+        days: number;
+        hours: number;
+        minutes: number;
+        seconds: number;
+    };
+}
+/**
+ * Hook to manage countdown timer
+ * @param initialCount - Initial countdown value in milliseconds
+ * @param options - Configuration options
+ */
+declare function useCountdown(initialCount: number, options?: UseCountdownOptions): UseCountdownReturn;
+
+interface UseContinuousRetryOptions {
+    /** Maximum number of retry attempts (default: Infinity) */
+    maxAttempts?: number;
+    /** Delay between retries in milliseconds (default: 1000) */
+    delay?: number;
+    /** Whether to use exponential backoff (default: false) */
+    exponentialBackoff?: boolean;
+    /** Maximum delay when using exponential backoff (default: 30000) */
+    maxDelay?: number;
+    /** Auto-start retrying (default: true) */
+    autoStart?: boolean;
+}
+interface UseContinuousRetryReturn {
+    /** Number of attempts made */
+    attempts: number;
+    /** Last error encountered */
+    error: Error | null;
+    /** Is currently retrying? */
+    isRetrying: boolean;
+    /** Has succeeded? */
+    isSuccess: boolean;
+    /** Has reached max attempts? */
+    isMaxAttempts: boolean;
+    /** Start/restart retrying */
+    start: () => void;
+    /** Stop retrying */
+    stop: () => void;
+    /** Reset state */
+    reset: () => void;
+}
+/**
+ * Hook to continuously retry a function until success
+ * @param callback - Async function to retry (return true for success, false for retry)
+ * @param options - Configuration options
+ */
+declare function useContinuousRetry(callback: () => Promise<boolean> | boolean, options?: UseContinuousRetryOptions): UseContinuousRetryReturn;
+
+interface WindowSize {
+    width: number;
+    height: number;
+}
+/**
+ * Track window dimensions with resize updates
+ * @param debounceMs - Debounce resize events (default: 100ms)
+ */
+declare function useWindowSize(debounceMs?: number): WindowSize;
+
+interface WindowScrollPosition {
+    /** Horizontal scroll position */
+    x: number;
+    /** Vertical scroll position */
+    y: number;
+    /** Scroll direction (up, down, left, right, or null) */
+    direction: 'up' | 'down' | 'left' | 'right' | null;
+    /** Is scrolling? */
+    isScrolling: boolean;
+}
+interface UseWindowScrollReturn extends WindowScrollPosition {
+    /** Scroll to position */
+    scrollTo: (options: ScrollToOptions) => void;
+    /** Scroll to top */
+    scrollToTop: (behavior?: ScrollBehavior) => void;
+    /** Scroll to bottom */
+    scrollToBottom: (behavior?: ScrollBehavior) => void;
+}
+/**
+ * Hook to track and control window scroll position
+ */
+declare function useWindowScroll(): UseWindowScrollReturn;
+
+interface UseDocumentTitleOptions {
+    /** Restore previous title on unmount (default: true) */
+    restoreOnUnmount?: boolean;
+    /** Title template, use %s for title placeholder */
+    template?: string;
+}
+/**
+ * Hook to set document title
+ * @param title - Document title
+ * @param options - Configuration options
+ */
+declare function useDocumentTitle(title: string, options?: UseDocumentTitleOptions): void;
+
+interface UsePageTitleOptions {
+    /** Suffix to append to the title (e.g., organization name) */
+    suffix?: string;
+    /** Separator between title and suffix (default: ' | ') */
+    separator?: string;
+    /** Whether to restore original title on unmount (default: true) */
+    restoreOnUnmount?: boolean;
+}
+/**
+ * Set the document title with optional suffix
+ * @param title - Page title
+ * @param options - Configuration options
+ */
+declare function usePageTitle(title: string, options?: UsePageTitleOptions): void;
+
+/**
+ * Hook to dynamically change favicon
+ * @param href - URL of the favicon image
+ * @param restoreOnUnmount - Whether to restore original favicon on unmount (default: true)
+ */
+declare function useFavicon(href: string, restoreOnUnmount?: boolean): void;
+
+interface UseVisibilityChangeReturn {
+    /** Is document visible? */
+    isVisible: boolean;
+    /** Visibility state ('visible', 'hidden', 'prerender') */
+    visibilityState: DocumentVisibilityState;
+    /** Time when visibility last changed */
+    lastChanged: Date | null;
+}
+/**
+ * Hook to track document visibility state
+ * @param onVisibilityChange - Optional callback when visibility changes
+ */
+declare function useVisibilityChange(onVisibilityChange?: (isVisible: boolean) => void): UseVisibilityChangeReturn;
+
+interface UsePageLeaveOptions {
+    /** Show confirmation dialog on page leave (default: false) */
+    showConfirmation?: boolean;
+    /** Custom confirmation message (browser may override) */
+    confirmationMessage?: string;
+}
+/**
+ * Hook to detect when user is leaving the page
+ * @param onLeave - Callback when user attempts to leave
+ * @param options - Configuration options
+ */
+declare function usePageLeave(onLeave?: () => void, options?: UsePageLeaveOptions): void;
+
+/**
+ * Hook to lock body scroll
+ * @param locked - Whether scroll should be locked (default: true)
+ */
+declare function useLockBodyScroll(locked?: boolean): void;
+
+/**
+ * Hook to check if rendering on client side
+ * Useful for SSR/SSG environments
+ */
+declare function useIsClient(): boolean;
+
+/**
+ * Hook to check if it's the first render
+ */
+declare function useIsFirstRender(): boolean;
+
+type EventMap = WindowEventMap & DocumentEventMap & HTMLElementEventMap;
+/**
+ * Hook to attach event listeners declaratively
+ * @param eventName - Name of the event to listen for
+ * @param handler - Event handler function
+ * @param element - Target element (default: window)
+ * @param options - AddEventListener options
+ */
+declare function useEventListener<K extends keyof EventMap>(eventName: K, handler: (event: EventMap[K]) => void, element?: HTMLElement | Window | Document | null, options?: boolean | AddEventListenerOptions): void;
+
+interface UseKeyPressOptions {
+    /** Target element (default: document) */
+    target?: HTMLElement | Document | Window | null;
+    /** Event type: 'keydown' | 'keyup' | 'keypress' */
+    event?: 'keydown' | 'keyup' | 'keypress';
+    /** Prevent default behavior */
+    preventDefault?: boolean;
+    /** Stop event propagation */
+    stopPropagation?: boolean;
+}
+interface UseKeyPressReturn {
+    /** Is the key currently pressed? */
+    pressed: boolean;
+    /** Event object from last press */
+    event: KeyboardEvent | null;
+}
+/**
+ * Hook to detect key press
+ * @param targetKey - Key to detect (e.g., 'Enter', 'Escape', 'a')
+ * @param callback - Optional callback when key is pressed
+ * @param options - Configuration options
+ */
+declare function useKeyPress(targetKey: string | string[], callback?: (event: KeyboardEvent) => void, options?: UseKeyPressOptions): UseKeyPressReturn;
+
+interface UseHoverReturn<T extends HTMLElement = HTMLElement> {
+    /** Ref to attach to the target element */
+    ref: React.RefObject<T | null>;
+    /** Is element being hovered? */
+    isHovered: boolean;
+    /** Bind props to spread on element */
+    bind: {
+        onMouseEnter: () => void;
+        onMouseLeave: () => void;
+    };
+}
+/**
+ * Hook to detect hover state
+ * @param onHoverChange - Optional callback when hover state changes
+ */
+declare function useHover<T extends HTMLElement = HTMLElement>(onHoverChange?: (isHovered: boolean) => void): UseHoverReturn<T>;
+
+type EventType = 'mousedown' | 'mouseup' | 'touchstart' | 'touchend';
+/**
+ * Hook to detect clicks outside of an element
+ * @param callback - Function to call when click outside occurs
+ * @param events - Event types to listen for (default: ['mousedown', 'touchstart'])
+ */
+declare function useClickAway<T extends HTMLElement = HTMLElement>(callback: (event: MouseEvent | TouchEvent) => void, events?: EventType[]): React.RefObject<T | null>;
+
+/**
+ * useOnClickOutside Hook
+ * Detect clicks outside of a referenced element
+ */
+
+type Handler = (event: MouseEvent | TouchEvent) => void;
+/**
+ * Detect clicks outside of a referenced element
+ * @param ref - React ref to the element
+ * @param handler - Callback when click outside occurs
+ * @param enabled - Whether the hook is enabled (default: true)
+ */
+declare function useOnClickOutside<T extends HTMLElement = HTMLElement>(ref: RefObject<T>, handler: Handler, enabled?: boolean): void;
+
+interface UseLongPressOptions {
+    /** Threshold in milliseconds (default: 400) */
+    threshold?: number;
+    /** Callback on long press */
+    onLongPress?: (event: React.MouseEvent | React.TouchEvent) => void;
+    /** Callback on regular click */
+    onClick?: (event: React.MouseEvent | React.TouchEvent) => void;
+    /** Callback when press starts */
+    onStart?: (event: React.MouseEvent | React.TouchEvent) => void;
+    /** Callback when press ends */
+    onFinish?: (event: React.MouseEvent | React.TouchEvent) => void;
+    /** Callback when press is cancelled */
+    onCancel?: (event: React.MouseEvent | React.TouchEvent) => void;
+}
+interface UseLongPressReturn {
+    /** Is currently pressing? */
+    isPressed: boolean;
+    /** Is long press achieved? */
+    isLongPress: boolean;
+    /** Bind props to spread on element */
+    bind: {
+        onMouseDown: (e: React.MouseEvent) => void;
+        onMouseUp: (e: React.MouseEvent) => void;
+        onMouseLeave: (e: React.MouseEvent) => void;
+        onTouchStart: (e: React.TouchEvent) => void;
+        onTouchEnd: (e: React.TouchEvent) => void;
+    };
+}
+/**
+ * Hook to detect long press gesture
+ * @param options - Configuration options
+ */
+declare function useLongPress(options?: UseLongPressOptions): UseLongPressReturn;
+
+interface MousePosition {
+    /** X position relative to viewport */
+    x: number;
+    /** Y position relative to viewport */
+    y: number;
+    /** X position relative to page */
+    pageX: number;
+    /** Y position relative to page */
+    pageY: number;
+    /** X position relative to element (if ref provided) */
+    elementX: number;
+    /** Y position relative to element (if ref provided) */
+    elementY: number;
+    /** Is mouse within element bounds? */
+    isInElement: boolean;
+}
+interface UseMouseOptions {
+    /** Whether to track (default: true) */
+    enabled?: boolean;
+}
+interface UseMouseReturn<T extends HTMLElement = HTMLElement> extends MousePosition {
+    /** Ref to attach to element for relative positioning */
+    ref: React.RefObject<T | null>;
+}
+/**
+ * Hook to track mouse position
+ * @param options - Configuration options
+ */
+declare function useMouse<T extends HTMLElement = HTMLElement>(options?: UseMouseOptions): UseMouseReturn<T>;
+
+interface UseCopyToClipboardReturn {
+    /** Copy text to clipboard */
+    copy: (text: string) => Promise<boolean>;
+    /** Whether copy was successful (resets after timeout) */
+    copied: boolean;
+    /** Error message if copy failed */
+    error: string | null;
+    /** Reset state */
+    reset: () => void;
+}
+/**
+ * Copy text to clipboard with feedback
+ * @param resetDelay - Time in ms before copied state resets (default: 2000)
+ */
+declare function useCopyToClipboard(resetDelay?: number): UseCopyToClipboardReturn;
+
+/**
+ * Track a media query match
+ * @param query - CSS media query string (e.g., '(min-width: 768px)')
+ */
+declare function useMediaQuery(query: string): boolean;
+declare const useIsMobile: () => boolean;
+declare const useIsTablet: () => boolean;
+declare const useIsDesktop: () => boolean;
+declare const useIsMobileOrTablet: () => boolean;
+
+interface OrientationState {
+    /** Device orientation angle */
+    angle: number;
+    /** Orientation type */
+    type: OrientationType;
+    /** Is portrait? */
+    isPortrait: boolean;
+    /** Is landscape? */
+    isLandscape: boolean;
+}
+/**
+ * Hook to track device/screen orientation
+ */
+declare function useOrientation(): OrientationState;
+
+interface BatteryState {
+    /** Is battery API supported? */
+    isSupported: boolean;
+    /** Is device charging? */
+    charging: boolean;
+    /** Time until fully charged (seconds), Infinity if not charging */
+    chargingTime: number;
+    /** Time until discharged (seconds), Infinity if charging */
+    dischargingTime: number;
+    /** Battery level (0 to 1) */
+    level: number;
+    /** Battery percentage (0 to 100) */
+    percentage: number;
+}
+/**
+ * Hook to track battery status
+ */
+declare function useBattery(): BatteryState;
+
+interface NetworkState {
+    /** Is online? */
+    online: boolean;
+    /** Is offline? */
+    offline: boolean;
+    /** Connection downlink speed (Mbps) */
+    downlink?: number;
+    /** Effective connection type */
+    effectiveType?: 'slow-2g' | '2g' | '3g' | '4g';
+    /** Round-trip time (ms) */
+    rtt?: number;
+    /** Is data saver enabled? */
+    saveData?: boolean;
+    /** Connection type */
+    type?: string;
+    /** Time when status last changed */
+    since?: Date;
+}
+/**
+ * Hook to track network status
+ */
+declare function useNetworkState(): NetworkState;
+
+interface UseIdleOptions {
+    /** Idle timeout in milliseconds (default: 60000 = 1 minute) */
+    timeout?: number;
+    /** Events to consider as activity */
+    events?: string[];
+    /** Initial idle state */
+    initialState?: boolean;
+    /** Callback when user becomes idle */
+    onIdle?: () => void;
+    /** Callback when user becomes active */
+    onActive?: () => void;
+}
+interface UseIdleReturn {
+    /** Is user idle? */
+    isIdle: boolean;
+    /** Last active timestamp */
+    lastActive: Date;
+    /** Reset idle timer */
+    reset: () => void;
+    /** Start tracking */
+    start: () => void;
+    /** Stop tracking */
+    stop: () => void;
+}
+/**
+ * Hook to detect user idle state
+ * @param options - Configuration options
+ */
+declare function useIdle(options?: UseIdleOptions): UseIdleReturn;
+
+interface GeolocationState {
+    /** Is loading? */
+    loading: boolean;
+    /** Error message */
+    error: string | null;
+    /** Latitude */
+    latitude: number | null;
+    /** Longitude */
+    longitude: number | null;
+    /** Accuracy in meters */
+    accuracy: number | null;
+    /** Altitude in meters */
+    altitude: number | null;
+    /** Altitude accuracy in meters */
+    altitudeAccuracy: number | null;
+    /** Heading in degrees */
+    heading: number | null;
+    /** Speed in m/s */
+    speed: number | null;
+    /** Timestamp */
+    timestamp: number | null;
+}
+interface UseGeolocationOptions {
+    /** Enable high accuracy mode */
+    enableHighAccuracy?: boolean;
+    /** Maximum age of cached position (ms) */
+    maximumAge?: number;
+    /** Timeout for getting position (ms) */
+    timeout?: number;
+    /** Watch position continuously */
+    watch?: boolean;
+}
+interface UseGeolocationReturn extends GeolocationState {
+    /** Refresh position */
+    refresh: () => void;
+    /** Is geolocation supported? */
+    isSupported: boolean;
+}
+/**
+ * Hook to track geolocation
+ * @param options - Configuration options
+ */
+declare function useGeolocation(options?: UseGeolocationOptions): UseGeolocationReturn;
+
+interface UsePreferredLanguageReturn {
+    /** Primary preferred language */
+    language: string;
+    /** All preferred languages */
+    languages: readonly string[];
+}
+/**
+ * Hook to get user's preferred language
+ */
+declare function usePreferredLanguage(): UsePreferredLanguageReturn;
+
+type ThemeMode$1 = 'light' | 'dark';
+/**
+ * Detect and track system color scheme preference
+ * @returns Current theme mode based on system preference
+ */
+declare function useThemeDetector(): ThemeMode$1;
+
+type SetValue<T> = T | ((prevValue: T) => T);
+interface UseLocalStorageOptions<T> {
+    /** Serialize function (default: JSON.stringify) */
+    serializer?: (value: T) => string;
+    /** Deserialize function (default: JSON.parse) */
+    deserializer?: (value: string) => T;
+    /** Enable cross-tab synchronization (default: true) */
+    syncTabs?: boolean;
+    /** Enable logging (default: false) */
+    debug?: boolean;
+}
+/**
+ * Hook to persist state in localStorage with cross-tab sync
+ * @param key - localStorage key
+ * @param initialValue - initial/fallback value
+ * @param options - configuration options
+ */
+declare function useLocalStorage<T>(key: string, initialValue: T, options?: UseLocalStorageOptions<T>): [T, (value: SetValue<T>) => void, () => void];
+
+interface UseSessionStorageOptions<T> {
+    /** Serialize function (default: JSON.stringify) */
+    serializer?: (value: T) => string;
+    /** Deserialize function (default: JSON.parse) */
+    deserializer?: (value: string) => T;
+    /** Enable logging (default: false) */
+    debug?: boolean;
+}
+/**
+ * Hook to persist state in sessionStorage
+ * @param key - sessionStorage key
+ * @param initialValue - initial/fallback value
+ * @param options - configuration options
+ */
+declare function useSessionStorage<T>(key: string, initialValue: T, options?: UseSessionStorageOptions<T>): [T, (value: SetValue<T>) => void, () => void];
+
+interface UseFetchOptions<T> extends Omit<RequestInit, 'body'> {
+    /** Request body (will be JSON.stringify'd if object) */
+    body?: BodyInit | object | null;
+    /** Skip initial fetch */
+    skip?: boolean;
+    /** Transform response data */
+    transform?: (data: unknown) => T;
+    /** Retry count on failure */
+    retries?: number;
+    /** Retry delay in ms */
+    retryDelay?: number;
+    /** Cache key (default: url) */
+    cacheKey?: string;
+    /** Cache time in ms */
+    cacheTime?: number;
+    /** Callback on success */
+    onSuccess?: (data: T) => void;
+    /** Callback on error */
+    onError?: (error: Error) => void;
+}
+interface UseFetchReturn<T> {
+    /** Response data */
+    data: T | null;
+    /** Is loading? */
+    loading: boolean;
+    /** Error */
+    error: Error | null;
+    /** Refetch data */
+    refetch: () => Promise<T | null>;
+    /** Abort current request */
+    abort: () => void;
+    /** Is fetching? (includes refetch) */
+    isFetching: boolean;
+    /** HTTP status code */
+    status: number | null;
+}
+/**
+ * Hook for data fetching with caching and retry support
+ * @param url - URL to fetch
+ * @param options - Fetch options
+ */
+declare function useFetch<T = unknown>(url: string | null, options?: UseFetchOptions<T>): UseFetchReturn<T>;
+
+type ScriptStatus = 'idle' | 'loading' | 'ready' | 'error';
+interface UseScriptOptions {
+    /** Should load script immediately (default: true) */
+    shouldLoad?: boolean;
+    /** Remove script on unmount (default: false) */
+    removeOnUnmount?: boolean;
+    /** Script attributes */
+    attributes?: Record<string, string>;
+}
+interface UseScriptReturn {
+    /** Script loading status */
+    status: ScriptStatus;
+    /** Is script ready? */
+    ready: boolean;
+    /** Is loading? */
+    loading: boolean;
+    /** Has error? */
+    error: boolean;
+    /** Load script manually */
+    load: () => void;
+    /** Remove script */
+    remove: () => void;
+}
+/**
+ * Hook to dynamically load external scripts
+ * @param src - Script source URL
+ * @param options - Configuration options
+ */
+declare function useScript(src: string, options?: UseScriptOptions): UseScriptReturn;
+
+interface RenderInfo {
+    /** Component name (if provided) */
+    name: string;
+    /** Total render count */
+    renders: number;
+    /** Time since last render (ms) */
+    sinceLastRender: number;
+    /** Timestamp of last render */
+    timestamp: number;
+}
+/**
+ * Hook to track render information for debugging
+ * @param componentName - Optional component name for identification
+ */
+declare function useRenderInfo(componentName?: string): RenderInfo;
+
+/**
+ * Hook to count component renders
+ */
+declare function useRenderCount(): number;
+
+interface UseLoggerOptions {
+    /** Log props changes */
+    logProps?: boolean;
+    /** Log lifecycle events */
+    logLifecycle?: boolean;
+    /** Custom logger function */
+    logger?: (...args: unknown[]) => void;
+}
+/**
+ * Hook to log component lifecycle and changes
+ * @param componentName - Name of the component
+ * @param props - Props to track changes
+ * @param options - Configuration options
+ */
+declare function useLogger(componentName: string, props?: Record<string, unknown>, options?: UseLoggerOptions): void;
+
+interface Dimensions {
+    /** Element width */
+    width: number;
+    /** Element height */
+    height: number;
+    /** Top position relative to viewport */
+    top: number;
+    /** Left position relative to viewport */
+    left: number;
+    /** Bottom position relative to viewport */
+    bottom: number;
+    /** Right position relative to viewport */
+    right: number;
+    /** X position (same as left) */
+    x: number;
+    /** Y position (same as top) */
+    y: number;
+}
+interface UseMeasureReturn<T extends HTMLElement = HTMLElement> {
+    /** Ref to attach to element */
+    ref: React.RefCallback<T>;
+    /** Element dimensions */
+    dimensions: Dimensions;
+    /** Manually trigger measurement */
+    measure: () => void;
+}
+/**
+ * Hook to measure element dimensions
+ */
+declare function useMeasure<T extends HTMLElement = HTMLElement>(): UseMeasureReturn<T>;
+
+interface UseIntersectionObserverOptions {
+    /** Root element (default: viewport) */
+    root?: Element | null;
+    /** Root margin (default: '0px') */
+    rootMargin?: string;
+    /** Intersection threshold(s) (default: 0) */
+    threshold?: number | number[];
+    /** Freeze after first intersection */
+    freezeOnceVisible?: boolean;
+    /** Initial visibility state */
+    initialIsIntersecting?: boolean;
+    /** Callback when intersection changes */
+    onChange?: (isIntersecting: boolean, entry: IntersectionObserverEntry) => void;
+}
+interface UseIntersectionObserverReturn<T extends Element = Element> {
+    /** Ref to attach to element */
+    ref: React.RefCallback<T>;
+    /** Is element intersecting? */
+    isIntersecting: boolean;
+    /** Full intersection entry */
+    entry: IntersectionObserverEntry | null;
+}
+/**
+ * Hook to observe element intersection with viewport
+ * @param options - IntersectionObserver options
+ */
+declare function useIntersectionObserver<T extends Element = Element>(options?: UseIntersectionObserverOptions): UseIntersectionObserverReturn<T>;
+
+type SnackbarSeverity = 'success' | 'error' | 'warning' | 'info';
+interface SnackbarState {
+    open: boolean;
+    message: string;
+    severity: SnackbarSeverity;
+    autoHideDuration?: number;
+}
+interface UseSnackbarReturn {
+    /** Current snackbar state */
+    state: SnackbarState;
+    /** Show snackbar with message */
+    show: (message: string, severity?: SnackbarSeverity, duration?: number) => void;
+    /** Show success snackbar */
+    success: (message: string, duration?: number) => void;
+    /** Show error snackbar */
+    error: (message: string, duration?: number) => void;
+    /** Show warning snackbar */
+    warning: (message: string, duration?: number) => void;
+    /** Show info snackbar */
+    info: (message: string, duration?: number) => void;
+    /** Close snackbar */
+    close: () => void;
+}
+/**
+ * Manage snackbar/toast notification state
+ * @param defaultDuration - Default auto-hide duration in ms
+ */
+declare function useSnackbar(defaultDuration?: number): UseSnackbarReturn;
+
+/**
+ * Brand Identity Configuration
+ * Complete brand identity for all Exyconn projects including logos,
+ * colors, contact info, and social links
+ */
+/**
+ * Logo variants interface
+ * - light: Logo for light backgrounds (dark colored logo)
+ * - dark: Logo for dark backgrounds (light colored logo)
+ * - logoOnly: Just the icon/symbol without text (light bg)
+ * - darkLogoOnly: Just the icon/symbol without text (dark bg)
+ */
+interface LogoSet {
+    /** Full logo with text for light backgrounds */
+    light: string;
+    /** Full logo with text for dark backgrounds */
+    dark: string;
+    /** Icon only for light backgrounds */
+    logoOnly: string;
+    /** Icon only for dark backgrounds */
+    darkLogoOnly: string;
+    /** Favicon URL */
+    favicon: string;
+}
+/**
+ * Brand colors
+ */
+interface BrandColors {
+    primary: string;
+    secondary: string;
+    accent?: string;
+    background?: string;
+    foreground?: string;
+}
+/**
+ * Social media links
+ */
+interface SocialLinks {
+    twitter?: string;
+    facebook?: string;
+    instagram?: string;
+    linkedin?: string;
+    github?: string;
+    youtube?: string;
+    discord?: string;
+    tiktok?: string;
+}
+/**
+ * Contact information
+ */
+interface ContactInfo {
+    supportEmail: string;
+    salesEmail?: string;
+    phone?: string;
+    address?: string;
+}
+/**
+ * SEO Configuration
+ */
+interface SEOConfig {
+    title: string;
+    description: string;
+    keywords: string[];
+    ogImage?: string;
+}
+/**
+ * Complete Brand Identity
+ */
+interface BrandIdentity {
+    id: string;
+    name: string;
+    tagline: string;
+    domain: string;
+    logo: LogoSet;
+    colors: BrandColors;
+    contact: ContactInfo;
+    social?: SocialLinks;
+    seo?: SEOConfig;
+}
+/**
+ * App configuration for runtime
+ * Use this in your apps for consistent branding
+ */
+interface AppConfig {
+    name: string;
+    tagline: string;
+    domain: string;
+    supportEmail: string;
+    logo: LogoSet;
+    colors: BrandColors;
+}
+declare const BRANDS: Record<string, BrandIdentity>;
+/**
+ * Pre-configured APP objects for each project
+ * Import directly: import { APP } from '@exyconn/common'
+ * Then configure which APP to use based on environment
+ */
+declare const APPS: {
+    readonly BOTIFY: AppConfig;
+    readonly EXYCONN: AppConfig;
+    readonly PARTYWINGS: AppConfig;
+    readonly SIBERA: AppConfig;
+    readonly SPENTIVA: AppConfig;
+};
+/**
+ * Create an AppConfig from a brand
+ */
+declare function createAppConfig(brandId: string): AppConfig;
+/**
+ * Get brand by ID
+ */
+declare function getBrandById(id: string): BrandIdentity | undefined;
+/**
+ * Get brand by domain
+ */
+declare function getBrandByDomain(domain: string): BrandIdentity | undefined;
+/**
+ * Get all brands
+ */
+declare function getAllBrands(): BrandIdentity[];
+/**
+ * Get all brand IDs
+ */
+declare function getAllBrandIds(): string[];
+/**
+ * Get logo for a brand
+ * @param brandId - Brand identifier
+ * @param variant - 'light' | 'dark' | 'logoOnly' | 'darkLogoOnly'
+ */
+declare function getLogo(brandId: string, variant: keyof LogoSet): string | undefined;
+/**
+ * Get appropriate logo based on theme
+ * @param brandId - Brand identifier
+ * @param theme - 'light' | 'dark'
+ * @param iconOnly - Whether to return icon only logo
+ */
+declare function getThemedLogo(brandId: string, theme: 'light' | 'dark', iconOnly?: boolean): string | undefined;
+/**
+ * Get current app config based on domain
+ * Useful for multi-tenant applications
+ */
+declare function getAppConfigByDomain(domain: string): AppConfig | undefined;
+/**
+ * Detect brand from current window.location.hostname
+ * For browser environments only
+ */
+declare function detectCurrentBrand(): BrandIdentity | undefined;
+
+/**
+ * Theme System Types
+ * Deep-level theming with micro-level customization
+ * Supports light/dark themes with fallback options
+ */
+
+interface ColorPalette {
+    50: string;
+    100: string;
+    200: string;
+    300: string;
+    400: string;
+    500: string;
+    600: string;
+    700: string;
+    800: string;
+    900: string;
+    950: string;
+}
+interface SemanticColors {
+    primary: string;
+    primaryHover: string;
+    primaryActive: string;
+    primaryDisabled: string;
+    secondary: string;
+    secondaryHover: string;
+    secondaryActive: string;
+    secondaryDisabled: string;
+    accent: string;
+    accentHover: string;
+    success: string;
+    successHover: string;
+    warning: string;
+    warningHover: string;
+    error: string;
+    errorHover: string;
+    info: string;
+    infoHover: string;
+}
+interface BackgroundColors {
+    /** Main page background */
+    default: string;
+    /** Alternate background for sections */
+    paper: string;
+    /** Card backgrounds */
+    card: string;
+    /** Modal/overlay backgrounds */
+    overlay: string;
+    /** Input field backgrounds */
+    input: string;
+    /** Disabled element backgrounds */
+    disabled: string;
+    /** Hover state background */
+    hover: string;
+    /** Selected state background */
+    selected: string;
+}
+interface SurfaceColors {
+    light: string;
+    main: string;
+    dark: string;
+}
+interface TextColors {
+    /** Primary text color */
+    primary: string;
+    /** Secondary/muted text */
+    secondary: string;
+    /** Disabled text */
+    disabled: string;
+    /** Placeholder text */
+    placeholder: string;
+    /** Link text */
+    link: string;
+    /** Link hover */
+    linkHover: string;
+    /** Inverted text (for dark backgrounds) */
+    inverse: string;
+    /** On primary color background */
+    onPrimary: string;
+    /** On secondary color background */
+    onSecondary: string;
+}
+interface BorderColors {
+    default: string;
+    light: string;
+    dark: string;
+    focus: string;
+    error: string;
+    success: string;
+    disabled: string;
+}
+interface Shadows {
+    none: string;
+    xs: string;
+    sm: string;
+    md: string;
+    lg: string;
+    xl: string;
+    '2xl': string;
+    inner: string;
+    /** Button specific shadows */
+    button: string;
+    buttonHover: string;
+    /** Card shadows */
+    card: string;
+    cardHover: string;
+    /** Modal/dropdown shadows */
+    modal: string;
+    dropdown: string;
+}
+interface FontFamily {
+    sans: string;
+    serif: string;
+    mono: string;
+    heading: string;
+    body: string;
+}
+interface FontSize {
+    xs: string;
+    sm: string;
+    base: string;
+    lg: string;
+    xl: string;
+    '2xl': string;
+    '3xl': string;
+    '4xl': string;
+    '5xl': string;
+    '6xl': string;
+}
+interface FontWeight {
+    light: number;
+    normal: number;
+    medium: number;
+    semibold: number;
+    bold: number;
+    extrabold: number;
+}
+interface LineHeight {
+    none: number;
+    tight: number;
+    snug: number;
+    normal: number;
+    relaxed: number;
+    loose: number;
+}
+interface Typography {
+    fontFamily: FontFamily;
+    fontSize: FontSize;
+    fontWeight: FontWeight;
+    lineHeight: LineHeight;
+}
+interface Spacing {
+    0: string;
+    px: string;
+    0.5: string;
+    1: string;
+    1.5: string;
+    2: string;
+    2.5: string;
+    3: string;
+    3.5: string;
+    4: string;
+    5: string;
+    6: string;
+    7: string;
+    8: string;
+    9: string;
+    10: string;
+    11: string;
+    12: string;
+    14: string;
+    16: string;
+    20: string;
+    24: string;
+    28: string;
+    32: string;
+    36: string;
+    40: string;
+    44: string;
+    48: string;
+    52: string;
+    56: string;
+    60: string;
+    64: string;
+    72: string;
+    80: string;
+    96: string;
+}
+interface BorderRadius {
+    none: string;
+    sm: string;
+    default: string;
+    md: string;
+    lg: string;
+    xl: string;
+    '2xl': string;
+    '3xl': string;
+    full: string;
+}
+interface Breakpoints {
+    xs: string;
+    sm: string;
+    md: string;
+    lg: string;
+    xl: string;
+    '2xl': string;
+}
+interface ZIndex {
+    hide: number;
+    auto: string;
+    base: number;
+    dropdown: number;
+    sticky: number;
+    fixed: number;
+    modalBackdrop: number;
+    modal: number;
+    popover: number;
+    tooltip: number;
+    toast: number;
+}
+interface Transitions {
+    none: string;
+    fast: string;
+    normal: string;
+    slow: string;
+    slower: string;
+    /** Specific transitions */
+    colors: string;
+    transform: string;
+    opacity: string;
+    shadow: string;
+    all: string;
+}
+interface ButtonTheme {
+    /** Background colors */
+    bg: string;
+    bgHover: string;
+    bgActive: string;
+    bgDisabled: string;
+    /** Text colors */
+    color: string;
+    colorHover: string;
+    colorDisabled: string;
+    /** Border */
+    border: string;
+    borderHover: string;
+    borderWidth: string;
+    borderRadius: string;
+    /** Shadow */
+    shadow: string;
+    shadowHover: string;
+    /** Sizes */
+    paddingX: string;
+    paddingY: string;
+    fontSize: string;
+    fontWeight: number;
+    /** Variants */
+    variants: {
+        primary: Partial<ButtonTheme>;
+        secondary: Partial<ButtonTheme>;
+        outline: Partial<ButtonTheme>;
+        ghost: Partial<ButtonTheme>;
+        link: Partial<ButtonTheme>;
+        danger: Partial<ButtonTheme>;
+        success: Partial<ButtonTheme>;
+    };
+    /** Sizes */
+    sizes: {
+        xs: Partial<ButtonTheme>;
+        sm: Partial<ButtonTheme>;
+        md: Partial<ButtonTheme>;
+        lg: Partial<ButtonTheme>;
+        xl: Partial<ButtonTheme>;
+    };
+}
+interface InputTheme {
+    bg: string;
+    bgFocus: string;
+    bgDisabled: string;
+    bgError: string;
+    color: string;
+    colorPlaceholder: string;
+    colorDisabled: string;
+    border: string;
+    borderFocus: string;
+    borderError: string;
+    borderWidth: string;
+    borderRadius: string;
+    shadow: string;
+    shadowFocus: string;
+    paddingX: string;
+    paddingY: string;
+    fontSize: string;
+    /** Label styles */
+    labelColor: string;
+    labelFontSize: string;
+    labelFontWeight: number;
+    /** Helper/Error text */
+    helperColor: string;
+    errorColor: string;
+    /** Sizes */
+    sizes: {
+        sm: Partial<InputTheme>;
+        md: Partial<InputTheme>;
+        lg: Partial<InputTheme>;
+    };
+}
+interface CardTheme {
+    bg: string;
+    bgHover: string;
+    border: string;
+    borderWidth: string;
+    borderRadius: string;
+    shadow: string;
+    shadowHover: string;
+    padding: string;
+    /** Header */
+    headerBg: string;
+    headerBorder: string;
+    headerPadding: string;
+    /** Footer */
+    footerBg: string;
+    footerBorder: string;
+    footerPadding: string;
+}
+interface HeaderTheme {
+    bg: string;
+    bgScrolled: string;
+    color: string;
+    border: string;
+    shadow: string;
+    shadowScrolled: string;
+    height: string;
+    paddingX: string;
+    /** Logo */
+    logoHeight: string;
+    /** Nav links */
+    navColor: string;
+    navColorHover: string;
+    navColorActive: string;
+    navFontSize: string;
+    navFontWeight: number;
+    /** Mobile menu */
+    mobileMenuBg: string;
+    mobileMenuShadow: string;
+}
+interface FooterTheme {
+    bg: string;
+    color: string;
+    colorMuted: string;
+    border: string;
+    padding: string;
+    /** Links */
+    linkColor: string;
+    linkColorHover: string;
+    /** Headings */
+    headingColor: string;
+    headingFontSize: string;
+    headingFontWeight: number;
+    /** Copyright */
+    copyrightBg: string;
+    copyrightColor: string;
+}
+interface BannerTheme {
+    bg: string;
+    color: string;
+    border: string;
+    borderRadius: string;
+    padding: string;
+    shadow: string;
+    /** Close button */
+    closeBg: string;
+    closeColor: string;
+    /** Variants */
+    variants: {
+        info: Partial<BannerTheme>;
+        success: Partial<BannerTheme>;
+        warning: Partial<BannerTheme>;
+        error: Partial<BannerTheme>;
+        promo: Partial<BannerTheme>;
+    };
+}
+interface LoaderTheme {
+    color: string;
+    colorSecondary: string;
+    size: string;
+    borderWidth: string;
+    /** Overlay */
+    overlayBg: string;
+    overlayOpacity: number;
+    /** Sizes */
+    sizes: {
+        xs: string;
+        sm: string;
+        md: string;
+        lg: string;
+        xl: string;
+    };
+}
+interface ModalTheme {
+    bg: string;
+    color: string;
+    border: string;
+    borderRadius: string;
+    shadow: string;
+    padding: string;
+    /** Overlay */
+    overlayBg: string;
+    overlayOpacity: number;
+    /** Header */
+    headerBg: string;
+    headerBorder: string;
+    headerPadding: string;
+    /** Footer */
+    footerBg: string;
+    footerBorder: string;
+    footerPadding: string;
+    /** Close button */
+    closeBg: string;
+    closeColor: string;
+    closeHoverBg: string;
+    /** Sizes */
+    sizes: {
+        sm: string;
+        md: string;
+        lg: string;
+        xl: string;
+        full: string;
+    };
+}
+interface ToastTheme {
+    bg: string;
+    color: string;
+    border: string;
+    borderRadius: string;
+    shadow: string;
+    padding: string;
+    /** Variants */
+    variants: {
+        success: Partial<ToastTheme>;
+        error: Partial<ToastTheme>;
+        warning: Partial<ToastTheme>;
+        info: Partial<ToastTheme>;
+    };
+}
+interface NewsletterTheme {
+    bg: string;
+    color: string;
+    border: string;
+    borderRadius: string;
+    padding: string;
+    /** Title */
+    titleColor: string;
+    titleFontSize: string;
+    /** Description */
+    descColor: string;
+    descFontSize: string;
+    /** Input override */
+    inputBg: string;
+    inputBorder: string;
+    /** Button override */
+    buttonBg: string;
+    buttonColor: string;
+}
+interface ComponentThemes {
+    button: ButtonTheme;
+    input: InputTheme;
+    card: CardTheme;
+    header: HeaderTheme;
+    footer: FooterTheme;
+    banner: BannerTheme;
+    loader: LoaderTheme;
+    modal: ModalTheme;
+    toast: ToastTheme;
+    newsletter: NewsletterTheme;
+}
+type ThemeMode = 'light' | 'dark' | 'system';
+interface Theme {
+    /** Theme identifier */
+    name: string;
+    /** Light or dark mode */
+    mode: ThemeMode;
+    /** Brand identity reference */
+    brand?: Partial<BrandIdentity>;
+    /** Color system */
+    colors: {
+        brand: BrandColors;
+        semantic: SemanticColors;
+        background: BackgroundColors;
+        surface: SurfaceColors;
+        text: TextColors;
+        border: BorderColors;
+    };
+    /** Shadow system */
+    shadows: Shadows;
+    /** Typography */
+    typography: Typography;
+    /** Spacing */
+    spacing: Spacing;
+    /** Border radius */
+    borderRadius: BorderRadius;
+    /** Breakpoints */
+    breakpoints: Breakpoints;
+    /** Z-index */
+    zIndex: ZIndex;
+    /** Transitions */
+    transitions: Transitions;
+    /** Component-specific themes */
+    components: ComponentThemes;
+}
+interface ThemeConfig {
+    /** Default theme mode */
+    defaultMode?: ThemeMode;
+    /** URL to load theme from */
+    themeUrl?: string;
+    /** Custom light theme overrides */
+    light?: DeepPartial<Theme>;
+    /** Custom dark theme overrides */
+    dark?: DeepPartial<Theme>;
+    /** Brand identity to apply */
+    brandIdentity?: BrandIdentity;
+    /** Enable system theme detection */
+    enableSystemTheme?: boolean;
+    /** Persist theme preference */
+    persistTheme?: boolean;
+    /** Storage key for persistence */
+    storageKey?: string;
+    /** CSS variable prefix */
+    cssVarPrefix?: string;
+}
+interface ThemeContextValue {
+    /** Current theme */
+    theme: Theme;
+    /** Current mode */
+    mode: ThemeMode;
+    /** Set theme mode */
+    setMode: (mode: ThemeMode) => void;
+    /** Toggle between light/dark */
+    toggleMode: () => void;
+    /** Update theme */
+    updateTheme: (updates: DeepPartial<Theme>) => void;
+    /** Reset to default theme */
+    resetTheme: () => void;
+    /** Check if dark mode */
+    isDark: boolean;
+    /** Check if light mode */
+    isLight: boolean;
+    /** Loading state (for URL themes) */
+    isLoading: boolean;
+    /** Error state */
+    error: string | null;
+}
+type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+
+/**
+ * Default Light Theme
+ * Complete theme definition with all micro-level customizations
+ */
+
+declare const defaultLightTheme: Theme;
+
+/**
+ * Default Dark Theme
+ * Complete dark theme with all micro-level customizations
+ */
+
+declare const defaultDarkTheme: Theme;
+
+/**
+ * Theme Utilities
+ * Functions for theme manipulation, loading, and CSS variable generation
+ */
+
+/**
+ * Deep merge two objects
+ */
+declare function deepMerge<T extends object>(target: T, source: DeepPartial<T>): T;
+/**
+ * Generate theme colors from brand identity
+ */
+declare function createThemeFromBrand(brand: BrandIdentity, baseTheme?: Theme): Theme;
+/**
+ * Adjust color brightness
+ * @param hex - Hex color
+ * @param percent - Positive to lighten, negative to darken
+ */
+declare function adjustColor(hex: string, percent: number): string;
+/**
+ * Convert hex to rgba
+ */
+declare function hexToRgba(hex: string, alpha?: number): string;
+/**
+ * Get contrasting text color (black or white)
+ */
+declare function getContrastColor(hex: string): string;
+/**
+ * Flatten nested object to CSS variables
+ */
+declare function flattenToCssVars(obj: Record<string, unknown>, prefix?: string): Record<string, string>;
+/**
+ * Generate CSS variables string from theme
+ */
+declare function generateCssVars(theme: Theme, prefix?: string): string;
+/**
+ * Inject CSS variables into document
+ */
+declare function injectCssVars(theme: Theme, prefix?: string): void;
+/**
+ * Remove CSS variables from document
+ */
+declare function removeCssVars(prefix?: string): void;
+/**
+ * Load theme from URL
+ */
+declare function loadThemeFromUrl(url: string): Promise<DeepPartial<Theme> | null>;
+/**
+ * Create theme with config
+ */
+declare function createTheme(config?: ThemeConfig): Promise<{
+    light: Theme;
+    dark: Theme;
+}>;
+/**
+ * Save theme mode to storage
+ */
+declare function saveThemeMode(mode: ThemeMode, storageKey?: string): void;
+/**
+ * Load theme mode from storage
+ */
+declare function loadThemeMode(storageKey?: string): ThemeMode | null;
+/**
+ * Get system preferred color scheme
+ */
+declare function getSystemColorScheme(): 'light' | 'dark';
+/**
+ * Resolve theme mode (handle 'system')
+ */
+declare function resolveThemeMode(mode: ThemeMode): 'light' | 'dark';
+
+/**
+ * ThemeProvider Component
+ * Global theme provider with light/dark mode support and brand identity integration
+ */
+
+declare const ThemeContext: React$1.Context<ThemeContextValue | null>;
+/**
+ * Hook to access theme context
+ */
+declare function useTheme(): ThemeContextValue;
+interface ThemeProviderProps {
+    children: React$1.ReactNode;
+    config?: ThemeConfig;
+    /** Initial theme (overrides config) */
+    initialTheme?: Theme;
+}
+declare function ThemeProvider({ children, config, initialTheme, }: ThemeProviderProps): React$1.ReactElement;
+/**
+ * Get CSS variable value from theme path
+ * @example cssVar('colors.brand.primary') => 'var(--ec-colors-brand-primary)'
+ */
+declare function cssVar(path: string, prefix?: string): string;
+/**
+ * Get theme value directly
+ */
+declare function useThemeValue<T>(selector: (theme: Theme) => T): T;
+interface ThemeToggleProps {
+    className?: string;
+    size?: number;
+    showLabel?: boolean;
+    lightLabel?: string;
+    darkLabel?: string;
+}
+declare function ThemeToggle({ className, size, showLabel, lightLabel, darkLabel, }: ThemeToggleProps): React$1.ReactElement;
+
+/**
+ * Astro Component Types
+ * Highly typed props for all Astro components with Tailwind class support
+ */
+/** Common Tailwind text colors */
+type TailwindTextColor = 'text-white' | 'text-black' | 'text-gray-50' | 'text-gray-100' | 'text-gray-200' | 'text-gray-300' | 'text-gray-400' | 'text-gray-500' | 'text-gray-600' | 'text-gray-700' | 'text-gray-800' | 'text-gray-900' | 'text-slate-50' | 'text-slate-100' | 'text-slate-200' | 'text-slate-300' | 'text-slate-400' | 'text-slate-500' | 'text-slate-600' | 'text-slate-700' | 'text-slate-800' | 'text-slate-900' | 'text-blue-500' | 'text-blue-600' | 'text-blue-700' | 'text-green-500' | 'text-green-600' | 'text-green-700' | 'text-red-500' | 'text-red-600' | 'text-red-700' | 'text-yellow-500' | 'text-yellow-600' | 'text-yellow-700' | 'text-purple-500' | 'text-purple-600' | 'text-purple-700' | 'text-pink-500' | 'text-pink-600' | 'text-pink-700' | 'text-indigo-500' | 'text-indigo-600' | 'text-indigo-700' | string;
+/** Common Tailwind background colors */
+type TailwindBgColor = 'bg-white' | 'bg-black' | 'bg-transparent' | 'bg-gray-50' | 'bg-gray-100' | 'bg-gray-200' | 'bg-gray-300' | 'bg-gray-400' | 'bg-gray-500' | 'bg-gray-600' | 'bg-gray-700' | 'bg-gray-800' | 'bg-gray-900' | 'bg-slate-50' | 'bg-slate-100' | 'bg-slate-200' | 'bg-slate-300' | 'bg-slate-400' | 'bg-slate-500' | 'bg-slate-600' | 'bg-slate-700' | 'bg-slate-800' | 'bg-slate-900' | 'bg-blue-500' | 'bg-blue-600' | 'bg-blue-700' | 'bg-green-500' | 'bg-green-600' | 'bg-green-700' | 'bg-red-500' | 'bg-red-600' | 'bg-red-700' | 'bg-yellow-500' | 'bg-yellow-600' | 'bg-yellow-700' | 'bg-purple-500' | 'bg-purple-600' | 'bg-purple-700' | 'bg-gradient-to-r' | 'bg-gradient-to-l' | 'bg-gradient-to-t' | 'bg-gradient-to-b' | 'bg-gradient-to-br' | 'bg-gradient-to-bl' | 'bg-gradient-to-tr' | 'bg-gradient-to-tl' | string;
+/** Common Tailwind padding */
+type TailwindPadding = 'p-0' | 'p-1' | 'p-2' | 'p-3' | 'p-4' | 'p-5' | 'p-6' | 'p-8' | 'p-10' | 'p-12' | 'p-16' | 'p-20' | 'p-24' | 'px-0' | 'px-1' | 'px-2' | 'px-3' | 'px-4' | 'px-5' | 'px-6' | 'px-8' | 'px-10' | 'px-12' | 'px-16' | 'py-0' | 'py-1' | 'py-2' | 'py-3' | 'py-4' | 'py-5' | 'py-6' | 'py-8' | 'py-10' | 'py-12' | 'py-16' | 'py-20' | 'py-24' | 'pt-0' | 'pt-4' | 'pt-8' | 'pt-12' | 'pt-16' | 'pt-20' | 'pt-24' | 'pb-0' | 'pb-4' | 'pb-8' | 'pb-12' | 'pb-16' | 'pb-20' | 'pb-24' | string;
+/** Common Tailwind margin */
+type TailwindMargin = 'm-0' | 'm-1' | 'm-2' | 'm-3' | 'm-4' | 'm-5' | 'm-6' | 'm-8' | 'm-auto' | 'mx-auto' | 'mx-0' | 'mx-4' | 'mx-6' | 'mx-8' | 'my-0' | 'my-4' | 'my-6' | 'my-8' | 'my-10' | 'my-12' | 'my-16' | 'mt-0' | 'mt-2' | 'mt-4' | 'mt-6' | 'mt-8' | 'mt-10' | 'mt-12' | 'mt-16' | 'mb-0' | 'mb-2' | 'mb-4' | 'mb-6' | 'mb-8' | 'mb-10' | 'mb-12' | 'mb-16' | 'ml-auto' | 'mr-auto' | string;
+/** Common Tailwind font sizes */
+type TailwindFontSize = 'text-xs' | 'text-sm' | 'text-base' | 'text-lg' | 'text-xl' | 'text-2xl' | 'text-3xl' | 'text-4xl' | 'text-5xl' | 'text-6xl' | 'text-7xl' | 'text-8xl' | 'text-9xl' | string;
+/** Common Tailwind font weights */
+type TailwindFontWeight = 'font-thin' | 'font-extralight' | 'font-light' | 'font-normal' | 'font-medium' | 'font-semibold' | 'font-bold' | 'font-extrabold' | 'font-black' | string;
+/** Common Tailwind border radius */
+type TailwindBorderRadius = 'rounded-none' | 'rounded-sm' | 'rounded' | 'rounded-md' | 'rounded-lg' | 'rounded-xl' | 'rounded-2xl' | 'rounded-3xl' | 'rounded-full' | string;
+/** Common Tailwind shadow */
+type TailwindShadow = 'shadow-none' | 'shadow-sm' | 'shadow' | 'shadow-md' | 'shadow-lg' | 'shadow-xl' | 'shadow-2xl' | 'shadow-inner' | string;
+/** Common Tailwind width */
+type TailwindWidth = 'w-full' | 'w-screen' | 'w-auto' | 'w-fit' | 'w-max' | 'w-min' | 'w-1/2' | 'w-1/3' | 'w-2/3' | 'w-1/4' | 'w-3/4' | 'w-1/5' | 'w-2/5' | 'w-3/5' | 'w-4/5' | 'w-8' | 'w-10' | 'w-12' | 'w-16' | 'w-20' | 'w-24' | 'w-32' | 'w-40' | 'w-48' | 'w-56' | 'w-64' | 'max-w-sm' | 'max-w-md' | 'max-w-lg' | 'max-w-xl' | 'max-w-2xl' | 'max-w-3xl' | 'max-w-4xl' | 'max-w-5xl' | 'max-w-6xl' | 'max-w-7xl' | 'max-w-full' | string;
+/** Common Tailwind height */
+type TailwindHeight = 'h-full' | 'h-screen' | 'h-auto' | 'h-fit' | 'h-max' | 'h-min' | 'h-8' | 'h-10' | 'h-12' | 'h-16' | 'h-20' | 'h-24' | 'h-32' | 'h-40' | 'h-48' | 'h-56' | 'h-64' | 'min-h-screen' | 'min-h-full' | string;
+/** Common Tailwind gap */
+type TailwindGap = 'gap-0' | 'gap-1' | 'gap-2' | 'gap-3' | 'gap-4' | 'gap-5' | 'gap-6' | 'gap-8' | 'gap-10' | 'gap-12' | 'gap-x-0' | 'gap-x-2' | 'gap-x-4' | 'gap-x-6' | 'gap-x-8' | 'gap-y-0' | 'gap-y-2' | 'gap-y-4' | 'gap-y-6' | 'gap-y-8' | string;
+/** Custom class string */
+type TailwindClasses$1 = string;
+type ButtonVariant = 'primary' | 'secondary' | 'outline' | 'ghost' | 'link' | 'danger' | 'success';
+type ButtonSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+interface ButtonProps {
+    /** Button text content */
+    text: string;
+    /** Button variant */
+    variant?: ButtonVariant;
+    /** Button size */
+    size?: ButtonSize;
+    /** Full width button */
+    fullWidth?: boolean;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Button type */
+    type?: 'button' | 'submit' | 'reset';
+    /** Link href (renders as anchor) */
+    href?: string;
+    /** Open in new tab */
+    target?: '_blank' | '_self' | '_parent' | '_top';
+    /** Left icon (SVG string or component) */
+    leftIcon?: string;
+    /** Right icon (SVG string or component) */
+    rightIcon?: string;
+    /** Additional class override */
+    class?: TailwindClasses$1;
+    /** Container class */
+    containerClass?: TailwindClasses$1;
+    /** ID attribute */
+    id?: string;
+    /** Aria label */
+    ariaLabel?: string;
+}
+type LoaderVariant = 'spinner' | 'dots' | 'pulse' | 'bars';
+type LoaderSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+interface LoaderProps {
+    /** Loader variant */
+    variant?: LoaderVariant;
+    /** Loader size */
+    size?: LoaderSize;
+    /** Custom color */
+    color?: TailwindTextColor;
+    /** Label text */
+    label?: string;
+    /** Show label */
+    showLabel?: boolean;
+    /** Additional classes */
+    class?: TailwindClasses$1;
+}
+interface ContainerProps {
+    /** Max width */
+    maxWidth?: 'sm' | 'md' | 'lg' | 'xl' | '2xl' | '3xl' | '4xl' | '5xl' | '6xl' | '7xl' | 'full';
+    /** Padding */
+    padding?: TailwindPadding;
+    /** Center content */
+    centered?: boolean;
+    /** Additional classes */
+    class?: TailwindClasses$1;
+}
+interface RowProps {
+    /** Gap between columns */
+    gap?: TailwindGap;
+    /** Vertical alignment */
+    alignItems?: 'start' | 'center' | 'end' | 'stretch' | 'baseline';
+    /** Horizontal alignment */
+    justifyContent?: 'start' | 'center' | 'end' | 'between' | 'around' | 'evenly';
+    /** Wrap behavior */
+    wrap?: boolean;
+    /** Reverse order */
+    reverse?: boolean;
+    /** Additional classes */
+    class?: TailwindClasses$1;
+}
+interface ColProps {
+    /** Column span (1-12) */
+    span?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 'auto' | 'full';
+    /** Span on sm screens */
+    sm?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 'auto' | 'full';
+    /** Span on md screens */
+    md?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 'auto' | 'full';
+    /** Span on lg screens */
+    lg?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 'auto' | 'full';
+    /** Span on xl screens */
+    xl?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 'auto' | 'full';
+    /** Additional classes */
+    class?: TailwindClasses$1;
+}
+interface TwoColumnProps {
+    /** Left column content ratio */
+    leftRatio?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11;
+    /** Gap between columns */
+    gap?: TailwindGap;
+    /** Reverse on mobile */
+    reverseMobile?: boolean;
+    /** Vertical alignment */
+    alignItems?: 'start' | 'center' | 'end' | 'stretch';
+    /** Additional classes */
+    class?: TailwindClasses$1;
+    /** Left column class */
+    leftClass?: TailwindClasses$1;
+    /** Right column class */
+    rightClass?: TailwindClasses$1;
+}
+interface ThreeColumnProps {
+    /** Gap between columns */
+    gap?: TailwindGap;
+    /** Vertical alignment */
+    alignItems?: 'start' | 'center' | 'end' | 'stretch';
+    /** Additional classes */
+    class?: TailwindClasses$1;
+    /** Column 1 class */
+    col1Class?: TailwindClasses$1;
+    /** Column 2 class */
+    col2Class?: TailwindClasses$1;
+    /** Column 3 class */
+    col3Class?: TailwindClasses$1;
+}
+interface NavLink {
+    /** Link text */
+    text: string;
+    /** Link URL */
+    href: string;
+    /** Active state */
+    active?: boolean;
+    /** Open in new tab */
+    external?: boolean;
+    /** Dropdown items */
+    children?: NavLink[];
+    /** Icon SVG string */
+    icon?: string;
+}
+interface HeaderProps {
+    /** Logo image URL */
+    logo?: string;
+    /** Logo alt text */
+    logoAlt?: string;
+    /** Logo text (if no image) */
+    logoText?: string;
+    /** Navigation links */
+    navLinks?: NavLink[];
+    /** CTA button */
+    cta?: {
+        text: string;
+        href: string;
+        variant?: ButtonVariant;
+    };
+    /** Sticky header */
+    sticky?: boolean;
+    /** Transparent background */
+    transparent?: boolean;
+    /** Background class */
+    bgClass?: TailwindBgColor;
+    /** Text color class */
+    textClass?: TailwindTextColor;
+    /** Additional classes */
+    class?: TailwindClasses$1;
+    /** Logo class */
+    logoClass?: TailwindClasses$1;
+    /** Nav class */
+    navClass?: TailwindClasses$1;
+    /** Container max width */
+    maxWidth?: ContainerProps['maxWidth'];
+}
+interface FooterColumn {
+    /** Column title */
+    title: string;
+    /** Column links */
+    links: NavLink[];
+}
+interface SocialLink {
+    /** Platform name */
+    platform: 'facebook' | 'twitter' | 'instagram' | 'linkedin' | 'youtube' | 'github' | 'discord' | 'tiktok';
+    /** Profile URL */
+    href: string;
+    /** Icon SVG (optional, defaults based on platform) */
+    icon?: string;
+}
+interface FooterProps {
+    /** Logo image URL */
+    logo?: string;
+    /** Logo alt text */
+    logoAlt?: string;
+    /** Logo text */
+    logoText?: string;
+    /** Company description */
+    description?: string;
+    /** Footer columns */
+    columns?: FooterColumn[];
+    /** Social links */
+    socialLinks?: SocialLink[];
+    /** Copyright text */
+    copyright?: string;
+    /** Background class */
+    bgClass?: TailwindBgColor;
+    /** Text color class */
+    textClass?: TailwindTextColor;
+    /** Additional classes */
+    class?: TailwindClasses$1;
+    /** Container max width */
+    maxWidth?: ContainerProps['maxWidth'];
+    /** Show newsletter signup */
+    showNewsletter?: boolean;
+    /** Newsletter title */
+    newsletterTitle?: string;
+    /** Newsletter description */
+    newsletterDescription?: string;
+}
+interface BannerProps {
+    /** Main heading */
+    title: string;
+    /** Subtitle/description */
+    subtitle?: string;
+    /** Background image URL */
+    backgroundImage?: string;
+    /** Background gradient/color */
+    bgClass?: TailwindBgColor;
+    /** Text color */
+    textClass?: TailwindTextColor;
+    /** Overlay opacity (0-100) */
+    overlayOpacity?: number;
+    /** Overlay color class */
+    overlayClass?: string;
+    /** Primary CTA */
+    primaryCta?: {
+        text: string;
+        href: string;
+        variant?: ButtonVariant;
+    };
+    /** Secondary CTA */
+    secondaryCta?: {
+        text: string;
+        href: string;
+        variant?: ButtonVariant;
+    };
+    /** Banner height */
+    height?: 'sm' | 'md' | 'lg' | 'xl' | 'screen';
+    /** Content alignment */
+    align?: 'left' | 'center' | 'right';
+    /** Additional classes */
+    class?: TailwindClasses$1;
+    /** Title class */
+    titleClass?: TailwindClasses$1;
+    /** Subtitle class */
+    subtitleClass?: TailwindClasses$1;
+    /** Content container class */
+    contentClass?: TailwindClasses$1;
+}
+interface CtaSectionProps {
+    /** Main heading */
+    title: string;
+    /** Description text */
+    description?: string;
+    /** Primary button */
+    primaryButton?: {
+        text: string;
+        href: string;
+        variant?: ButtonVariant;
+    };
+    /** Secondary button */
+    secondaryButton?: {
+        text: string;
+        href: string;
+        variant?: ButtonVariant;
+    };
+    /** Background class */
+    bgClass?: TailwindBgColor;
+    /** Text color */
+    textClass?: TailwindTextColor;
+    /** Content alignment */
+    align?: 'left' | 'center' | 'right';
+    /** Additional classes */
+    class?: TailwindClasses$1;
+    /** Padding */
+    padding?: TailwindPadding;
+}
+interface NewsletterSectionProps {
+    /** Main heading */
+    title?: string;
+    /** Description text */
+    description?: string;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Submit button text */
+    buttonText?: string;
+    /** Success message */
+    successMessage?: string;
+    /** Error message */
+    errorMessage?: string;
+    /** Form action URL */
+    actionUrl?: string;
+    /** Background class */
+    bgClass?: TailwindBgColor;
+    /** Text color */
+    textClass?: TailwindTextColor;
+    /** Additional classes */
+    class?: TailwindClasses$1;
+    /** Input class */
+    inputClass?: TailwindClasses$1;
+    /** Button class */
+    buttonClass?: TailwindClasses$1;
+    /** Show privacy note */
+    showPrivacyNote?: boolean;
+    /** Privacy note text */
+    privacyNote?: string;
+}
+interface CardProps {
+    /** Card title */
+    title?: string;
+    /** Card description */
+    description?: string;
+    /** Card image URL */
+    image?: string;
+    /** Image alt text */
+    imageAlt?: string;
+    /** Image position */
+    imagePosition?: 'top' | 'bottom' | 'left' | 'right';
+    /** Card link */
+    href?: string;
+    /** Background class */
+    bgClass?: TailwindBgColor;
+    /** Text color */
+    textClass?: TailwindTextColor;
+    /** Border radius */
+    rounded?: TailwindBorderRadius;
+    /** Shadow */
+    shadow?: TailwindShadow;
+    /** Hover effect */
+    hoverEffect?: boolean;
+    /** Additional classes */
+    class?: TailwindClasses$1;
+    /** Image class */
+    imageClass?: TailwindClasses$1;
+    /** Content class */
+    contentClass?: TailwindClasses$1;
+    /** Title class */
+    titleClass?: TailwindClasses$1;
+    /** Description class */
+    descriptionClass?: TailwindClasses$1;
+    /** Padding */
+    padding?: TailwindPadding;
+}
+interface Feature {
+    /** Feature title */
+    title: string;
+    /** Feature description */
+    description: string;
+    /** Feature icon (SVG string) */
+    icon?: string;
+    /** Feature image */
+    image?: string;
+    /** Feature link */
+    href?: string;
+}
+interface FeatureSectionProps {
+    /** Section title */
+    title?: string;
+    /** Section subtitle */
+    subtitle?: string;
+    /** Features array */
+    features: Feature[];
+    /** Layout columns */
+    columns?: 2 | 3 | 4;
+    /** Background class */
+    bgClass?: TailwindBgColor;
+    /** Text color */
+    textClass?: TailwindTextColor;
+    /** Additional classes */
+    class?: TailwindClasses$1;
+    /** Feature card class */
+    featureClass?: TailwindClasses$1;
+    /** Icon class */
+    iconClass?: TailwindClasses$1;
+}
+interface Testimonial {
+    /** Author name */
+    name: string;
+    /** Author role/title */
+    role?: string;
+    /** Author company */
+    company?: string;
+    /** Author avatar URL */
+    avatar?: string;
+    /** Testimonial text */
+    text: string;
+    /** Rating (1-5) */
+    rating?: 1 | 2 | 3 | 4 | 5;
+}
+interface TestimonialSectionProps {
+    /** Section title */
+    title?: string;
+    /** Section subtitle */
+    subtitle?: string;
+    /** Testimonials array */
+    testimonials: Testimonial[];
+    /** Layout style */
+    layout?: 'grid' | 'carousel' | 'single';
+    /** Background class */
+    bgClass?: TailwindBgColor;
+    /** Text color */
+    textClass?: TailwindTextColor;
+    /** Additional classes */
+    class?: TailwindClasses$1;
+    /** Testimonial card class */
+    cardClass?: TailwindClasses$1;
+}
+interface PricingFeature {
+    /** Feature text */
+    text: string;
+    /** Included or not */
+    included: boolean;
+}
+interface PricingPlan {
+    /** Plan name */
+    name: string;
+    /** Plan description */
+    description?: string;
+    /** Price */
+    price: string;
+    /** Price period */
+    period?: string;
+    /** Features list */
+    features: PricingFeature[];
+    /** CTA button text */
+    ctaText: string;
+    /** CTA button href */
+    ctaHref: string;
+    /** Highlighted/popular plan */
+    popular?: boolean;
+    /** Badge text */
+    badge?: string;
+}
+interface PricingSectionProps {
+    /** Section title */
+    title?: string;
+    /** Section subtitle */
+    subtitle?: string;
+    /** Pricing plans */
+    plans: PricingPlan[];
+    /** Background class */
+    bgClass?: TailwindBgColor;
+    /** Text color */
+    textClass?: TailwindTextColor;
+    /** Additional classes */
+    class?: TailwindClasses$1;
+    /** Plan card class */
+    planClass?: TailwindClasses$1;
+}
+interface FaqItem {
+    /** Question */
+    question: string;
+    /** Answer */
+    answer: string;
+}
+interface FaqSectionProps {
+    /** Section title */
+    title?: string;
+    /** Section subtitle */
+    subtitle?: string;
+    /** FAQ items */
+    items: FaqItem[];
+    /** Layout style */
+    layout?: 'accordion' | 'grid' | 'list';
+    /** Background class */
+    bgClass?: TailwindBgColor;
+    /** Text color */
+    textClass?: TailwindTextColor;
+    /** Additional classes */
+    class?: TailwindClasses$1;
+}
+/** Generate dummy image URL */
+declare function dummyImage(width: number, height: number, text?: string, bgColor?: string, textColor?: string): string;
+/** Lorem ipsum generator */
+declare function loremIpsum(type?: 'word' | 'sentence' | 'paragraph', count?: number): string;
+declare const dummyHeaderData: HeaderProps;
+declare const dummyFooterData: FooterProps;
+declare const dummyBannerData: BannerProps;
+declare const dummyFeatures: Feature[];
+declare const dummyTestimonials: Testimonial[];
+declare const dummyPricingPlans: PricingPlan[];
+declare const dummyFaqItems: FaqItem[];
+
+/**
+ * Form Types
+ * Types for all form components
+ */
+type TailwindClasses = string;
+interface FormFieldError {
+    field: string;
+    message: string;
+}
+interface FormSubmitResult {
+    success: boolean;
+    message?: string;
+    errors?: FormFieldError[];
+    data?: Record<string, unknown>;
+}
+interface ContactFormValues {
+    name: string;
+    email: string;
+    phone?: string;
+    subject?: string;
+    message: string;
+}
+interface ContactFormProps {
+    /** Form action URL */
+    actionUrl?: string;
+    /** Submit handler */
+    onSubmit?: (values: ContactFormValues) => Promise<FormSubmitResult>;
+    /** Initial values */
+    initialValues?: Partial<ContactFormValues>;
+    /** Show phone field */
+    showPhone?: boolean;
+    /** Show subject field */
+    showSubject?: boolean;
+    /** Subject options (if select) */
+    subjectOptions?: string[];
+    /** Submit button text */
+    submitText?: string;
+    /** Success message */
+    successMessage?: string;
+    /** Container class */
+    className?: TailwindClasses;
+    /** Form class */
+    formClass?: TailwindClasses;
+    /** Input class */
+    inputClass?: TailwindClasses;
+    /** Label class */
+    labelClass?: TailwindClasses;
+    /** Button class */
+    buttonClass?: TailwindClasses;
+    /** Error class */
+    errorClass?: TailwindClasses;
+}
+interface NewsletterFormValues {
+    email: string;
+    firstName?: string;
+    lastName?: string;
+}
+interface NewsletterFormProps {
+    /** Form action URL */
+    actionUrl?: string;
+    /** Submit handler */
+    onSubmit?: (values: NewsletterFormValues) => Promise<FormSubmitResult>;
+    /** Initial values */
+    initialValues?: Partial<NewsletterFormValues>;
+    /** Show name fields */
+    showName?: boolean;
+    /** Placeholder */
+    placeholder?: string;
+    /** Submit button text */
+    submitText?: string;
+    /** Success message */
+    successMessage?: string;
+    /** Layout */
+    layout?: 'inline' | 'stacked';
+    /** Container class */
+    className?: TailwindClasses;
+    /** Form class */
+    formClass?: TailwindClasses;
+    /** Input class */
+    inputClass?: TailwindClasses;
+    /** Button class */
+    buttonClass?: TailwindClasses;
+}
+interface LoginFormValues {
+    email: string;
+    password: string;
+    rememberMe?: boolean;
+}
+interface LoginFormProps {
+    /** Form action URL */
+    actionUrl?: string;
+    /** Submit handler */
+    onSubmit?: (values: LoginFormValues) => Promise<FormSubmitResult>;
+    /** Initial values */
+    initialValues?: Partial<LoginFormValues>;
+    /** Show remember me */
+    showRememberMe?: boolean;
+    /** Forgot password link */
+    forgotPasswordLink?: string;
+    /** Register link */
+    registerLink?: string;
+    /** Submit button text */
+    submitText?: string;
+    /** Success redirect URL */
+    successRedirect?: string;
+    /** Container class */
+    className?: TailwindClasses;
+    /** Form class */
+    formClass?: TailwindClasses;
+    /** Input class */
+    inputClass?: TailwindClasses;
+    /** Button class */
+    buttonClass?: TailwindClasses;
+}
+interface RegisterFormValues {
+    firstName: string;
+    lastName: string;
+    email: string;
+    password: string;
+    confirmPassword: string;
+    acceptTerms: boolean;
+}
+interface RegisterFormProps {
+    /** Form action URL */
+    actionUrl?: string;
+    /** Submit handler */
+    onSubmit?: (values: RegisterFormValues) => Promise<FormSubmitResult>;
+    /** Initial values */
+    initialValues?: Partial<RegisterFormValues>;
+    /** Terms link */
+    termsLink?: string;
+    /** Privacy link */
+    privacyLink?: string;
+    /** Login link */
+    loginLink?: string;
+    /** Submit button text */
+    submitText?: string;
+    /** Success redirect URL */
+    successRedirect?: string;
+    /** Password requirements */
+    passwordRequirements?: {
+        minLength?: number;
+        requireUppercase?: boolean;
+        requireLowercase?: boolean;
+        requireNumber?: boolean;
+        requireSpecial?: boolean;
+    };
+    /** Container class */
+    className?: TailwindClasses;
+    /** Form class */
+    formClass?: TailwindClasses;
+    /** Input class */
+    inputClass?: TailwindClasses;
+    /** Button class */
+    buttonClass?: TailwindClasses;
+}
+declare const VALIDATION_MESSAGES: {
+    readonly required: "This field is required";
+    readonly email: "Please enter a valid email address";
+    readonly phone: "Please enter a valid phone number";
+    readonly minLength: (min: number) => string;
+    readonly maxLength: (max: number) => string;
+    readonly passwordMatch: "Passwords must match";
+    readonly acceptTerms: "You must accept the terms and conditions";
+    readonly passwordUppercase: "Password must contain at least one uppercase letter";
+    readonly passwordLowercase: "Password must contain at least one lowercase letter";
+    readonly passwordNumber: "Password must contain at least one number";
+    readonly passwordSpecial: "Password must contain at least one special character";
+};
+
+/**
+ * Form Validation Schemas
+ * Yup validation schemas for all forms
+ */
+
+declare const contactFormSchema: Yup.ObjectSchema<{
+    name: string;
+    email: string;
+    phone: string | null | undefined;
+    subject: string | null | undefined;
+    message: string;
+}, Yup.AnyObject, {
+    name: undefined;
+    email: undefined;
+    phone: undefined;
+    subject: undefined;
+    message: undefined;
+}, "">;
+declare const newsletterFormSchema: Yup.ObjectSchema<{
+    email: string;
+    firstName: string | null | undefined;
+    lastName: string | null | undefined;
+}, Yup.AnyObject, {
+    email: undefined;
+    firstName: undefined;
+    lastName: undefined;
+}, "">;
+declare const loginFormSchema: Yup.ObjectSchema<{
+    email: string;
+    password: string;
+    rememberMe: boolean | undefined;
+}, Yup.AnyObject, {
+    email: undefined;
+    password: undefined;
+    rememberMe: undefined;
+}, "">;
+interface PasswordRequirements {
+    minLength?: number;
+    requireUppercase?: boolean;
+    requireLowercase?: boolean;
+    requireNumber?: boolean;
+    requireSpecial?: boolean;
+}
+declare function createRegisterFormSchema(requirements?: PasswordRequirements): Yup.ObjectSchema<{
+    firstName: string;
+    lastName: string;
+    email: string;
+    password: string;
+    confirmPassword: string;
+    acceptTerms: boolean | undefined;
+}, Yup.AnyObject, {
+    firstName: undefined;
+    lastName: undefined;
+    email: undefined;
+    password: undefined;
+    confirmPassword: undefined;
+    acceptTerms: undefined;
+}, "">;
+declare const registerFormSchema: Yup.ObjectSchema<{
+    firstName: string;
+    lastName: string;
+    email: string;
+    password: string;
+    confirmPassword: string;
+    acceptTerms: boolean | undefined;
+}, Yup.AnyObject, {
+    firstName: undefined;
+    lastName: undefined;
+    email: undefined;
+    password: undefined;
+    confirmPassword: undefined;
+    acceptTerms: undefined;
+}, "">;
+
+/**
+ * Contact Form Component
+ * React form with Formik and Yup validation
+ */
+
+declare function ContactForm({ actionUrl, onSubmit, initialValues, showPhone, showSubject, subjectOptions, submitText, successMessage, className, formClass, inputClass, labelClass, buttonClass, errorClass, }: ContactFormProps): React$1.ReactElement;
+
+/**
+ * Newsletter Form Component
+ * React form with Formik and Yup validation
+ */
+
+declare function NewsletterForm({ actionUrl, onSubmit, initialValues, showName, placeholder, submitText, successMessage, layout, className, formClass, inputClass, buttonClass, }: NewsletterFormProps): React$1.ReactElement;
+
+/**
+ * Login Form Component
+ * React form with Formik and Yup validation
+ */
+
+declare function LoginForm({ actionUrl, onSubmit, initialValues, showRememberMe, forgotPasswordLink, registerLink, submitText, successRedirect, className, formClass, inputClass, buttonClass, }: LoginFormProps): React$1.ReactElement;
+
+/**
+ * Register Form Component
+ * React form with Formik and Yup validation
+ */
+
+declare function RegisterForm({ actionUrl, onSubmit, initialValues, termsLink, privacyLink, loginLink, submitText, successRedirect, passwordRequirements, className, formClass, inputClass, buttonClass, }: RegisterFormProps): React$1.ReactElement;
+
+declare const index_ApiResponse: typeof ApiResponse;
+declare const index_ApiUrlBuilder: typeof ApiUrlBuilder;
+declare const index_ApiUrlConfig: typeof ApiUrlConfig;
+type index_BannerProps = BannerProps;
+type index_BatteryState = BatteryState;
+type index_BorderRadius = BorderRadius;
+type index_Breakpoints = Breakpoints;
+type index_ButtonProps = ButtonProps;
+type index_ButtonSize = ButtonSize;
+type index_ButtonVariant = ButtonVariant;
+type index_CardProps = CardProps;
+declare const index_ClientLogger: typeof ClientLogger;
+declare const index_ClientLoggerConfig: typeof ClientLoggerConfig;
+type index_ColProps = ColProps;
+type index_ColorPalette = ColorPalette;
+type index_ComponentThemes = ComponentThemes;
+declare const index_ContactForm: typeof ContactForm;
+type index_ContactFormProps = ContactFormProps;
+type index_ContactFormValues = ContactFormValues;
+type index_ContainerProps = ContainerProps;
+type index_CtaSectionProps = CtaSectionProps;
+type index_Dimensions = Dimensions;
+declare const index_EventEmitter: typeof EventEmitter;
+type index_FaqItem = FaqItem;
+type index_FaqSectionProps = FaqSectionProps;
+type index_Feature = Feature;
+type index_FeatureSectionProps = FeatureSectionProps;
+type index_FooterColumn = FooterColumn;
+type index_FooterProps = FooterProps;
+type index_FormFieldError = FormFieldError;
+type index_FormSubmitResult = FormSubmitResult;
+type index_GeolocationState = GeolocationState;
+type index_HeaderProps = HeaderProps;
+declare const index_HttpClientOptions: typeof HttpClientOptions;
+type index_LoaderProps = LoaderProps;
+type index_LoaderSize = LoaderSize;
+type index_LoaderVariant = LoaderVariant;
+declare const index_LogLevel: typeof LogLevel;
+declare const index_LoginForm: typeof LoginForm;
+type index_LoginFormProps = LoginFormProps;
+type index_LoginFormValues = LoginFormValues;
+type index_MousePosition = MousePosition;
+type index_NavLink = NavLink;
+type index_NetworkState = NetworkState;
+declare const index_NewsletterForm: typeof NewsletterForm;
+type index_NewsletterFormProps = NewsletterFormProps;
+type index_NewsletterFormValues = NewsletterFormValues;
+type index_NewsletterSectionProps = NewsletterSectionProps;
+declare const index_NpmRegistryResponse: typeof NpmRegistryResponse;
+type index_ObjectStateUpdate<T> = ObjectStateUpdate<T>;
+type index_OrientationState = OrientationState;
+declare const index_PackageCheckResult: typeof PackageCheckResult;
+declare const index_PackageJson: typeof PackageJson;
+declare const index_PackageVersion: typeof PackageVersion;
+declare const index_PaginatedResponse: typeof PaginatedResponse;
+type index_PasswordRequirements = PasswordRequirements;
+type index_PricingFeature = PricingFeature;
+type index_PricingPlan = PricingPlan;
+type index_PricingSectionProps = PricingSectionProps;
+declare const index_RegisterForm: typeof RegisterForm;
+type index_RegisterFormProps = RegisterFormProps;
+type index_RegisterFormValues = RegisterFormValues;
+type index_RenderInfo = RenderInfo;
+type index_RowProps = RowProps;
+type index_ScriptStatus = ScriptStatus;
+type index_SemanticColors = SemanticColors;
+type index_SetValue<T> = SetValue<T>;
+type index_Shadows = Shadows;
+type index_SnackbarSeverity = SnackbarSeverity;
+type index_SnackbarState = SnackbarState;
+type index_SocialLink = SocialLink;
+type index_Spacing = Spacing;
+type index_TailwindBgColor = TailwindBgColor;
+type index_TailwindBorderRadius = TailwindBorderRadius;
+type index_TailwindFontSize = TailwindFontSize;
+type index_TailwindFontWeight = TailwindFontWeight;
+type index_TailwindGap = TailwindGap;
+type index_TailwindHeight = TailwindHeight;
+type index_TailwindMargin = TailwindMargin;
+type index_TailwindPadding = TailwindPadding;
+type index_TailwindShadow = TailwindShadow;
+type index_TailwindTextColor = TailwindTextColor;
+type index_TailwindWidth = TailwindWidth;
+type index_Testimonial = Testimonial;
+type index_TestimonialSectionProps = TestimonialSectionProps;
+type index_Theme = Theme;
+type index_ThemeConfig = ThemeConfig;
+declare const index_ThemeContext: typeof ThemeContext;
+type index_ThemeContextValue = ThemeContextValue;
+declare const index_ThemeProvider: typeof ThemeProvider;
+type index_ThemeProviderProps = ThemeProviderProps;
+declare const index_ThemeToggle: typeof ThemeToggle;
+type index_ThemeToggleProps = ThemeToggleProps;
+type index_ThreeColumnProps = ThreeColumnProps;
+type index_TwoColumnProps = TwoColumnProps;
+type index_Typography = Typography;
+type index_UseContinuousRetryOptions = UseContinuousRetryOptions;
+type index_UseContinuousRetryReturn = UseContinuousRetryReturn;
+type index_UseCopyToClipboardReturn = UseCopyToClipboardReturn;
+type index_UseCountdownOptions = UseCountdownOptions;
+type index_UseCountdownReturn = UseCountdownReturn;
+type index_UseCounterOptions = UseCounterOptions;
+type index_UseCounterReturn = UseCounterReturn;
+type index_UseDocumentTitleOptions = UseDocumentTitleOptions;
+type index_UseFetchOptions<T> = UseFetchOptions<T>;
+type index_UseFetchReturn<T> = UseFetchReturn<T>;
+type index_UseGeolocationOptions = UseGeolocationOptions;
+type index_UseGeolocationReturn = UseGeolocationReturn;
+type index_UseHistoryStateOptions = UseHistoryStateOptions;
+type index_UseHistoryStateReturn<T> = UseHistoryStateReturn<T>;
+type index_UseHoverReturn<T extends HTMLElement = HTMLElement> = UseHoverReturn<T>;
+type index_UseIdleOptions = UseIdleOptions;
+type index_UseIdleReturn = UseIdleReturn;
+type index_UseIntersectionObserverOptions = UseIntersectionObserverOptions;
+type index_UseIntersectionObserverReturn<T extends Element = Element> = UseIntersectionObserverReturn<T>;
+type index_UseKeyPressOptions = UseKeyPressOptions;
+type index_UseKeyPressReturn = UseKeyPressReturn;
+type index_UseListReturn<T> = UseListReturn<T>;
+type index_UseLocalStorageOptions<T> = UseLocalStorageOptions<T>;
+type index_UseLoggerOptions = UseLoggerOptions;
+type index_UseLongPressOptions = UseLongPressOptions;
+type index_UseLongPressReturn = UseLongPressReturn;
+type index_UseMapReturn<K, V> = UseMapReturn<K, V>;
+type index_UseMeasureReturn<T extends HTMLElement = HTMLElement> = UseMeasureReturn<T>;
+type index_UseMouseOptions = UseMouseOptions;
+type index_UseMouseReturn<T extends HTMLElement = HTMLElement> = UseMouseReturn<T>;
+type index_UseObjectStateReturn<T extends object> = UseObjectStateReturn<T>;
+type index_UsePageLeaveOptions = UsePageLeaveOptions;
+type index_UsePageTitleOptions = UsePageTitleOptions;
+type index_UsePreferredLanguageReturn = UsePreferredLanguageReturn;
+type index_UseQueueReturn<T> = UseQueueReturn<T>;
+type index_UseScriptOptions = UseScriptOptions;
+type index_UseScriptReturn = UseScriptReturn;
+type index_UseSessionStorageOptions<T> = UseSessionStorageOptions<T>;
+type index_UseSetReturn<T> = UseSetReturn<T>;
+type index_UseSnackbarReturn = UseSnackbarReturn;
+type index_UseTimeoutReturn = UseTimeoutReturn;
+type index_UseToggleReturn = UseToggleReturn;
+type index_UseVisibilityChangeReturn = UseVisibilityChangeReturn;
+type index_UseWindowScrollReturn = UseWindowScrollReturn;
+declare const index_VALIDATION_MESSAGES: typeof VALIDATION_MESSAGES;
+type index_WindowScrollPosition = WindowScrollPosition;
+type index_WindowSize = WindowSize;
+declare const index_addDays: typeof addDays;
+declare const index_adjustColor: typeof adjustColor;
+declare const index_appEvents: typeof appEvents;
+declare const index_camelToKebab: typeof camelToKebab;
+declare const index_capitalize: typeof capitalize;
+declare const index_capitalizeWords: typeof capitalizeWords;
+declare const index_checkPackage: typeof checkPackage;
+declare const index_clientLogger: typeof clientLogger;
+declare const index_contactFormSchema: typeof contactFormSchema;
+declare const index_copyToClipboard: typeof copyToClipboard;
+declare const index_createApiEndpoints: typeof createApiEndpoints;
+declare const index_createApiUrlBuilder: typeof createApiUrlBuilder;
+declare const index_createClientLogger: typeof createClientLogger;
+declare const index_createEmptyPaginationMeta: typeof createEmptyPaginationMeta;
+declare const index_createErrorResponse: typeof createErrorResponse;
+declare const index_createEventEmitter: typeof createEventEmitter;
+declare const index_createHttpClient: typeof createHttpClient;
+declare const index_createRegisterFormSchema: typeof createRegisterFormSchema;
+declare const index_createSuccessResponse: typeof createSuccessResponse;
+declare const index_createTheme: typeof createTheme;
+declare const index_createThemeFromBrand: typeof createThemeFromBrand;
+declare const index_cssVar: typeof cssVar;
+declare const index_deepMerge: typeof deepMerge;
+declare const index_defaultDarkTheme: typeof defaultDarkTheme;
+declare const index_defaultLightTheme: typeof defaultLightTheme;
+declare const index_dummyBannerData: typeof dummyBannerData;
+declare const index_dummyFaqItems: typeof dummyFaqItems;
+declare const index_dummyFeatures: typeof dummyFeatures;
+declare const index_dummyFooterData: typeof dummyFooterData;
+declare const index_dummyHeaderData: typeof dummyHeaderData;
+declare const index_dummyImage: typeof dummyImage;
+declare const index_dummyPricingPlans: typeof dummyPricingPlans;
+declare const index_dummyTestimonials: typeof dummyTestimonials;
+declare const index_endOfDay: typeof endOfDay;
+declare const index_flattenToCssVars: typeof flattenToCssVars;
+declare const index_formatDate: typeof formatDate;
+declare const index_formatDateForInput: typeof formatDateForInput;
+declare const index_formatDateTime: typeof formatDateTime;
+declare const index_formatDateTimeForInput: typeof formatDateTimeForInput;
+declare const index_formatPackageCheckResult: typeof formatPackageCheckResult;
+declare const index_formatRelativeTime: typeof formatRelativeTime;
+declare const index_generateCssVars: typeof generateCssVars;
+declare const index_generateNcuCommand: typeof generateNcuCommand;
+declare const index_getContrastColor: typeof getContrastColor;
+declare const index_getErrorMessage: typeof getErrorMessage;
+declare const index_getNextPage: typeof getNextPage;
+declare const index_getPrevPage: typeof getPrevPage;
+declare const index_getResponseData: typeof getResponseData;
+declare const index_getSystemColorScheme: typeof getSystemColorScheme;
+declare const index_hasData: typeof hasData;
+declare const index_hasMorePages: typeof hasMorePages;
+declare const index_hexToRgba: typeof hexToRgba;
+declare const index_injectCssVars: typeof injectCssVars;
+declare const index_isClipboardAvailable: typeof isClipboardAvailable;
+declare const index_isErrorResponse: typeof isErrorResponse;
+declare const index_isForbidden: typeof isForbidden;
+declare const index_isFuture: typeof isFuture;
+declare const index_isNotFound: typeof isNotFound;
+declare const index_isPast: typeof isPast;
+declare const index_isServerError: typeof isServerError;
+declare const index_isStatusError: typeof isStatusError;
+declare const index_isSuccess: typeof isSuccess;
+declare const index_isSuccessResponse: typeof isSuccessResponse;
+declare const index_isToday: typeof isToday;
+declare const index_isUnauthorized: typeof isUnauthorized;
+declare const index_kebabToCamel: typeof kebabToCamel;
+declare const index_loadThemeFromUrl: typeof loadThemeFromUrl;
+declare const index_loadThemeMode: typeof loadThemeMode;
+declare const index_loginFormSchema: typeof loginFormSchema;
+declare const index_loremIpsum: typeof loremIpsum;
+declare const index_newsletterFormSchema: typeof newsletterFormSchema;
+declare const index_packageCheck: typeof packageCheck;
+declare const index_parseError: typeof parseError;
+declare const index_parseFullResponse: typeof parseFullResponse;
+declare const index_parseResponse: typeof parseResponse;
+declare const index_readFromClipboard: typeof readFromClipboard;
+declare const index_registerFormSchema: typeof registerFormSchema;
+declare const index_removeCssVars: typeof removeCssVars;
+declare const index_resolveThemeMode: typeof resolveThemeMode;
+declare const index_saveThemeMode: typeof saveThemeMode;
+declare const index_slugify: typeof slugify;
+declare const index_slugifyUnique: typeof slugifyUnique;
+declare const index_startOfDay: typeof startOfDay;
+declare const index_truncate: typeof truncate;
+declare const index_truncateWords: typeof truncateWords;
+declare const index_unslugify: typeof unslugify;
+declare const index_useBattery: typeof useBattery;
+declare const index_useClickAway: typeof useClickAway;
+declare const index_useContinuousRetry: typeof useContinuousRetry;
+declare const index_useCopyToClipboard: typeof useCopyToClipboard;
+declare const index_useCountdown: typeof useCountdown;
+declare const index_useCounter: typeof useCounter;
+declare const index_useDebounce: typeof useDebounce;
+declare const index_useDefault: typeof useDefault;
+declare const index_useDocumentTitle: typeof useDocumentTitle;
+declare const index_useEventListener: typeof useEventListener;
+declare const index_useFavicon: typeof useFavicon;
+declare const index_useFetch: typeof useFetch;
+declare const index_useGeolocation: typeof useGeolocation;
+declare const index_useHistoryState: typeof useHistoryState;
+declare const index_useHover: typeof useHover;
+declare const index_useIdle: typeof useIdle;
+declare const index_useIntersectionObserver: typeof useIntersectionObserver;
+declare const index_useInterval: typeof useInterval;
+declare const index_useIntervalWhen: typeof useIntervalWhen;
+declare const index_useIsClient: typeof useIsClient;
+declare const index_useIsDesktop: typeof useIsDesktop;
+declare const index_useIsFirstRender: typeof useIsFirstRender;
+declare const index_useIsMobile: typeof useIsMobile;
+declare const index_useIsMobileOrTablet: typeof useIsMobileOrTablet;
+declare const index_useIsTablet: typeof useIsTablet;
+declare const index_useKeyPress: typeof useKeyPress;
+declare const index_useList: typeof useList;
+declare const index_useLocalStorage: typeof useLocalStorage;
+declare const index_useLockBodyScroll: typeof useLockBodyScroll;
+declare const index_useLogger: typeof useLogger;
+declare const index_useLongPress: typeof useLongPress;
+declare const index_useMap: typeof useMap;
+declare const index_useMeasure: typeof useMeasure;
+declare const index_useMediaQuery: typeof useMediaQuery;
+declare const index_useMouse: typeof useMouse;
+declare const index_useNetworkState: typeof useNetworkState;
+declare const index_useObjectState: typeof useObjectState;
+declare const index_useOnClickOutside: typeof useOnClickOutside;
+declare const index_useOrientation: typeof useOrientation;
+declare const index_usePageLeave: typeof usePageLeave;
+declare const index_usePageTitle: typeof usePageTitle;
+declare const index_usePreferredLanguage: typeof usePreferredLanguage;
+declare const index_usePrevious: typeof usePrevious;
+declare const index_useQueue: typeof useQueue;
+declare const index_useRandomInterval: typeof useRandomInterval;
+declare const index_useRenderCount: typeof useRenderCount;
+declare const index_useRenderInfo: typeof useRenderInfo;
+declare const index_useScript: typeof useScript;
+declare const index_useSessionStorage: typeof useSessionStorage;
+declare const index_useSet: typeof useSet;
+declare const index_useSnackbar: typeof useSnackbar;
+declare const index_useTheme: typeof useTheme;
+declare const index_useThemeDetector: typeof useThemeDetector;
+declare const index_useThemeValue: typeof useThemeValue;
+declare const index_useThrottle: typeof useThrottle;
+declare const index_useTimeout: typeof useTimeout;
+declare const index_useToggle: typeof useToggle;
+declare const index_useVisibilityChange: typeof useVisibilityChange;
+declare const index_useWindowScroll: typeof useWindowScroll;
+declare const index_useWindowSize: typeof useWindowSize;
+declare const index_withAbortSignal: typeof withAbortSignal;
+declare const index_withFormData: typeof withFormData;
+declare const index_withTimeout: typeof withTimeout;
+declare namespace index {
+  export { index_ApiResponse as ApiResponse, index_ApiUrlBuilder as ApiUrlBuilder, index_ApiUrlConfig as ApiUrlConfig, type index_BannerProps as BannerProps, type index_BatteryState as BatteryState, type index_BorderRadius as BorderRadius, type index_Breakpoints as Breakpoints, type index_ButtonProps as ButtonProps, type index_ButtonSize as ButtonSize, type index_ButtonVariant as ButtonVariant, type index_CardProps as CardProps, index_ClientLogger as ClientLogger, index_ClientLoggerConfig as ClientLoggerConfig, type index_ColProps as ColProps, type index_ColorPalette as ColorPalette, type index_ComponentThemes as ComponentThemes, index_ContactForm as ContactForm, type index_ContactFormProps as ContactFormProps, type index_ContactFormValues as ContactFormValues, type index_ContainerProps as ContainerProps, type index_CtaSectionProps as CtaSectionProps, type index_Dimensions as Dimensions, index_EventEmitter as EventEmitter, type index_FaqItem as FaqItem, type index_FaqSectionProps as FaqSectionProps, type index_Feature as Feature, type index_FeatureSectionProps as FeatureSectionProps, type index_FooterColumn as FooterColumn, type index_FooterProps as FooterProps, type index_FormFieldError as FormFieldError, type index_FormSubmitResult as FormSubmitResult, type index_GeolocationState as GeolocationState, type index_HeaderProps as HeaderProps, index_HttpClientOptions as HttpClientOptions, type index_LoaderProps as LoaderProps, type index_LoaderSize as LoaderSize, type index_LoaderVariant as LoaderVariant, index_LogLevel as LogLevel, index_LoginForm as LoginForm, type index_LoginFormProps as LoginFormProps, type index_LoginFormValues as LoginFormValues, type index_MousePosition as MousePosition, type index_NavLink as NavLink, type index_NetworkState as NetworkState, index_NewsletterForm as NewsletterForm, type index_NewsletterFormProps as NewsletterFormProps, type index_NewsletterFormValues as NewsletterFormValues, type index_NewsletterSectionProps as NewsletterSectionProps, index_NpmRegistryResponse as NpmRegistryResponse, type index_ObjectStateUpdate as ObjectStateUpdate, type index_OrientationState as OrientationState, index_PackageCheckResult as PackageCheckResult, index_PackageJson as PackageJson, index_PackageVersion as PackageVersion, index_PaginatedResponse as PaginatedResponse, type index_PasswordRequirements as PasswordRequirements, type index_PricingFeature as PricingFeature, type index_PricingPlan as PricingPlan, type index_PricingSectionProps as PricingSectionProps, index_RegisterForm as RegisterForm, type index_RegisterFormProps as RegisterFormProps, type index_RegisterFormValues as RegisterFormValues, type index_RenderInfo as RenderInfo, type index_RowProps as RowProps, type index_ScriptStatus as ScriptStatus, type index_SemanticColors as SemanticColors, type index_SetValue as SetValue, type index_Shadows as Shadows, type index_SnackbarSeverity as SnackbarSeverity, type index_SnackbarState as SnackbarState, type index_SocialLink as SocialLink, type index_Spacing as Spacing, type index_TailwindBgColor as TailwindBgColor, type index_TailwindBorderRadius as TailwindBorderRadius, type TailwindClasses$1 as TailwindClasses, type index_TailwindFontSize as TailwindFontSize, type index_TailwindFontWeight as TailwindFontWeight, type index_TailwindGap as TailwindGap, type index_TailwindHeight as TailwindHeight, type index_TailwindMargin as TailwindMargin, type index_TailwindPadding as TailwindPadding, type index_TailwindShadow as TailwindShadow, type index_TailwindTextColor as TailwindTextColor, type index_TailwindWidth as TailwindWidth, type index_Testimonial as Testimonial, type index_TestimonialSectionProps as TestimonialSectionProps, type index_Theme as Theme, type index_ThemeConfig as ThemeConfig, index_ThemeContext as ThemeContext, type index_ThemeContextValue as ThemeContextValue, type ThemeMode$1 as ThemeMode, index_ThemeProvider as ThemeProvider, type index_ThemeProviderProps as ThemeProviderProps, index_ThemeToggle as ThemeToggle, type index_ThemeToggleProps as ThemeToggleProps, type index_ThreeColumnProps as ThreeColumnProps, type index_TwoColumnProps as TwoColumnProps, type index_Typography as Typography, type index_UseContinuousRetryOptions as UseContinuousRetryOptions, type index_UseContinuousRetryReturn as UseContinuousRetryReturn, type index_UseCopyToClipboardReturn as UseCopyToClipboardReturn, type index_UseCountdownOptions as UseCountdownOptions, type index_UseCountdownReturn as UseCountdownReturn, type index_UseCounterOptions as UseCounterOptions, type index_UseCounterReturn as UseCounterReturn, type index_UseDocumentTitleOptions as UseDocumentTitleOptions, type index_UseFetchOptions as UseFetchOptions, type index_UseFetchReturn as UseFetchReturn, type index_UseGeolocationOptions as UseGeolocationOptions, type index_UseGeolocationReturn as UseGeolocationReturn, type index_UseHistoryStateOptions as UseHistoryStateOptions, type index_UseHistoryStateReturn as UseHistoryStateReturn, type index_UseHoverReturn as UseHoverReturn, type index_UseIdleOptions as UseIdleOptions, type index_UseIdleReturn as UseIdleReturn, type index_UseIntersectionObserverOptions as UseIntersectionObserverOptions, type index_UseIntersectionObserverReturn as UseIntersectionObserverReturn, type index_UseKeyPressOptions as UseKeyPressOptions, type index_UseKeyPressReturn as UseKeyPressReturn, type index_UseListReturn as UseListReturn, type index_UseLocalStorageOptions as UseLocalStorageOptions, type index_UseLoggerOptions as UseLoggerOptions, type index_UseLongPressOptions as UseLongPressOptions, type index_UseLongPressReturn as UseLongPressReturn, type index_UseMapReturn as UseMapReturn, type index_UseMeasureReturn as UseMeasureReturn, type index_UseMouseOptions as UseMouseOptions, type index_UseMouseReturn as UseMouseReturn, type index_UseObjectStateReturn as UseObjectStateReturn, type index_UsePageLeaveOptions as UsePageLeaveOptions, type index_UsePageTitleOptions as UsePageTitleOptions, type index_UsePreferredLanguageReturn as UsePreferredLanguageReturn, type index_UseQueueReturn as UseQueueReturn, type index_UseScriptOptions as UseScriptOptions, type index_UseScriptReturn as UseScriptReturn, type index_UseSessionStorageOptions as UseSessionStorageOptions, type index_UseSetReturn as UseSetReturn, type index_UseSnackbarReturn as UseSnackbarReturn, type index_UseTimeoutReturn as UseTimeoutReturn, type index_UseToggleReturn as UseToggleReturn, type index_UseVisibilityChangeReturn as UseVisibilityChangeReturn, type index_UseWindowScrollReturn as UseWindowScrollReturn, index_VALIDATION_MESSAGES as VALIDATION_MESSAGES, type ThemeMode as WebThemeMode, type index_WindowScrollPosition as WindowScrollPosition, type index_WindowSize as WindowSize, index_addDays as addDays, index_adjustColor as adjustColor, index_appEvents as appEvents, index_camelToKebab as camelToKebab, index_capitalize as capitalize, index_capitalizeWords as capitalizeWords, index_checkPackage as checkPackage, index_clientLogger as clientLogger, index_contactFormSchema as contactFormSchema, index_copyToClipboard as copyToClipboard, index_createApiEndpoints as createApiEndpoints, index_createApiUrlBuilder as createApiUrlBuilder, index_createClientLogger as createClientLogger, index_createEmptyPaginationMeta as createEmptyPaginationMeta, index_createErrorResponse as createErrorResponse, index_createEventEmitter as createEventEmitter, index_createHttpClient as createHttpClient, index_createRegisterFormSchema as createRegisterFormSchema, index_createSuccessResponse as createSuccessResponse, index_createTheme as createTheme, index_createThemeFromBrand as createThemeFromBrand, index_cssVar as cssVar, index_deepMerge as deepMerge, index_defaultDarkTheme as defaultDarkTheme, index_defaultLightTheme as defaultLightTheme, index_dummyBannerData as dummyBannerData, index_dummyFaqItems as dummyFaqItems, index_dummyFeatures as dummyFeatures, index_dummyFooterData as dummyFooterData, index_dummyHeaderData as dummyHeaderData, index_dummyImage as dummyImage, index_dummyPricingPlans as dummyPricingPlans, index_dummyTestimonials as dummyTestimonials, index_endOfDay as endOfDay, index_flattenToCssVars as flattenToCssVars, index_formatDate as formatDate, index_formatDateForInput as formatDateForInput, index_formatDateTime as formatDateTime, index_formatDateTimeForInput as formatDateTimeForInput, index_formatPackageCheckResult as formatPackageCheckResult, index_formatRelativeTime as formatRelativeTime, index_generateCssVars as generateCssVars, index_generateNcuCommand as generateNcuCommand, index_getContrastColor as getContrastColor, index_getErrorMessage as getErrorMessage, index_getNextPage as getNextPage, index_getPrevPage as getPrevPage, index_getResponseData as getResponseData, index_getSystemColorScheme as getSystemColorScheme, index_hasData as hasData, index_hasMorePages as hasMorePages, index_hexToRgba as hexToRgba, index_injectCssVars as injectCssVars, index_isClipboardAvailable as isClipboardAvailable, index_isErrorResponse as isErrorResponse, index_isForbidden as isForbidden, index_isFuture as isFuture, index_isNotFound as isNotFound, index_isPast as isPast, index_isServerError as isServerError, index_isStatusError as isStatusError, index_isSuccess as isSuccess, index_isSuccessResponse as isSuccessResponse, index_isToday as isToday, index_isUnauthorized as isUnauthorized, index_kebabToCamel as kebabToCamel, index_loadThemeFromUrl as loadThemeFromUrl, index_loadThemeMode as loadThemeMode, index_loginFormSchema as loginFormSchema, index_loremIpsum as loremIpsum, index_newsletterFormSchema as newsletterFormSchema, index_packageCheck as packageCheck, index_parseError as parseError, index_parseFullResponse as parseFullResponse, index_parseResponse as parseResponse, index_readFromClipboard as readFromClipboard, index_registerFormSchema as registerFormSchema, index_removeCssVars as removeCssVars, index_resolveThemeMode as resolveThemeMode, index_saveThemeMode as saveThemeMode, index_slugify as slugify, index_slugifyUnique as slugifyUnique, index_startOfDay as startOfDay, index_truncate as truncate, index_truncateWords as truncateWords, index_unslugify as unslugify, index_useBattery as useBattery, index_useClickAway as useClickAway, index_useContinuousRetry as useContinuousRetry, index_useCopyToClipboard as useCopyToClipboard, index_useCountdown as useCountdown, index_useCounter as useCounter, index_useDebounce as useDebounce, index_useDefault as useDefault, index_useDocumentTitle as useDocumentTitle, index_useEventListener as useEventListener, index_useFavicon as useFavicon, index_useFetch as useFetch, index_useGeolocation as useGeolocation, index_useHistoryState as useHistoryState, index_useHover as useHover, index_useIdle as useIdle, index_useIntersectionObserver as useIntersectionObserver, index_useInterval as useInterval, index_useIntervalWhen as useIntervalWhen, index_useIsClient as useIsClient, index_useIsDesktop as useIsDesktop, index_useIsFirstRender as useIsFirstRender, index_useIsMobile as useIsMobile, index_useIsMobileOrTablet as useIsMobileOrTablet, index_useIsTablet as useIsTablet, index_useKeyPress as useKeyPress, index_useList as useList, index_useLocalStorage as useLocalStorage, index_useLockBodyScroll as useLockBodyScroll, index_useLogger as useLogger, index_useLongPress as useLongPress, index_useMap as useMap, index_useMeasure as useMeasure, index_useMediaQuery as useMediaQuery, index_useMouse as useMouse, index_useNetworkState as useNetworkState, index_useObjectState as useObjectState, index_useOnClickOutside as useOnClickOutside, index_useOrientation as useOrientation, index_usePageLeave as usePageLeave, index_usePageTitle as usePageTitle, index_usePreferredLanguage as usePreferredLanguage, index_usePrevious as usePrevious, index_useQueue as useQueue, index_useRandomInterval as useRandomInterval, index_useRenderCount as useRenderCount, index_useRenderInfo as useRenderInfo, index_useScript as useScript, index_useSessionStorage as useSessionStorage, index_useSet as useSet, index_useSnackbar as useSnackbar, index_useTheme as useTheme, index_useThemeDetector as useThemeDetector, index_useThemeValue as useThemeValue, index_useThrottle as useThrottle, index_useTimeout as useTimeout, index_useToggle as useToggle, index_useVisibilityChange as useVisibilityChange, index_useWindowScroll as useWindowScroll, index_useWindowSize as useWindowSize, index_withAbortSignal as withAbortSignal, index_withFormData as withFormData, index_withTimeout as withTimeout };
+}
+
+export { useMouse as $, APPS as A, BRANDS as B, type ContactInfo as C, useTimeout as D, useInterval as E, useIntervalWhen as F, useRandomInterval as G, useCountdown as H, useContinuousRetry as I, useWindowSize as J, useWindowScroll as K, type LogoSet as L, useDocumentTitle as M, usePageTitle as N, useFavicon as O, useVisibilityChange as P, usePageLeave as Q, useLockBodyScroll as R, type SEOConfig as S, useIsClient as T, useIsFirstRender as U, useEventListener as V, useKeyPress as W, useHover as X, useClickAway as Y, useOnClickOutside as Z, useLongPress as _, type AppConfig as a, type UsePreferredLanguageReturn as a$, useCopyToClipboard as a0, useMediaQuery as a1, useOrientation as a2, useBattery as a3, useNetworkState as a4, useIdle as a5, useGeolocation as a6, usePreferredLanguage as a7, useThemeDetector as a8, useLocalStorage as a9, type WindowScrollPosition as aA, type UseWindowScrollReturn as aB, type UseDocumentTitleOptions as aC, type UsePageTitleOptions as aD, type UseVisibilityChangeReturn as aE, type UsePageLeaveOptions as aF, type UseKeyPressOptions as aG, type UseKeyPressReturn as aH, type UseHoverReturn as aI, type UseLongPressOptions as aJ, type UseLongPressReturn as aK, type MousePosition as aL, type UseMouseOptions as aM, type UseMouseReturn as aN, type UseCopyToClipboardReturn as aO, useIsMobile as aP, useIsTablet as aQ, useIsDesktop as aR, useIsMobileOrTablet as aS, type OrientationState as aT, type BatteryState as aU, type NetworkState as aV, type UseIdleOptions as aW, type UseIdleReturn as aX, type GeolocationState as aY, type UseGeolocationOptions as aZ, type UseGeolocationReturn as a_, useSessionStorage as aa, useFetch as ab, useScript as ac, useRenderInfo as ad, useRenderCount as ae, useLogger as af, useMeasure as ag, useIntersectionObserver as ah, useSnackbar as ai, type UseToggleReturn as aj, type UseCounterOptions as ak, type UseCounterReturn as al, type ObjectStateUpdate as am, type UseObjectStateReturn as an, type UseHistoryStateReturn as ao, type UseHistoryStateOptions as ap, type UseQueueReturn as aq, type UseListReturn as ar, type UseMapReturn as as, type UseSetReturn as at, type UseTimeoutReturn as au, type UseCountdownOptions as av, type UseCountdownReturn as aw, type UseContinuousRetryOptions as ax, type UseContinuousRetryReturn as ay, type WindowSize as az, type BrandColors as b, type TailwindWidth as b$, type ThemeMode$1 as b0, type SetValue as b1, type UseLocalStorageOptions as b2, type UseSessionStorageOptions as b3, type UseFetchOptions as b4, type UseFetchReturn as b5, type ScriptStatus as b6, type UseScriptOptions as b7, type UseScriptReturn as b8, type RenderInfo as b9, cssVar as bA, ThemeContext as bB, defaultLightTheme as bC, defaultDarkTheme as bD, deepMerge as bE, createThemeFromBrand as bF, adjustColor as bG, hexToRgba as bH, getContrastColor as bI, flattenToCssVars as bJ, generateCssVars as bK, injectCssVars as bL, removeCssVars as bM, loadThemeFromUrl as bN, createTheme as bO, saveThemeMode as bP, loadThemeMode as bQ, getSystemColorScheme as bR, resolveThemeMode as bS, type TailwindTextColor as bT, type TailwindBgColor as bU, type TailwindPadding as bV, type TailwindMargin as bW, type TailwindFontSize as bX, type TailwindFontWeight as bY, type TailwindBorderRadius as bZ, type TailwindShadow as b_, type UseLoggerOptions as ba, type Dimensions as bb, type UseMeasureReturn as bc, type UseIntersectionObserverOptions as bd, type UseIntersectionObserverReturn as be, type SnackbarSeverity as bf, type SnackbarState as bg, type UseSnackbarReturn as bh, type Theme as bi, type ThemeMode as bj, type ThemeConfig as bk, type ThemeContextValue as bl, type ColorPalette as bm, type SemanticColors as bn, type Typography as bo, type Spacing as bp, type BorderRadius as bq, type Shadows as br, type Breakpoints as bs, type ComponentThemes as bt, type ThemeProviderProps as bu, type ThemeToggleProps as bv, ThemeProvider as bw, useTheme as bx, ThemeToggle as by, useThemeValue as bz, type BrandIdentity as c, type TailwindHeight as c0, type TailwindGap as c1, type TailwindClasses$1 as c2, type ButtonVariant as c3, type ButtonSize as c4, type ButtonProps as c5, type LoaderVariant as c6, type LoaderSize as c7, type LoaderProps as c8, type ContainerProps as c9, dummyBannerData as cA, dummyFeatures as cB, dummyTestimonials as cC, dummyPricingPlans as cD, dummyFaqItems as cE, type FormFieldError as cF, type FormSubmitResult as cG, type ContactFormValues as cH, type ContactFormProps as cI, type NewsletterFormValues as cJ, type NewsletterFormProps as cK, type LoginFormValues as cL, type LoginFormProps as cM, type RegisterFormValues as cN, type RegisterFormProps as cO, VALIDATION_MESSAGES as cP, contactFormSchema as cQ, newsletterFormSchema as cR, loginFormSchema as cS, registerFormSchema as cT, createRegisterFormSchema as cU, type PasswordRequirements as cV, ContactForm as cW, NewsletterForm as cX, LoginForm as cY, RegisterForm as cZ, type RowProps as ca, type ColProps as cb, type TwoColumnProps as cc, type ThreeColumnProps as cd, type NavLink as ce, type HeaderProps as cf, type FooterColumn as cg, type SocialLink as ch, type FooterProps as ci, type BannerProps as cj, type CtaSectionProps as ck, type NewsletterSectionProps as cl, type CardProps as cm, type Feature as cn, type FeatureSectionProps as co, type Testimonial as cp, type TestimonialSectionProps as cq, type PricingFeature as cr, type PricingPlan as cs, type PricingSectionProps as ct, type FaqItem as cu, type FaqSectionProps as cv, dummyImage as cw, loremIpsum as cx, dummyHeaderData as cy, dummyFooterData as cz, type SocialLinks as d, createAppConfig as e, detectCurrentBrand as f, getAllBrandIds as g, getAllBrands as h, getAppConfigByDomain as i, getBrandByDomain as j, getBrandById as k, getLogo as l, getThemedLogo as m, index as n, useCounter as o, useDefault as p, usePrevious as q, useObjectState as r, useHistoryState as s, useQueue as t, useToggle as u, useList as v, useMap as w, useSet as x, useDebounce as y, useThrottle as z };