import * as react_jsx_runtime from 'react/jsx-runtime';
import * as React$1 from 'react';
import React__default, { ReactNode, ComponentType } from 'react';
import { Components } from 'react-markdown';
import { ViewState } from 'react-map-gl/maplibre';
import { Language } from 'prism-react-renderer';
export { Language } from 'prism-react-renderer';
import { RJSFSchema, UiSchema, WidgetProps, FieldTemplateProps, ObjectFieldTemplateProps, ArrayFieldTemplateProps, ArrayFieldItemTemplateProps, ErrorListProps } from '@rjsf/utils';
import { FormProps, IChangeEvent } from '@rjsf/core';
import * as zustand from 'zustand';
import { CommonExternalProps } from 'react-json-tree';
import { MediaPlayerInstance } from '@vidstack/react';
import * as monaco from 'monaco-editor';
import * as zustand_middleware from 'zustand/middleware';

interface LoadingFallbackProps {
    /** Minimum height of the loading container */
    minHeight?: string | number;
    /** Show loading text */
    showText?: boolean;
    /** Custom loading text */
    text?: string;
    /** Additional CSS classes */
    className?: string;
}
/**
 * Spinner - Simple spinning loader
 */
declare function Spinner({ className }: {
    className?: string;
}): react_jsx_runtime.JSX.Element;
/**
 * LoadingFallback - Default loading state for lazy components
 */
declare function LoadingFallback({ minHeight, showText, text, className, }: LoadingFallbackProps): react_jsx_runtime.JSX.Element;
/**
 * CardLoadingFallback - Loading state styled as a card
 */
declare function CardLoadingFallback({ title, description, minHeight, className, }: {
    title?: string;
    description?: string;
    minHeight?: string | number;
    className?: string;
}): react_jsx_runtime.JSX.Element;
/**
 * MapLoadingFallback - Loading state for map components
 */
declare function MapLoadingFallback({ minHeight, className, }: {
    minHeight?: string | number;
    className?: string;
}): react_jsx_runtime.JSX.Element;
interface LazyWrapperProps {
    children: ReactNode;
    /** Custom fallback component */
    fallback?: ReactNode;
    /** Use card-style fallback */
    card?: boolean;
    /** Card title (when card=true) */
    cardTitle?: string;
    /** Card description (when card=true) */
    cardDescription?: string;
    /** Minimum height for fallback */
    minHeight?: string | number;
    /** Additional CSS classes for fallback */
    className?: string;
}
/**
 * LazyWrapper - Suspense wrapper with configurable fallbacks
 *
 * @example
 * // Basic usage
 * <LazyWrapper>
 *   <LazyComponent />
 * </LazyWrapper>
 *
 * @example
 * // Card style fallback
 * <LazyWrapper card cardTitle="Diagram" minHeight={300}>
 *   <Mermaid chart={...} />
 * </LazyWrapper>
 *
 * @example
 * // Custom fallback
 * <LazyWrapper fallback={<MyCustomLoader />}>
 *   <HeavyComponent />
 * </LazyWrapper>
 */
declare function LazyWrapper({ children, fallback, card, cardTitle, cardDescription, minHeight, className, }: LazyWrapperProps): react_jsx_runtime.JSX.Element;
interface CreateLazyComponentOptions<P> {
    /** Loading fallback component */
    fallback?: ReactNode | ((props: P) => ReactNode);
    /** Display name for the component */
    displayName?: string;
}
/**
 * createLazyComponent - Factory for creating lazy-loaded components
 *
 * @example
 * const LazyMermaid = createLazyComponent(
 *   () => import('./Mermaid.client'),
 *   {
 *     displayName: 'Mermaid',
 *     fallback: <CardLoadingFallback title="Diagram" />,
 *   }
 * );
 */
declare function createLazyComponent<P extends object>(loader: () => Promise<{
    default: ComponentType<P>;
}>, options?: CreateLazyComponentOptions<P>): ComponentType<P>;

/**
 * Declarative rule for handling a custom URL scheme inside markdown.
 *
 * Each rule owns one href shape (e.g. `cmdop://machine/<uuid>`,
 * `obsidian://open?path=…`) and decides:
 *
 *   1. Whether the URL scheme survives sanitize (`protocols`).
 *   2. How to massage the source markdown before render
 *      (`preprocess` — optional; useful for stripping decorative
 *      prefixes like the `@` in `@[label](href)` so the chip alone
 *      reads as the mention indicator).
 *   3. Which links it owns (`match`), and how to render them
 *      (`render`, returning JSX).
 *
 * Rules compose: pass an array, and the renderer iterates top-to-bottom
 * picking the first `match` hit per `<a>`. Anything no rule claims
 * falls through to the built-in chat-link styling (or to a custom
 * `customComponents.a` if both are provided).
 *
 * Prefer `linkRules` over `customComponents` + `extraHrefProtocols` —
 * it's the same pieces with the boilerplate removed.
 */
interface LinkRule {
    /** Pre-process the raw markdown source before any rendering happens.
     *  Pure / synchronous; identity-return when no transform applies. */
    preprocess?: (source: string) => string;
    /** Predicate against the resolved href. */
    match: (href: string) => boolean;
    /** Render the link this rule owns. `children` is the link's label
     *  (markdown-rendered React content). */
    render: (props: {
        href: string;
        children: React__default.ReactNode;
        isUser: boolean;
    }) => React__default.ReactNode;
    /** URL scheme(s) to whitelist on the sanitize side, e.g. `['cmdop']`.
     *  Bare schemes only — no `://`. Optional; omit for `http(s)` rules. */
    protocols?: readonly string[];
    /** Diagnostic label, surfaced in dev warnings. Optional. */
    name?: string;
}
interface MarkdownMessageProps {
    /** Markdown content to render */
    content: string;
    /** Additional CSS classes */
    className?: string;
    /** Whether the message is from the user (affects styling) */
    isUser?: boolean;
    /** Use compact size (text-xs instead of text-sm) */
    isCompact?: boolean;
    /**
     * Force the plain-text rendering path (single `<div>` with
     * `white-space: pre-wrap`, no ReactMarkdown). Use this for
     * user-authored content where markdown shouldn't be parsed.
     *
     * When `undefined` (default) we run a small heuristic
     * (`looksLikePlainProse`): short single-paragraph text without
     * markdown markers → plain; everything else → ReactMarkdown.
     *
     * Pass an explicit `true` / `false` to opt out of the heuristic
     * entirely.
     */
    plainText?: boolean;
    /**
     * Per-tag overrides merged on top of the built-in renderers.
     *
     * Use this when you need custom rendering for a specific tag without
     * losing the chat-tuned defaults (links, code blocks with copy, etc).
     *
     * For custom URL-scheme link handling, prefer `linkRules` — it's the
     * same ergonomics with the per-consumer boilerplate removed.
     */
    customComponents?: Partial<Components>;
    /**
     * Extra URL protocols allowed in `<a href>` after sanitize.
     *
     * The default schema strips anything that isn't
     * `http(s)/mailto/xmpp/irc(s)` — your custom renderer would receive
     * `href={undefined}` for `cmdop://…` / `obsidian://…` etc. Listing
     * the bare scheme here (e.g. `'cmdop'`, NOT `'cmdop://'`) opts it in.
     *
     * Use carefully: every protocol you add increases what the rendered
     * HTML can do via clicks. Stick to schemes you control.
     */
    extraHrefProtocols?: readonly string[];
    /**
     * Declarative link rules — preferred over `customComponents` +
     * `extraHrefProtocols` for chat-style apps that want pluggable
     * URL-scheme handling without re-implementing the custom-`a`
     * boilerplate per consumer.
     *
     * If you provide both `linkRules` and `extraHrefProtocols`, the
     * effective protocol list is the union of the two.
     */
    linkRules?: readonly LinkRule[];
    /**
     * Enable collapsible "Read more..." functionality
     * @default false
     */
    collapsible?: boolean;
    /** Maximum character length before showing "Read more...". */
    maxLength?: number;
    /** Maximum number of lines before showing "Read more...". */
    maxLines?: number;
    /** Custom "Read more" button text. @default "Read more..." */
    readMoreLabel?: string;
    /** Custom "Show less" button text. @default "Show less" */
    showLessLabel?: string;
    /** Start expanded (only when `collapsible` is true). @default false */
    defaultExpanded?: boolean;
    /** Callback when collapsed state changes */
    onCollapseChange?: (isCollapsed: boolean) => void;
}

/**
 * MarkdownMessage — chat-tuned markdown renderer.
 *
 * Features:
 * - GitHub Flavored Markdown (GFM) via remark-gfm
 * - Syntax-highlighted code blocks with Copy button
 * - Mermaid diagram rendering (` ```mermaid ` fence)
 * - Tables, lists, blockquotes scaled for chat density
 * - User vs assistant styling modes (`isUser`)
 * - Plain-text fast path: skips ReactMarkdown when content has no
 *   markdown syntax (cheaper render, preserves newlines via CSS)
 * - Optional collapsible "Read more..." for long messages
 *
 * Custom URL schemes (chat mentions, deep-links, custom file viewers)
 * are best handled with the declarative `linkRules` prop — see the
 * type definition in `./types.ts` and the storybook for examples.
 *
 * @example
 * ```tsx
 * <MarkdownMessage content="# Hello\n\nThis is **bold** text." />
 *
 * // User message styling
 * <MarkdownMessage content="Some content" isUser />
 *
 * // Custom URL scheme via linkRules
 * <MarkdownMessage
 *   content="Talk to [Vps-audi](cmdop://machine/abc-123)"
 *   linkRules={[machineMentionRule]}
 * />
 * ```
 */
declare const MarkdownMessage: React__default.FC<MarkdownMessageProps>;

/** Recursively concatenate the text content of a React.ReactNode tree.
 *  Used by the markdown renderers (e.g. `<pre>` extracting code) and
 *  by consumers that need a plain-string label out of link children. */
declare function extractTextFromChildren(children: React__default.ReactNode): string;

interface UseCollapsibleContentOptions {
    /**
     * Maximum character length before collapsing
     * If both maxLength and maxLines are set, the stricter limit applies
     */
    maxLength?: number;
    /**
     * Maximum number of lines before collapsing
     * If both maxLength and maxLines are set, the stricter limit applies
     */
    maxLines?: number;
    /**
     * Start in expanded state (default: false - starts collapsed)
     */
    defaultExpanded?: boolean;
}
interface UseCollapsibleContentResult {
    /** Whether content is currently collapsed */
    isCollapsed: boolean;
    /** Toggle between collapsed/expanded state */
    toggleCollapsed: () => void;
    /** Set collapsed state directly */
    setCollapsed: (collapsed: boolean) => void;
    /** Content to display (truncated if collapsed, full if expanded) */
    displayContent: string;
    /** Whether the content exceeds limits and should be collapsible */
    shouldCollapse: boolean;
    /** Original content length */
    originalLength: number;
    /** Original line count */
    originalLineCount: number;
}
/**
 * Hook for managing collapsible content with "Read more..." functionality
 *
 * @example
 * ```tsx
 * const { isCollapsed, toggleCollapsed, displayContent, shouldCollapse } = useCollapsibleContent(
 *   longText,
 *   { maxLength: 300, maxLines: 5 }
 * );
 *
 * return (
 *   <div>
 *     <Markdown content={displayContent} />
 *     {shouldCollapse && (
 *       <button onClick={toggleCollapsed}>
 *         {isCollapsed ? 'Read more...' : 'Show less'}
 *       </button>
 *     )}
 *   </div>
 * );
 * ```
 */
declare function useCollapsibleContent(content: string, options?: UseCollapsibleContentOptions): UseCollapsibleContentResult;

interface MarkerData {
    id: string;
    longitude: number;
    latitude: number;
    data?: Record<string, unknown>;
}
interface MapViewport extends Partial<ViewState> {
    longitude: number;
    latitude: number;
    zoom: number;
    bearing?: number;
    pitch?: number;
    transitionDuration?: number;
}
type MapStyleKey = 'light' | 'dark' | 'streets' | 'satellite';

interface MapContainerProps {
    children?: ReactNode;
    initialViewport?: Partial<MapViewport>;
    mapStyle?: MapStyleKey | string;
    interactiveLayerIds?: string[];
    className?: string;
    style?: React.CSSProperties;
    cursor?: string;
    attributionControl?: boolean;
    reuseMaps?: boolean;
    /** URL to open in external maps app (shows "Open in Maps" button if provided) */
    openInMapsUrl?: string;
    /** Label for the open in maps button */
    openInMapsLabel?: string;
    /** Auto-reset to initial viewport after N ms of inactivity (0 = disabled) */
    autoResetDelay?: number;
    /** Show reset button */
    showResetButton?: boolean;
}

/**
 * LazyMapContainer - Lazy-loaded map container
 *
 * Automatically shows loading state while MapLibre GL loads (~800KB)
 */
declare const LazyMapContainer: React$1.ComponentType<MapContainerProps>;
/**
 * LazyMapView - Lazy-loaded map view (alias for MapContainer)
 */
declare const LazyMapView: React$1.ComponentType<Omit<MapContainerProps, "initialViewport">>;

/**
 * Mermaid Component - Dynamic Import Wrapper
 *
 * Lazy loads the heavy Mermaid library (~800KB) only when needed.
 * This significantly reduces the initial bundle size.
 */

interface MermaidProps {
    chart: string;
    className?: string;
    isCompact?: boolean;
    /** Enable click-to-fullscreen functionality (default: true) */
    fullscreen?: boolean;
    /**
     * Enable the FloatingToolbar's "click to scroll" lock overlay.
     * Defaults to `false` — Mermaid diagrams don't scroll internally,
     * so the lock overlay just steals page wheel events. See the
     * Mermaid.client implementation for the full rationale.
     */
    scrollIsolation?: boolean;
}
declare const Mermaid: React__default.FC<MermaidProps>;

/**
 * LazyMermaid - Lazy-loaded Mermaid diagram renderer
 *
 * Automatically shows loading state while Mermaid loads (~800KB)
 */
declare const LazyMermaid: React$1.ComponentType<MermaidProps>;

interface PrettyCodeProps$1 {
    data: string | object;
    language: Language;
    className?: string;
    mode?: 'dark' | 'light';
    inline?: boolean;
    customBg?: string;
    isCompact?: boolean;
    scrollIsolation?: boolean;
    maxLines?: number;
    /** ``'card'`` (default) ships the full chrome. ``'plain'`` is
     *  chrome-less — for embedding inside another scroll container. */
    variant?: 'card' | 'plain';
}

/**
 * LazyPrettyCode - Lazy-loaded code syntax highlighter
 *
 * Automatically shows loading state while Prism loads (~500KB)
 */
declare const LazyPrettyCode: React$1.ComponentType<PrettyCodeProps$1>;

interface ApiKey {
    id: string;
    name: string;
    /** Raw key value sent in the ``X-API-Key`` request header. */
    secret: string;
    created_at?: string;
    last_used_at?: string | null;
}
interface SchemaSource {
    id: string;
    name: string;
    url: string;
    /** Per-schema override for the request base URL. Wins over the
     *  global ``PlaygroundConfig.baseUrl`` and over ``schema.servers[0].url``
     *  from the OpenAPI document. Use when a single playground hosts
     *  several APIs that live on different domains. */
    baseUrl?: string;
}
interface PlaygroundConfig {
    schemas: SchemaSource[];
    defaultSchemaId?: string;
    /** Global override for the request base URL. Used when the OpenAPI
     *  document has no ``servers`` entry, or when docs are hosted on a
     *  different origin than the API. Resolution order (highest wins):
     *  ``SchemaSource.baseUrl`` → ``PlaygroundConfig.baseUrl`` →
     *  ``schema.servers[0].url`` → empty string (relative paths). */
    baseUrl?: string;
    /** Optional API keys the user can pick from in the request panel.
     *  When provided, the playground auto-selects the first one and
     *  syncs the ``X-API-Key`` header from ``ApiKey.secret``. Pass
     *  the loading flag if your source is async — the picker shows
     *  a spinner instead of "no keys yet". */
    apiKeys?: ApiKey[];
    apiKeysLoading?: boolean;
    /** How multiple schemas are presented in the sidebar.
     *  - ``'selector'`` (default): a Combobox switches between schemas, the
     *    docs column shows endpoints of the active schema only.
     *  - ``'sections'``: the Combobox is hidden and every schema becomes a
     *    top-level heading in the sidebar, with endpoints of all schemas
     *    rendered back-to-back in the docs column. Scrollspy picks the
     *    active schema based on what's visible. */
    schemaGrouping?: 'selector' | 'sections';
    /** URL-hash sync. When enabled, the viewer reads/writes
     *  ``#<schemaId>/<anchor>`` on the browser location so deep-links
     *  to a specific endpoint work out of the box. Defaults to ``true`` —
     *  pass ``false`` (or ``{ enabled: false }``) to opt out if the host
     *  page already manages the hash itself. */
    urlSync?: boolean | {
        enabled: boolean;
    };
}

/**
 * Lazy-loaded OpenapiViewer Component
 *
 * Heavy OpenAPI viewer (~400KB) is loaded only when component is rendered.
 * Use this for automatic code-splitting with Suspense fallback.
 *
 * For direct imports without lazy loading, use:
 *   import OpenapiViewer from '@djangocfg/ui-tools/openapi'
 */

interface PlaygroundProps$1 {
    config: PlaygroundConfig;
}

declare const LazyOpenapiViewer: React$1.FC<PlaygroundProps$1>;

/**
 * JSON Schema Form props interface
 */
interface JsonSchemaFormProps<T = any> extends Partial<FormProps<T>> {
    /** JSON Schema that defines the form structure */
    schema: RJSFSchema;
    /** UI Schema for customizing the form appearance */
    uiSchema?: UiSchema;
    /** Initial form data */
    formData?: T;
    /** Callback when form is submitted */
    onSubmit?: (data: IChangeEvent<T>) => void;
    /** Callback when form data changes */
    onChange?: (data: IChangeEvent<T>) => void;
    /** Callback when form has validation errors */
    onError?: (errors: any[]) => void;
    /** Whether to show error list at the top of form */
    showErrorList?: false | 'top' | 'bottom';
    /** Whether to live validate on change */
    liveValidate?: boolean;
    /** Whether the form is disabled */
    disabled?: boolean;
    /** Whether the form is read-only */
    readonly?: boolean;
    /** Custom CSS class name */
    className?: string;
    /** Whether to show submit button */
    showSubmitButton?: boolean;
    /** Submit button text */
    submitButtonText?: string;
}

/**
 * LazyJsonSchemaForm - Lazy-loaded JSON Schema form generator
 *
 * Automatically shows loading state while RJSF loads (~300KB)
 */
declare const LazyJsonSchemaForm: React$1.ComponentType<JsonSchemaFormProps<any>>;

/**
 * LottiePlayer Types
 *
 * Type definitions for the Lottie animation player component
 */
type LottieSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'full';
type LottieSpeed = 0.5 | 1 | 1.5 | 2;
type LottieDirection = 1 | -1;
interface LottiePlayerProps {
    /**
     * Animation data (JSON object) or URL to load from
     */
    src: string | object;
    /**
     * Size preset for the player
     * @default 'md'
     */
    size?: LottieSize;
    /**
     * Custom width (overrides size preset)
     */
    width?: number | string;
    /**
     * Custom height (overrides size preset)
     */
    height?: number | string;
    /**
     * Autoplay animation
     * @default true
     */
    autoplay?: boolean;
    /**
     * Loop animation
     * @default true
     */
    loop?: boolean | number;
    /**
     * Playback speed
     * @default 1
     */
    speed?: LottieSpeed;
    /**
     * Direction (1 = forward, -1 = reverse)
     * @default 1
     */
    direction?: LottieDirection;
    /**
     * Show playback controls
     * @default false
     */
    controls?: boolean;
    /**
     * Background color
     */
    background?: string;
    /**
     * CSS class name
     */
    className?: string;
    /**
     * Show loading state
     * @default true
     */
    showLoading?: boolean;
    /**
     * Callback when animation completes
     */
    onComplete?: () => void;
    /**
     * Callback when animation loads
     */
    onLoad?: () => void;
    /**
     * Callback on error
     */
    onError?: (error: Error) => void;
}

/**
 * LazyLottiePlayer - Lazy-loaded Lottie animation player
 *
 * Automatically shows loading state while Lottie loads (~200KB)
 */
declare const LazyLottiePlayer: React$1.ComponentType<LottiePlayerProps>;

interface HybridAudioPlayerProps {
    /** Show playback controls */
    showControls?: boolean;
    /** Show frequency waveform */
    showWaveform?: boolean;
    /** Waveform visualization mode */
    waveformMode?: 'frequency' | 'static';
    /** Waveform height in pixels */
    waveformHeight?: number;
    /** Show time display */
    showTimer?: boolean;
    /** Show volume control */
    showVolume?: boolean;
    /** Show loop button */
    showLoop?: boolean;
    /** Additional CSS class */
    className?: string;
    /** Inline styles */
    style?: React.CSSProperties;
}
declare const HybridAudioPlayer: React$1.NamedExoticComponent<HybridAudioPlayerProps>;

/**
 * Audio Reactive Effects - Common utilities and types
 *
 * Provides reusable effect calculations and configurations
 */
type EffectVariant = 'glow' | 'orbs' | 'spotlight' | 'mesh';
type EffectIntensity = 'subtle' | 'medium' | 'strong';
type EffectColorScheme = 'primary' | 'vibrant' | 'cool' | 'warm';
interface AudioLevels {
    bass: number;
    mid: number;
    high: number;
    overall: number;
}
interface EffectConfig$1 {
    opacity: number;
    scale: number;
    blur: string;
}
interface EffectColors {
    colors: string[];
    hueShift: number;
}
interface EffectLayer {
    inset: number;
    opacity: number;
    scale: number;
    background: string;
    blur: string;
    animation?: string;
}
declare const INTENSITY_CONFIG: Record<EffectIntensity, EffectConfig$1>;
declare const COLOR_SCHEMES: Record<EffectColorScheme, string[]>;
/**
 * Get effect configuration from intensity setting
 */
declare function getEffectConfig(intensity: EffectIntensity): EffectConfig$1;
/**
 * Get color array from color scheme
 */
declare function getColors(colorScheme: EffectColorScheme): string[];
/**
 * Prepare colors with hue shift based on audio levels
 */
declare function prepareEffectColors(colorScheme: EffectColorScheme, levels: AudioLevels): EffectColors;
/**
 * Calculate glow layer properties
 */
declare function calculateGlowLayers(levels: AudioLevels, config: EffectConfig$1, colors: string[]): EffectLayer[];
/**
 * Calculate orb positions and properties - highly reactive
 */
declare function calculateOrbs(levels: AudioLevels, config: EffectConfig$1, colors: string[], baseSize?: number): {
    x: number;
    y: number;
    size: number;
    color: string;
    opacity: number;
    scale: number;
}[];
/**
 * Calculate mesh gradient positions - dynamic and reactive
 */
declare function calculateMeshGradients(levels: AudioLevels, config: EffectConfig$1, colors: string[]): ({
    width: string;
    height: string;
    top: string;
    right: string;
    color: string;
    opacity: number;
    scale: number;
    rotation: number;
    blur: string;
    bottom?: undefined;
    left?: undefined;
    isCenter?: undefined;
} | {
    width: string;
    height: string;
    bottom: string;
    left: string;
    color: string;
    opacity: number;
    scale: number;
    rotation: number;
    blur: string;
    top?: undefined;
    right?: undefined;
    isCenter?: undefined;
} | {
    width: string;
    height: string;
    top: string;
    left: string;
    color: string;
    opacity: number;
    scale: number;
    rotation: number;
    blur: string;
    right?: undefined;
    bottom?: undefined;
    isCenter?: undefined;
} | {
    width: string;
    height: string;
    top: string;
    left: string;
    color: string;
    opacity: number;
    scale: number;
    rotation: number;
    isCenter: boolean;
    blur: string;
    right?: undefined;
    bottom?: undefined;
})[];
/**
 * Calculate spotlight effect properties - highly reactive
 */
declare function calculateSpotlight(levels: AudioLevels, config: EffectConfig$1, colors: string[], rotation: number): {
    rotation: number;
    inset: number;
    colors: {
        color: string;
        opacity: number;
    }[];
    pulseInset: number;
    pulseOpacity: number;
    pulseScale: number;
    ringOpacity: number;
    ringScale: number;
};
/**
 * CSS for effect animations - can be injected once
 */
declare const EFFECT_ANIMATIONS = "\n  @keyframes spotlight-spin {\n    0% { transform: rotate(0deg); }\n    100% { transform: rotate(360deg); }\n  }\n\n  @keyframes orb-float-1 {\n    0%, 100% { transform: translate(-50%, -50%) translateY(0); }\n    50% { transform: translate(-50%, -50%) translateY(-15px); }\n  }\n\n  @keyframes orb-float-2 {\n    0%, 100% { transform: translate(-50%, -50%) translateX(0); }\n    50% { transform: translate(-50%, -50%) translateX(15px); }\n  }\n\n  @keyframes orb-float-3 {\n    0%, 100% { transform: translate(-50%, -50%) translate(0, 0); }\n    33% { transform: translate(-50%, -50%) translate(10px, -10px); }\n    66% { transform: translate(-50%, -50%) translate(-10px, 10px); }\n  }\n\n  @keyframes orb-float-4 {\n    0%, 100% { transform: translate(-50%, -50%) translate(0, 0); }\n    50% { transform: translate(-50%, -50%) translate(-15px, -10px); }\n  }\n\n  @keyframes mesh-float-1 {\n    0%, 100% { transform: translate(0, 0) scale(1); }\n    25% { transform: translate(-5%, 10%) scale(1.05); }\n    50% { transform: translate(5%, 5%) scale(0.95); }\n    75% { transform: translate(-3%, -5%) scale(1.02); }\n  }\n\n  @keyframes mesh-float-2 {\n    0%, 100% { transform: translate(0, 0) scale(1); }\n    33% { transform: translate(8%, -8%) scale(1.08); }\n    66% { transform: translate(-6%, 6%) scale(0.92); }\n  }\n\n  @keyframes mesh-float-3 {\n    0%, 100% { transform: translate(0, 0) scale(1); }\n    50% { transform: translate(10%, 10%) scale(1.1); }\n  }\n\n  @keyframes mesh-float-4 {\n    0%, 100% { transform: translate(0, 0) scale(1) rotate(0deg); }\n    25% { transform: translate(10%, -5%) scale(1.1) rotate(5deg); }\n    50% { transform: translate(-5%, 10%) scale(0.95) rotate(-5deg); }\n    75% { transform: translate(-10%, -10%) scale(1.05) rotate(3deg); }\n  }\n\n  @keyframes mesh-pulse {\n    0%, 100% { transform: translate(-50%, -50%) scale(1); opacity: 0.3; }\n    50% { transform: translate(-50%, -50%) scale(1.2); opacity: 0.5; }\n  }\n\n  @keyframes glow-breathe {\n    0%, 100% { opacity: 0.6; transform: scale(1); }\n    50% { opacity: 1; transform: scale(1.05); }\n  }\n\n  @keyframes glow-rotate {\n    0% { transform: rotate(0deg); }\n    100% { transform: rotate(360deg); }\n  }\n\n  @keyframes sparkle-move {\n    0% { opacity: 0; transform: scale(0.8); }\n    50% { opacity: 1; }\n    100% { opacity: 0; transform: scale(1.2); }\n  }\n";

interface AudioBusStore {
    /** ID of the currently active (playing) player, null if none */
    activeId: string | null;
    setActiveId: (id: string | null) => void;
}
declare const useAudioBusStore: zustand.UseBoundStore<zustand.StoreApi<AudioBusStore>>;
interface UseAudioBusReturn {
    /** Broadcast: this player is now playing — all others should stop */
    announce: () => void;
    /** Release: this player stopped (clears activeId if it was ours) */
    release: () => void;
}
/**
 * @param playerId  Stable unique ID for this player instance
 * @param onStop    Called when another player announces — should pause this player
 */
declare function useAudioBus(playerId: string, onStop: () => void): UseAudioBusReturn;

interface UseHybridAudioOptions {
    src: string;
    autoPlay?: boolean;
    initialVolume?: number;
    loop?: boolean;
    crossOrigin?: 'anonymous' | 'use-credentials';
    /** Set to true to opt out of global audio bus (player won't stop others and won't be stopped) */
    excludeFromBus?: boolean;
    onPlay?: () => void;
    onPause?: () => void;
    onEnded?: () => void;
    onTimeUpdate?: (time: number) => void;
    onError?: (error: Error) => void;
    onReady?: () => void;
}
interface HybridAudioState {
    isReady: boolean;
    isPlaying: boolean;
    currentTime: number;
    duration: number;
    volume: number;
    isMuted: boolean;
    isLooping: boolean;
    buffered: TimeRanges | null;
    error: Error | null;
}
interface HybridAudioControls {
    play: () => Promise<void>;
    pause: () => void;
    togglePlay: () => void;
    seek: (time: number) => void;
    seekTo: (progress: number) => void;
    skip: (seconds: number) => void;
    setVolume: (vol: number) => void;
    toggleMute: () => void;
    toggleLoop: () => void;
    setLoop: (enabled: boolean) => void;
    restart: () => void;
}
interface HybridWebAudioAPI {
    context: AudioContext | null;
    analyser: AnalyserNode | null;
    sourceNode: MediaElementAudioSourceNode | null;
}
interface UseHybridAudioReturn {
    audioRef: React.RefObject<HTMLAudioElement | null>;
    state: HybridAudioState;
    controls: HybridAudioControls;
    webAudio: HybridWebAudioAPI;
}
declare function useHybridAudio(options: UseHybridAudioOptions): UseHybridAudioReturn;

declare function useHybridAudioAnalysis(analyser: AnalyserNode | null, isPlaying: boolean): AudioLevels;

type VisualizationVariant = 'glow' | 'orbs' | 'spotlight' | 'mesh' | 'none';
type VisualizationIntensity = 'subtle' | 'medium' | 'strong';
type VisualizationColorScheme = 'primary' | 'vibrant' | 'cool' | 'warm';
interface VisualizationSettings {
    /** Enable reactive cover animation */
    enabled: boolean;
    /** Visual effect variant */
    variant: VisualizationVariant;
    /** Effect intensity */
    intensity: VisualizationIntensity;
    /** Color scheme */
    colorScheme: VisualizationColorScheme;
    /** Playback volume (0-1) */
    volume: number;
    /** Loop playback */
    isLooping: boolean;
}
interface UseVisualizationReturn {
    /** Current settings */
    settings: VisualizationSettings;
    /** Toggle visualization on/off */
    toggle: () => void;
    /** Set specific setting */
    setSetting: <K extends keyof VisualizationSettings>(key: K, value: VisualizationSettings[K]) => void;
    /** Cycle to next variant */
    nextVariant: () => void;
    /** Cycle to next intensity */
    nextIntensity: () => void;
    /** Cycle to next color scheme */
    nextColorScheme: () => void;
    /** Reset to defaults */
    reset: () => void;
}
type UseAudioVisualizationReturn = UseVisualizationReturn;
interface VisualizationProviderProps {
    children: ReactNode;
}
declare function VisualizationProvider({ children }: VisualizationProviderProps): react_jsx_runtime.JSX.Element;
declare function useVisualization(): UseVisualizationReturn;
declare const useAudioVisualization: typeof useVisualization;
declare const VARIANT_INFO: Record<VisualizationVariant, {
    label: string;
    icon: string;
}>;
declare const INTENSITY_INFO: Record<VisualizationIntensity, {
    label: string;
}>;
declare const COLOR_SCHEME_INFO: Record<VisualizationColorScheme, {
    label: string;
    preview: string;
}>;

interface HybridSimplePlayerProps {
    /** Audio source URL */
    src: string;
    /** Track title */
    title?: string;
    /** Artist name */
    artist?: string;
    /** Cover art URL or ReactNode */
    coverArt?: string | ReactNode;
    /** Cover art size */
    coverSize?: 'sm' | 'md' | 'lg';
    /** Show frequency waveform */
    showWaveform?: boolean;
    /** Waveform visualization mode */
    waveformMode?: 'frequency' | 'static';
    /** Waveform height in pixels */
    waveformHeight?: number;
    /** Show timer */
    showTimer?: boolean;
    /** Show volume control */
    showVolume?: boolean;
    /** Show loop/repeat button */
    showLoop?: boolean;
    /** Enable audio-reactive cover effects */
    reactiveCover?: boolean;
    /** Reactive effect variant */
    variant?: VisualizationVariant;
    /** Reactive effect intensity */
    intensity?: EffectIntensity;
    /** Reactive effect color scheme */
    colorScheme?: EffectColorScheme;
    /** Auto-play on load */
    autoPlay?: boolean;
    /** Loop playback */
    loop?: boolean;
    /** Initial volume (0-1) */
    initialVolume?: number;
    /** Layout direction */
    layout?: 'vertical' | 'horizontal';
    /** Additional class name */
    className?: string;
    /** Callbacks */
    onPlay?: () => void;
    onPause?: () => void;
    onEnded?: () => void;
    onError?: (error: Error) => void;
}
declare function HybridSimplePlayer(props: HybridSimplePlayerProps): react_jsx_runtime.JSX.Element;

/**
 * HybridCompactPlayer - Single-row audio player
 *
 * Designed for tight spaces: play/pause + waveform + timer.
 * No cover art, no volume slider, no skip buttons.
 *
 * @example
 * <HybridCompactPlayer src="https://example.com/audio.mp3" title="Rain & Thunder" />
 *
 * @example
 * // Lazy-loaded (preferred in app)
 * <LazyHybridCompactPlayer src={url} autoPlay />
 */

interface HybridCompactPlayerProps {
    /** Audio source URL */
    src: string;
    /** Track title (shown as tooltip / aria-label) */
    title?: string;
    /** Auto-play on load */
    autoPlay?: boolean;
    /** Loop playback */
    loop?: boolean;
    /** Initial volume (0-1) */
    initialVolume?: number;
    /** Waveform visualization mode */
    waveformMode?: 'frequency' | 'static';
    /** Show timer */
    showTimer?: boolean;
    /** Button size — 'sm' (h-6 w-6) | 'md' (h-8 w-8, default) */
    buttonSize?: 'sm' | 'md';
    /** Additional class name */
    className?: string;
    /** Callbacks */
    onPlay?: () => void;
    onPause?: () => void;
    onEnded?: () => void;
    onError?: (error: Error) => void;
}

interface HybridWaveformProps {
    /** Visualization mode */
    mode?: 'frequency' | 'static';
    /** Canvas height in pixels */
    height?: number;
    /** Bar width in pixels */
    barWidth?: number;
    /** Gap between bars in pixels */
    barGap?: number;
    /** Bar border radius */
    barRadius?: number;
    /** Color for played portion */
    progressColor?: string;
    /** Color for unplayed portion */
    waveColor?: string;
    /** Color for buffered regions indicator */
    bufferedColor?: string;
    /** Additional CSS class */
    className?: string;
    /** Callback when user seeks */
    onSeek?: (time: number) => void;
}
declare const HybridWaveform: React$1.NamedExoticComponent<HybridWaveformProps>;

interface AudioReactiveCoverProps {
    children: ReactNode;
    /** 'sm' | 'md' | 'lg' = fixed sizes; 'full' = stretch to container width (aspect-square) */
    size?: 'sm' | 'md' | 'lg' | 'full';
    variant?: EffectVariant;
    intensity?: EffectIntensity;
    colorScheme?: EffectColorScheme;
    onClick?: () => void;
    className?: string;
}
declare function AudioReactiveCover({ children, size, variant, intensity, colorScheme, onClick, className, }: AudioReactiveCoverProps): react_jsx_runtime.JSX.Element;

interface GlowEffectData {
    layers: ReturnType<typeof calculateGlowLayers>;
    hueShift: number;
    showPulseRings: boolean;
    showSparkle: boolean;
}
interface GlowEffectProps {
    data: GlowEffectData;
    colors: string[];
    isPlaying: boolean;
}
declare function GlowEffect({ data, colors, isPlaying }: GlowEffectProps): react_jsx_runtime.JSX.Element;

interface OrbsEffectProps {
    orbs: ReturnType<typeof calculateOrbs>;
    blur: string;
    isPlaying: boolean;
}
declare function OrbsEffect({ orbs, blur, isPlaying }: OrbsEffectProps): react_jsx_runtime.JSX.Element;

interface SpotlightEffectProps {
    data: ReturnType<typeof calculateSpotlight>;
    colors: string[];
    blur: string;
    isPlaying: boolean;
}
declare function SpotlightEffect({ data, colors, blur, isPlaying }: SpotlightEffectProps): react_jsx_runtime.JSX.Element;

interface MeshEffectProps {
    gradients: ReturnType<typeof calculateMeshGradients>;
    blur: string;
    isPlaying: boolean;
}
declare function MeshEffect({ gradients, isPlaying }: MeshEffectProps): react_jsx_runtime.JSX.Element;

/**
 * LazyHybridAudioPlayer - Lazy-loaded full-featured audio player
 *
 * Automatically shows loading state while WaveSurfer loads (~200KB)
 */
declare const LazyHybridAudioPlayer: React$1.ComponentType<HybridAudioPlayerProps>;
/**
 * LazyHybridSimplePlayer - Lazy-loaded simple audio player
 *
 * Automatically shows loading state while WaveSurfer loads (~200KB)
 */
declare const LazyHybridSimplePlayer: React$1.ComponentType<HybridSimplePlayerProps>;
/**
 * LazyHybridCompactPlayer - Lazy-loaded compact single-row audio player
 *
 * Use in tight spaces: play/pause + waveform + timer in one line.
 */
declare const LazyHybridCompactPlayer: React$1.ComponentType<HybridCompactPlayerProps>;

/**
 * Video source type definitions
 */
/** Simple URL source (mp4, webm, etc.) */
interface UrlSource {
    type: 'url';
    url: string;
    title?: string;
    poster?: string;
}
/** YouTube embed source */
interface YouTubeSource {
    type: 'youtube';
    /** YouTube video ID (11 characters) */
    id: string;
    title?: string;
    poster?: string;
}
/** Vimeo embed source */
interface VimeoSource {
    type: 'vimeo';
    /** Vimeo video ID */
    id: string;
    title?: string;
    poster?: string;
}
/** HLS streaming source */
interface HLSSource {
    type: 'hls';
    /** URL to .m3u8 manifest */
    url: string;
    title?: string;
    poster?: string;
}
/** DASH streaming source */
interface DASHSource {
    type: 'dash';
    /** URL to .mpd manifest */
    url: string;
    title?: string;
    poster?: string;
}
/** HTTP Range streaming source (for large files with auth) */
interface StreamSource {
    type: 'stream';
    /** Session ID for authorization */
    sessionId: string;
    /** File path on server */
    path: string;
    /** Function to generate stream URL */
    getStreamUrl: (sessionId: string, path: string) => string;
    /** MIME type for the video */
    mimeType?: string;
    title?: string;
    poster?: string;
}
/** Binary data source (ArrayBuffer) */
interface BlobSource {
    type: 'blob';
    /** Video data as ArrayBuffer */
    data: ArrayBuffer;
    /** MIME type (default: video/mp4) */
    mimeType?: string;
    title?: string;
    poster?: string;
}
/** Base64 data URL source */
interface DataUrlSource {
    type: 'data-url';
    /** Base64 encoded data URL */
    data: string;
    title?: string;
    poster?: string;
}
/** Union of all source types */
type VideoSourceUnion = UrlSource | YouTubeSource | VimeoSource | HLSSource | DASHSource | StreamSource | BlobSource | DataUrlSource;

/**
 * Player configuration types
 */

/** Player mode - determines which provider to use */
type PlayerMode = 'auto' | 'vidstack' | 'native' | 'streaming';
/** Aspect ratio options */
type AspectRatioValue = number | 'auto' | 'fill';
/** Common player settings */
interface CommonPlayerSettings {
    /** Auto-play video */
    autoPlay?: boolean;
    /** Mute video by default */
    muted?: boolean;
    /** Loop video */
    loop?: boolean;
    /** Play video inline on mobile */
    playsInline?: boolean;
    /** Show player controls */
    controls?: boolean;
    /**
     * Aspect ratio:
     * - number (e.g. 16/9): Fixed aspect ratio
     * - 'auto': Natural video aspect ratio
     * - 'fill': Fill parent container (100% width & height)
     */
    aspectRatio?: AspectRatioValue;
    /** Preload strategy */
    preload?: 'auto' | 'metadata' | 'none';
}
/** Common player events */
interface CommonPlayerEvents {
    onPlay?: () => void;
    onPause?: () => void;
    onEnded?: () => void;
    onError?: (error: string) => void;
    onLoadStart?: () => void;
    onCanPlay?: () => void;
    onTimeUpdate?: (currentTime: number, duration: number) => void;
    /** Called when buffering progress changes (buffered seconds, total duration) */
    onBufferProgress?: (buffered: number, duration: number) => void;
}
/** Error fallback render props */
interface ErrorFallbackProps {
    error: string;
    retry?: () => void;
}
/** Main VideoPlayer props */
interface VideoPlayerProps extends CommonPlayerSettings, CommonPlayerEvents {
    /** Video source configuration */
    source: VideoSourceUnion;
    /** Player mode (default: 'auto') */
    mode?: PlayerMode;
    /** Player theme (Vidstack only) */
    theme?: 'default' | 'minimal' | 'modern';
    /** Show video info below player */
    showInfo?: boolean;
    /** Container className */
    className?: string;
    /** Video element className (native/streaming only) */
    videoClassName?: string;
    /** Disable right-click context menu */
    disableContextMenu?: boolean;
    /** Show loading spinner */
    showPreloader?: boolean;
    /** Preloader timeout in ms */
    preloaderTimeout?: number;
    /** Custom error fallback UI */
    errorFallback?: React__default.ReactNode | ((props: ErrorFallbackProps) => React__default.ReactNode);
}
/** VideoPlayer ref methods */
interface VideoPlayerRef {
    /** Play video */
    play: () => Promise<void> | void;
    /** Pause video */
    pause: () => void;
    /** Toggle play/pause */
    togglePlay: () => void;
    /** Seek to time in seconds */
    seekTo: (time: number) => void;
    /** Set volume (0-1) */
    setVolume: (volume: number) => void;
    /** Toggle mute */
    toggleMute: () => void;
    /** Enter fullscreen */
    enterFullscreen: () => void;
    /** Exit fullscreen */
    exitFullscreen: () => void;
    /** Current playback time in seconds */
    readonly currentTime: number;
    /** Video duration in seconds */
    readonly duration: number;
    /** Whether video is paused */
    readonly paused: boolean;
}

/**
 * Provider-specific types
 */

/** Props passed to Vidstack provider */
interface VidstackProviderProps extends CommonPlayerSettings, CommonPlayerEvents {
    source: UrlSource | YouTubeSource | VimeoSource | HLSSource | DASHSource;
    theme?: 'default' | 'minimal' | 'modern';
    showInfo?: boolean;
    className?: string;
    errorFallback?: React__default.ReactNode | ((props: ErrorFallbackProps) => React__default.ReactNode);
}
/** Props passed to Native provider */
interface NativeProviderProps extends CommonPlayerSettings, CommonPlayerEvents {
    source: UrlSource | DataUrlSource;
    className?: string;
    videoClassName?: string;
    disableContextMenu?: boolean;
    showPreloader?: boolean;
    preloaderTimeout?: number;
}
/** Props passed to Stream provider */
interface StreamProviderProps extends CommonPlayerSettings, CommonPlayerEvents {
    source: StreamSource | BlobSource | DataUrlSource;
    className?: string;
    videoClassName?: string;
    disableContextMenu?: boolean;
    showPreloader?: boolean;
    preloaderTimeout?: number;
    errorFallback?: React__default.ReactNode | ((props: ErrorFallbackProps) => React__default.ReactNode);
}
/** Options for resolving file source */
interface ResolveFileSourceOptions {
    /** File content - can be data URL string or binary ArrayBuffer */
    content: string | ArrayBuffer | null | undefined;
    /** File path for streaming */
    path: string;
    /** MIME type of the file */
    mimeType?: string;
    /** Session ID for authenticated streaming */
    sessionId?: string | null;
    /** Load method hint - 'http_stream' enables streaming mode */
    loadMethod?: 'http_stream' | 'rpc' | 'unspecified' | 'skip' | string;
    /** Function to generate stream URL (required for streaming) */
    getStreamUrl?: (sessionId: string, path: string) => string;
    /** Optional title */
    title?: string;
    /** Optional poster */
    poster?: string;
}
interface VideoPlayerContextValue {
    /** Function to generate stream URL (for HTTP Range streaming) */
    getStreamUrl?: (sessionId: string, path: string) => string;
    /** Current session ID */
    sessionId?: string | null;
}
interface VideoPlayerProviderProps extends VideoPlayerContextValue {
    children: React__default.ReactNode;
}
/** Simplified stream source (uses context for getStreamUrl) */
interface SimpleStreamSource {
    type: 'stream';
    /** File path on server */
    path: string;
    /** Session ID (optional, uses context if not provided) */
    sessionId?: string;
    /** MIME type for the video */
    mimeType?: string;
    title?: string;
    poster?: string;
}

/**
 * LazyVideoPlayer - Lazy-loaded professional video player
 *
 * Automatically shows loading state while Vidstack loads (~150KB)
 */
declare const LazyVideoPlayer: React$1.ComponentType<VideoPlayerProps>;

type JsonTreeMode = 'full' | 'compact' | 'inline';
interface JsonTreeConfig {
    /** Maximum depth to expand automatically (default: 2) */
    maxAutoExpandDepth?: number;
    /** Maximum items in array to auto-expand (default: 10) */
    maxAutoExpandArrayItems?: number;
    /** Maximum object keys to auto-expand (default: 5) */
    maxAutoExpandObjectKeys?: number;
    /** Maximum string length before truncation (default: 200) */
    maxStringLength?: number;
    /** Collection limit for performance (default: 50) */
    collectionLimit?: number;
    /** Whether to show collection info (array length, object keys count) */
    showCollectionInfo?: boolean;
    /** Whether to show expand/collapse all buttons */
    showExpandControls?: boolean;
    /** Whether to show copy/download buttons */
    showActionButtons?: boolean;
    /** Custom CSS classes for the container */
    className?: string;
    /** Whether to preserve object key order (default: true) */
    preserveKeyOrder?: boolean;
    /** Font size for tree nodes (default: '12px' for compact/inline, '13px' for full) */
    fontSize?: string;
}
interface JsonTreeComponentProps {
    title?: string;
    data: unknown;
    /**
     * Extra top offset in px for the floating toolbar — use when your layout
     * has a non-sticky header that useNavbarHeight cannot auto-detect.
     * Adds to the auto-detected navbar height.
     */
    toolbarOffset?: number;
    /**
     * Display mode:
     * - "full" (default): With toolbar and border
     * - "compact": No toolbar, subtle styling
     * - "inline": Minimal, no border
     */
    mode?: JsonTreeMode;
    config?: JsonTreeConfig;
    /** Override for react-json-tree props */
    jsonTreeProps?: Partial<CommonExternalProps>;
}

declare const JsonTreeComponent: ({ title, data, mode, config, jsonTreeProps, }: JsonTreeComponentProps) => react_jsx_runtime.JSX.Element;

interface JsonTreeProps {
    title?: string;
    data: unknown;
    /**
     * Display mode:
     * - "full" (default): With toolbar and border
     * - "compact": No toolbar, subtle styling
     * - "inline": Minimal, no border
     */
    mode?: JsonTreeMode;
    config?: JsonTreeConfig;
    jsonTreeProps?: Partial<CommonExternalProps>;
}

/**
 * LazyJsonTree - Lazy-loaded JSON visualization tree
 *
 * Automatically shows loading state while JsonTree loads (~100KB)
 *
 * @example
 * // Full mode (with toolbar)
 * <LazyJsonTree data={obj} mode="full" />
 *
 * // Compact mode (no toolbar)
 * <LazyJsonTree data={obj} mode="compact" />
 *
 * // Inline mode (minimal, for embedding)
 * <LazyJsonTree data={obj} mode="inline" />
 */
declare const LazyJsonTree: React$1.ComponentType<JsonTreeProps>;

/**
 * ImageViewer type definitions
 */
interface ImageFile {
    /** Display name for the image */
    name: string;
    /** File path used for change detection and caching */
    path: string;
    /** Optional MIME type */
    mimeType?: string;
}
interface ImageItem {
    /** File info for this image */
    file: ImageFile;
    /** Direct image URL (use when serving from CDN/server) */
    src?: string;
    /** Raw image content — ArrayBuffer or base64/binary string (use when serving from memory) */
    content?: string | ArrayBuffer;
}
interface ImageViewerProps {
    /**
     * Gallery images array.
     * When provided, enables gallery mode with prev/next navigation.
     * Single-image mode: pass one item.
     * Each item can have `src` (URL) or `content` (ArrayBuffer/base64) or both.
     */
    images: ImageItem[];
    /**
     * Initial index to show (default: 0).
     * Useful when opening a specific image from a grid.
     */
    initialIndex?: number;
    /** Hide expand button when already in dialog */
    inDialog?: boolean;
}

/**
 * LazyImageViewer - Lazy-loaded image viewer with zoom/pan/rotate
 *
 * Automatically shows loading state while ImageViewer loads (~50KB)
 */
declare const LazyImageViewer: React$1.ComponentType<ImageViewerProps>;

/**
 * CronScheduler Types
 *
 * Unix 5-field cron format: minute hour day-of-month month day-of-week
 */
type ScheduleType = 'daily' | 'weekly' | 'monthly' | 'custom';
/** Day of week: 0 = Sunday, 1 = Monday, ..., 6 = Saturday */
type WeekDay = 0 | 1 | 2 | 3 | 4 | 5 | 6;
/** Day of month: 1-31 */
type MonthDay = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31;
interface CronSchedulerState {
    /** Current schedule type */
    type: ScheduleType;
    /** Hour (0-23) */
    hour: number;
    /** Minute (0-59) */
    minute: number;
    /** Selected week days (for weekly type) */
    weekDays: WeekDay[];
    /** Selected month days (for monthly type) */
    monthDays: MonthDay[];
    /** Raw cron expression (for custom type) */
    customCron: string;
    /** Whether current state produces valid cron */
    isValid: boolean;
}
interface CronSchedulerComputed {
    /** Generated cron expression */
    cronExpression: string;
    /** Human-readable description */
    humanDescription: string;
    /** Initial value from props (null if not provided) */
    initialValue: string | null;
}
interface CronSchedulerActions {
    /** Set schedule type */
    setType: (type: ScheduleType) => void;
    /** Set time (hour and minute) */
    setTime: (hour: number, minute: number) => void;
    /** Toggle a week day selection */
    toggleWeekDay: (day: WeekDay) => void;
    /** Set all week days at once */
    setWeekDays: (days: WeekDay[]) => void;
    /** Toggle a month day selection */
    toggleMonthDay: (day: MonthDay) => void;
    /** Set all month days at once */
    setMonthDays: (days: MonthDay[]) => void;
    /** Set custom cron expression */
    setCustomCron: (cron: string) => void;
    /** Reset to default state */
    reset: () => void;
}
interface CronSchedulerContextValue extends CronSchedulerState, CronSchedulerComputed, CronSchedulerActions {
}
interface CronSchedulerProps {
    /** Current cron expression (Unix 5-field format) */
    value?: string;
    /** Callback when schedule changes */
    onChange?: (cron: string) => void;
    /** Initial schedule type (default: 'daily') */
    defaultType?: ScheduleType;
    /** Show human-readable preview (default: true) */
    showPreview?: boolean;
    /** Show raw cron expression in preview (default: false) */
    showCronExpression?: boolean;
    /** Allow copying cron expression (default: false) */
    allowCopy?: boolean;
    /** 12h or 24h time format (default: '24h') */
    timeFormat?: '12h' | '24h';
    /** Disable all interactions */
    disabled?: boolean;
    /** Additional CSS classes */
    className?: string;
}
interface CronSchedulerProviderProps {
    children: React.ReactNode;
    value?: string;
    onChange?: (cron: string) => void;
    defaultType?: ScheduleType;
}

/**
 * LazyCronScheduler - Lazy-loaded cron expression builder
 *
 * Automatically shows loading state while CronScheduler loads (~15KB).
 * Uses createLazyComponent factory for optimal code-splitting.
 *
 * @example
 * // Basic usage
 * <LazyCronScheduler
 *   value="0 9 * * *"
 *   onChange={handleChange}
 * />
 *
 * @example
 * // With all options
 * <LazyCronScheduler
 *   value={cron}
 *   onChange={setCron}
 *   defaultType="weekly"
 *   showPreview
 *   showCronExpression
 *   allowCopy
 *   timeFormat="24h"
 * />
 */
declare const LazyCronScheduler: React$1.ComponentType<CronSchedulerProps>;

/**
 * PrettyCode Component - Dynamic Import Wrapper
 *
 * Lazy loads the heavy Prism library (~500KB) only when needed.
 * This significantly reduces the initial bundle size.
 */

interface PrettyCodeProps {
    data: string | object;
    language: Language;
    className?: string;
    mode?: 'dark' | 'light';
    inline?: boolean;
    customBg?: string;
    isCompact?: boolean;
    /** Block scroll capture until user clicks (default: true) */
    scrollIsolation?: boolean;
    /**
     * Line count above which the block starts scrolling instead of growing.
     * ``undefined`` (default) = no cap, block grows to fit. Set e.g. ``50``
     * to inline short snippets and cap long ones.
     */
    maxLines?: number;
    /**
     * Visual variant:
     *   - ``"card"`` (default) — full chrome: border, background, hover
     *     toolbar (Copy + language tag), optional internal scroll. Suits
     *     a standalone code block in documentation prose where the block
     *     is its own surface.
     *   - ``"plain"`` — chrome-less: no border, no background, no toolbar,
     *     no internal scroll. Grows to fit its content. Use when
     *     embedding inside another scroll container (e.g. the Response
     *     panel) — avoids double-scroll surfaces and lets the parent
     *     manage copy/language affordances.
     */
    variant?: 'card' | 'plain';
}
declare const PrettyCode: React__default.FC<PrettyCodeProps>;

/**
 * useLottie Hook
 *
 * Hook for loading and managing Lottie animation data
 */
interface UseLottieOptions {
    /**
     * Animation data (JSON object) or URL to load from
     */
    src: string | object;
    /**
     * Enable caching of loaded animations
     * @default true
     */
    cache?: boolean;
}
interface UseLottieReturn {
    /**
     * Loaded animation data
     */
    animationData: object | null;
    /**
     * Loading state
     */
    isLoading: boolean;
    /**
     * Error state
     */
    error: Error | null;
    /**
     * Retry loading the animation
     */
    retry: () => void;
}
/**
 * Hook for loading Lottie animations from URLs or objects
 *
 * Features:
 * - Loads animations from URLs or accepts animation objects directly
 * - Caching support to prevent re-fetching the same animation
 * - Error handling with retry capability
 * - Loading states
 *
 * Usage:
 * ```tsx
 * const { animationData, isLoading, error, retry } = useLottie({
 *   src: 'https://example.com/animation.json'
 * });
 *
 * if (isLoading) return <div>Loading...</div>;
 * if (error) return <div>Error: {error.message} <button onClick={retry}>Retry</button></div>;
 * if (!animationData) return null;
 *
 * return <LottiePlayer animationData={animationData} />;
 * ```
 */
declare function useLottie(options: UseLottieOptions): UseLottieReturn;

/**
 * LottiePlayer component wrapper with dynamic import
 *
 * This component automatically handles code splitting and lazy loading
 * of the Lottie player to optimize bundle size.
 *
 * Usage:
 * ```tsx
 * import { LottiePlayer } from '@djangocfg/ui-core/tools';
 *
 * <LottiePlayer
 *   src="https://example.com/animation.json"
 *   size="md"
 *   autoplay
 *   loop
 * />
 * ```
 */
declare function LottiePlayer(props: LottiePlayerProps): react_jsx_runtime.JSX.Element;

/**
 * JSON Schema Form Component
 *
 * A fully-featured form generator that creates forms from JSON Schema.
 * Built on top of react-jsonschema-form with custom widgets and templates
 * using @djangocfg/ui components.
 *
 * @example
 * ```tsx
 * const schema = {
 *   type: 'object',
 *   required: ['name'],
 *   properties: {
 *     name: { type: 'string', title: 'Name' },
 *     age: { type: 'number', title: 'Age' },
 *     active: { type: 'boolean', title: 'Active' }
 *   }
 * };
 *
 * <JsonSchemaForm
 *   schema={schema}
 *   onSubmit={(data) => console.log(data.formData)}
 * />
 * ```
 */
declare function JsonSchemaForm<T = any>(props: JsonSchemaFormProps<T>): react_jsx_runtime.JSX.Element;

/**
 * Text input widget for JSON Schema Form
 * Handles string fields with optional textarea for multiline
 */
declare function TextWidget(props: WidgetProps): react_jsx_runtime.JSX.Element;

/**
 * Number input widget for JSON Schema Form
 * Handles integer and number fields
 */
declare function NumberWidget(props: WidgetProps): react_jsx_runtime.JSX.Element;

/**
 * Checkbox widget for JSON Schema Form
 * Handles boolean fields
 */
declare function CheckboxWidget(props: WidgetProps): react_jsx_runtime.JSX.Element;

/**
 * Select dropdown widget for JSON Schema Form
 * Handles enum fields
 */
declare function SelectWidget(props: WidgetProps): react_jsx_runtime.JSX.Element;

/**
 * Switch toggle widget for JSON Schema Form
 * Alternative boolean input
 */
declare function SwitchWidget(props: WidgetProps): react_jsx_runtime.JSX.Element;

/**
 * Color input widget for JSON Schema Form
 * Supports HSL format (h s% l%) and HEX format
 * Click on color box to open native color picker directly
 */
declare function ColorWidget(props: WidgetProps): react_jsx_runtime.JSX.Element;

/**
 * Slider widget for JSON Schema Form
 *
 * Supports:
 * - number/integer types
 * - min/max from schema
 * - step from schema or options
 * - unit suffix (e.g., "rem", "px", "%")
 * - optional text input for precise values
 *
 * Usage in uiSchema:
 * ```json
 * {
 *   "radius": {
 *     "ui:widget": "slider",
 *     "ui:options": {
 *       "unit": "rem",
 *       "showInput": true,
 *       "step": 0.125
 *     }
 *   }
 * }
 * ```
 */
declare function SliderWidget(props: WidgetProps): react_jsx_runtime.JSX.Element;

/**
 * Field template for JSON Schema Form
 * Controls the layout and styling of individual form fields
 */
declare function FieldTemplate(props: FieldTemplateProps): react_jsx_runtime.JSX.Element;

/**
 * Object field template for JSON Schema Form
 *
 * Supports:
 * - Collapsible groups via ui:collapsible option
 * - Grid layout via ui:grid option
 * - Custom styling via ui:className
 *
 * Usage in uiSchema:
 * ```json
 * {
 *   "colors": {
 *     "ui:collapsible": true,
 *     "ui:collapsed": false,
 *     "ui:grid": 2
 *   }
 * }
 * ```
 */
declare function ObjectFieldTemplate(props: ObjectFieldTemplateProps): react_jsx_runtime.JSX.Element;

/**
 * Array field template for JSON Schema Form
 * Renders array items with add/remove controls
 *
 * NOTE: In RJSF v6, `items` is an array of ReactElement (already rendered),
 * NOT an array of objects with {children, hasRemove, etc.}.
 * The actual rendering of each item (including remove buttons) is handled
 * by ArrayFieldItemTemplate.
 */
declare function ArrayFieldTemplate(props: ArrayFieldTemplateProps): react_jsx_runtime.JSX.Element;

/**
 * Array field item template for JSON Schema Form
 * Renders individual array items with proper styling and action buttons
 *
 * In RJSF v6, this template is responsible for rendering each item in an array,
 * including the item content (children) and the action buttons (remove, move up/down, copy).
 */
declare function ArrayFieldItemTemplate(props: ArrayFieldItemTemplateProps): react_jsx_runtime.JSX.Element;

/**
 * Error list template for JSON Schema Form
 * Displays validation errors at the top of the form
 */
declare function ErrorListTemplate(props: ErrorListProps): react_jsx_runtime.JSX.Element;

/**
 * Base input template for JSON Schema Form
 *
 * This template is CRITICAL for rendering primitive types (string, number)
 * inside arrays. Without it, array items with primitive types will render
 * as empty containers.
 *
 * RJSF uses this template for:
 * - Array items with primitive types (e.g., array of strings)
 * - Fields without explicit widget mapping
 * - All text-based widgets internally
 *
 * @see https://rjsf-team.github.io/react-jsonschema-form/docs/advanced-customization/custom-templates/#baseinputtemplate
 */
declare function BaseInputTemplate(props: WidgetProps): react_jsx_runtime.JSX.Element;

/**
 * Utility functions for JSON Schema Form
 */
/**
 * Safely validates and normalizes JSON Schema
 * Ensures schema is valid before rendering
 */
declare function validateSchema(schema: any): RJSFSchema | null;
/**
 * Safely normalizes form data
 * Removes undefined values and ensures data structure matches schema
 */
declare function normalizeFormData<T = any>(formData: any, schema: RJSFSchema): T;
/**
 * Merges schema defaults with form data
 */
declare function mergeDefaults(formData: any, schema: RJSFSchema): any;
/**
 * Safely parses JSON string with error handling
 */
declare function safeJsonParse<T = any>(jsonString: string, fallback: T): T;
/**
 * Safely stringifies object to JSON
 */
declare function safeJsonStringify(obj: any, pretty?: boolean): string;
/**
 * Checks if schema has required fields
 */
declare function hasRequiredFields(schema: RJSFSchema): boolean;
/**
 * Gets all required field paths from schema
 */
declare function getRequiredFields(schema: RJSFSchema, prefix?: string): string[];
/**
 * Validates form data against required fields
 */
declare function validateRequiredFields(formData: any, schema: RJSFSchema): {
    valid: boolean;
    missing: string[];
};

interface PlaygroundProps {
    config: PlaygroundConfig;
}
declare const Playground: React__default.FC<PlaygroundProps>;

/**
 * VideoPlayer - Unified Video Player Component
 *
 * Supports multiple modes:
 * - vidstack: Full-featured player (YouTube, Vimeo, HLS, DASH)
 * - native: Lightweight HTML5 player
 * - streaming: HTTP Range streaming with auth / Blob sources
 *
 * @example
 * // YouTube video
 * <VideoPlayer source={{ type: 'youtube', id: 'dQw4w9WgXcQ' }} />
 *
 * @example
 * // HLS stream
 * <VideoPlayer source={{ type: 'hls', url: 'https://example.com/video.m3u8' }} />
 *
 * @example
 * // HTTP Range streaming with auth (full source)
 * <VideoPlayer
 *   source={{
 *     type: 'stream',
 *     sessionId: 'abc123',
 *     path: '/videos/movie.mp4',
 *     getStreamUrl: (id, path) => `/api/stream/${id}?path=${path}&token=${token}`
 *   }}
 * />
 *
 * @example
 * // HTTP Range streaming (simplified, using VideoPlayerProvider context)
 * <VideoPlayerProvider sessionId={sessionId} getStreamUrl={getStreamUrl}>
 *   <VideoPlayer source={{ type: 'stream', path: '/videos/movie.mp4' }} />
 * </VideoPlayerProvider>
 *
 * @example
 * // Blob/ArrayBuffer
 * <VideoPlayer source={{ type: 'blob', data: arrayBuffer, mimeType: 'video/mp4' }} />
 */

declare const VideoPlayer: React__default.ForwardRefExoticComponent<VideoPlayerProps & {
    source: VideoSourceUnion | SimpleStreamSource;
} & React__default.RefAttributes<VideoPlayerRef>>;

interface VideoControlsProps {
    player: React__default.RefObject<MediaPlayerInstance | null>;
    className?: string;
}
declare function VideoControls({ player, className }: VideoControlsProps): react_jsx_runtime.JSX.Element;

interface VideoErrorFallbackProps extends ErrorFallbackProps {
    /** URL for download button (if provided, shows download button) */
    downloadUrl?: string;
    /** Filename for download */
    downloadFilename?: string;
    /** File size to display */
    fileSize?: string;
    /** Show retry button */
    showRetry?: boolean;
    /** Custom className */
    className?: string;
    /** Custom icon */
    icon?: React__default.ReactNode;
    /** Custom title (defaults to error message) */
    title?: string;
    /** Custom description */
    description?: string;
}
/**
 * Pre-built error fallback component for VideoPlayer
 *
 * @example
 * // Basic usage
 * <VideoPlayer
 *   source={source}
 *   errorFallback={(props) => (
 *     <VideoErrorFallback
 *       {...props}
 *       downloadUrl={getDownloadUrl()}
 *       downloadFilename="video.mp4"
 *     />
 *   )}
 * />
 *
 * @example
 * // With file size
 * <VideoErrorFallback
 *   error="Failed to load video"
 *   downloadUrl="/api/download/video.mp4"
 *   fileSize="125 MB"
 *   showRetry
 *   retry={() => reloadVideo()}
 * />
 */
declare function VideoErrorFallback({ error, retry, downloadUrl, downloadFilename, fileSize, showRetry, className, icon, title, description, }: VideoErrorFallbackProps): react_jsx_runtime.JSX.Element;
interface CreateVideoErrorFallbackOptions {
    /** Function to get download URL from source */
    getDownloadUrl?: (source: unknown) => string | undefined;
    /** Function to get filename from source */
    getFilename?: (source: unknown) => string | undefined;
    /** Function to get file size from source */
    getFileSize?: (source: unknown) => string | undefined;
    /** Show retry button */
    showRetry?: boolean;
}
/**
 * Factory to create error fallback function for VideoPlayer
 *
 * @example
 * const errorFallback = createVideoErrorFallback({
 *   getDownloadUrl: (source) => source.downloadUrl,
 *   getFilename: (source) => source.filename,
 *   showRetry: true,
 * });
 *
 * <VideoPlayer source={source} errorFallback={errorFallback} />
 */
declare function createVideoErrorFallback(options: CreateVideoErrorFallbackOptions): (props: ErrorFallbackProps, source?: unknown) => React__default.ReactNode;

/**
 * VidstackProvider - Full-featured video player using Vidstack
 * Supports YouTube, Vimeo, HLS, DASH, and direct URLs
 */

declare const VidstackProvider: React__default.ForwardRefExoticComponent<VidstackProviderProps & React__default.RefAttributes<VideoPlayerRef>>;

/**
 * NativeProvider - Lightweight native HTML5 video player
 * For demo videos, background videos, autoplay loop muted scenarios
 */

declare const NativeProvider: React__default.ForwardRefExoticComponent<NativeProviderProps & React__default.RefAttributes<VideoPlayerRef>>;

/**
 * StreamProvider - HTTP Range streaming and Blob video player
 * Supports:
 * - HTTP Range requests with authorization (for large files)
 * - Blob/ArrayBuffer sources
 * - Data URL sources
 * - Fill parent container mode
 * - Custom error fallback
 */

declare const StreamProvider: React__default.ForwardRefExoticComponent<StreamProviderProps & React__default.RefAttributes<VideoPlayerRef>>;

/**
 * Provider for VideoPlayer streaming configuration
 *
 * @example
 * // In your app layout or FileWorkspace
 * <VideoPlayerProvider
 *   sessionId={sessionId}
 *   getStreamUrl={terminalClient.terminal_media.streamStreamRetrieveUrl}
 * >
 *   <VideoPlayer source={{ type: 'stream', path: '/video.mp4' }} />
 * </VideoPlayerProvider>
 */
declare function VideoPlayerProvider({ children, getStreamUrl, sessionId, }: VideoPlayerProviderProps): react_jsx_runtime.JSX.Element;
/**
 * Hook to access VideoPlayer context
 */
declare function useVideoPlayerContext(): VideoPlayerContextValue | null;

/**
 * Video source and player mode resolvers
 */

/**
 * Determine which provider to use based on source type
 */
declare function resolvePlayerMode(source: VideoSourceUnion, mode?: PlayerMode): 'vidstack' | 'native' | 'streaming';
/**
 * Check if source is a simplified stream source (without getStreamUrl)
 */
declare function isSimpleStreamSource(source: VideoSourceUnion | SimpleStreamSource | undefined | null): source is SimpleStreamSource;
/**
 * Resolve simplified stream source to full stream source using context
 */
declare function resolveStreamSource(source: SimpleStreamSource, context: VideoPlayerContextValue | null): StreamSource | null;

/**
 * File source resolution utilities
 */

/**
 * Resolve file content to VideoSourceUnion
 * Useful for FileWorkspace/file manager integrations
 *
 * @example
 * const source = resolveFileSource({
 *   content: file.content,
 *   path: file.path,
 *   mimeType: file.mimeType,
 *   sessionId: sessionId,
 *   loadMethod: file.loadMethod,
 *   getStreamUrl: terminalClient.terminal_media.streamStreamRetrieveUrl
 * });
 *
 * <VideoPlayer source={source} />
 */
declare function resolveFileSource(options: ResolveFileSourceOptions): VideoSourceUnion | null;

interface HybridAudioContextValue {
    state: HybridAudioState;
    controls: HybridAudioControls;
    webAudio: HybridWebAudioAPI;
    audioLevels: AudioLevels;
    audioRef: React.RefObject<HTMLAudioElement | null>;
}
interface HybridAudioProviderProps extends UseHybridAudioOptions {
    children: ReactNode;
}
declare function HybridAudioProvider({ children, ...options }: HybridAudioProviderProps): react_jsx_runtime.JSX.Element;
/**
 * Access full hybrid audio context
 */
declare function useHybridAudioContext(): HybridAudioContextValue;
/**
 * Access audio state only (read-only)
 */
declare function useHybridAudioState(): HybridAudioState;
/**
 * Access audio controls only (no state re-renders)
 */
declare function useHybridAudioControls(): HybridAudioControls;
/**
 * Access audio levels for reactive effects
 */
declare function useHybridAudioLevels(): AudioLevels;
/**
 * Access Web Audio API for custom visualizations
 */
declare function useHybridWebAudio(): HybridWebAudioAPI;

/**
 * AudioPlayer types
 */
interface EqualizerOptions {
    barCount?: number;
    height?: number;
    gap?: number;
    showPeaks?: boolean;
    barColor?: string;
    peakColor?: string;
}

/**
 * formatTime - Format seconds to mm:ss string
 */
declare function formatTime(seconds: number): string;

declare function ImageViewer({ images, initialIndex, inDialog, }: ImageViewerProps): react_jsx_runtime.JSX.Element;

declare function CronSchedulerProvider({ children, value, onChange, defaultType, }: CronSchedulerProviderProps): react_jsx_runtime.JSX.Element;
declare function useCronSchedulerContext(): CronSchedulerContextValue;

/**
 * Hook for schedule type selection
 * Re-renders only when type changes
 */
declare function useCronType(): {
    type: ScheduleType;
    setType: (type: ScheduleType) => void;
};
/**
 * Hook for time selection
 * Re-renders only when hour/minute changes
 */
declare function useCronTime(): {
    hour: number;
    minute: number;
    setTime: (hour: number, minute: number) => void;
};
/**
 * Hook for week days selection
 * Re-renders only when weekDays changes
 */
declare function useCronWeekDays(): {
    weekDays: WeekDay[];
    toggleWeekDay: (day: WeekDay) => void;
    setWeekDays: (days: WeekDay[]) => void;
};
/**
 * Hook for month days selection
 * Re-renders only when monthDays changes
 */
declare function useCronMonthDays(): {
    monthDays: MonthDay[];
    toggleMonthDay: (day: MonthDay) => void;
    setMonthDays: (days: MonthDay[]) => void;
};
/**
 * Hook for custom cron input
 * Re-renders only when customCron/isValid changes
 */
declare function useCronCustom(): {
    customCron: string;
    isValid: boolean;
    setCustomCron: (cron: string) => void;
};
/**
 * Hook for preview display
 * Re-renders only when computed values change
 */
declare function useCronPreview(): {
    cronExpression: string;
    humanDescription: string;
    isValid: boolean;
    initialValue: string;
};
/**
 * Full context access
 * Use sparingly - causes re-render on any state change
 */
declare function useCronScheduler(): CronSchedulerContextValue;

/**
 * Cron Builder
 *
 * Converts CronSchedulerState to Unix 5-field cron expression
 * Format: minute hour day-of-month month day-of-week
 */

/**
 * Builds Unix 5-field cron expression from state
 *
 * @example
 * // Daily at 9:00
 * buildCron({ type: 'daily', hour: 9, minute: 0, ... }) // '0 9 * * *'
 *
 * // Weekly on Mon, Wed, Fri at 14:30
 * buildCron({ type: 'weekly', hour: 14, minute: 30, weekDays: [1, 3, 5], ... }) // '30 14 * * 1,3,5'
 *
 * // Monthly on 1st and 15th at 0:00
 * buildCron({ type: 'monthly', hour: 0, minute: 0, monthDays: [1, 15], ... }) // '0 0 1,15 * *'
 */
declare function buildCron(state: CronSchedulerState): string;

/**
 * Cron Parser
 *
 * Parses Unix 5-field cron expression into CronSchedulerState
 * Format: minute hour day-of-month month day-of-week
 */

/**
 * Parses Unix 5-field cron expression into state
 *
 * @param cron - Cron expression to parse
 * @returns Parsed state or null if invalid
 *
 * @example
 * parseCron('0 9 * * *')
 * // { type: 'daily', hour: 9, minute: 0, ... }
 *
 * parseCron('30 14 * * 1,3,5')
 * // { type: 'weekly', hour: 14, minute: 30, weekDays: [1, 3, 5], ... }
 */
declare function parseCron(cron: string): CronSchedulerState | null;
/**
 * Validates cron expression syntax
 */
declare function isValidCron(cron: string): boolean;

/**
 * Cron Humanize
 *
 * Converts cron expressions to human-readable descriptions
 */
/**
 * Converts cron expression to human-readable description
 *
 * Examples:
 * - humanizeCron('0 9 * * *') returns "Every day at 09:00"
 * - humanizeCron('30 14 * * 1,3,5') returns "Mon, Wed, Fri at 14:30"
 * - humanizeCron('0 0 1 * *') returns "1st of every month at 00:00"
 */
declare function humanizeCron(cron: string): string;

interface ScheduleTypeSelectorProps {
    disabled?: boolean;
    className?: string;
}
declare function ScheduleTypeSelector({ disabled, className, }: ScheduleTypeSelectorProps): react_jsx_runtime.JSX.Element;

interface TimeSelectorProps {
    format?: '12h' | '24h';
    disabled?: boolean;
    className?: string;
}
declare function TimeSelector({ format, disabled, className, }: TimeSelectorProps): react_jsx_runtime.JSX.Element;

interface DayChipsProps {
    disabled?: boolean;
    showPresets?: boolean;
    className?: string;
}
declare function DayChips({ disabled, showPresets, className, }: DayChipsProps): react_jsx_runtime.JSX.Element;

interface MonthDayGridProps {
    disabled?: boolean;
    showPresets?: boolean;
    className?: string;
}
declare function MonthDayGrid({ disabled, showPresets, className, }: MonthDayGridProps): react_jsx_runtime.JSX.Element;

interface CustomInputProps {
    disabled?: boolean;
    className?: string;
}
declare function CustomInput({ disabled, className }: CustomInputProps): react_jsx_runtime.JSX.Element;

interface SchedulePreviewProps {
    /** Show raw cron expression (default: true) */
    showCronExpression?: boolean;
    /** Enable copy to clipboard */
    allowCopy?: boolean;
    /** Show initial value when changed (default: true) */
    showInitialValue?: boolean;
    /** Additional CSS classes */
    className?: string;
}
declare function SchedulePreview({ showCronExpression, allowCopy, showInitialValue, className, }: SchedulePreviewProps): react_jsx_runtime.JSX.Element;

/**
 * CronScheduler with Suspense wrapper
 */
declare function CronScheduler(props: CronSchedulerProps): react_jsx_runtime.JSX.Element;

interface EditorFile {
    /** Unique file path */
    path: string;
    /** File content */
    content: string;
    /** Detected or specified language */
    language: string;
    /** Whether file has unsaved changes */
    isDirty: boolean;
    /** Monaco model reference */
    model?: monaco.editor.ITextModel;
}
interface EditorOptions {
    /** Editor theme: 'vs' | 'vs-dark' | 'hc-black' | custom */
    theme?: string;
    /** Font size in pixels */
    fontSize?: number;
    /** Font family */
    fontFamily?: string;
    /** Tab size */
    tabSize?: number;
    /** Insert spaces instead of tabs */
    insertSpaces?: boolean;
    /** Word wrap mode */
    wordWrap?: 'off' | 'on' | 'wordWrapColumn' | 'bounded';
    /** Show minimap */
    minimap?: boolean;
    /** Show line numbers */
    lineNumbers?: 'on' | 'off' | 'relative' | 'interval';
    /** Read-only mode */
    readOnly?: boolean;
}
interface EditorProps {
    /** File content */
    value?: string;
    /** Programming language for syntax highlighting */
    language?: string;
    /** Called when content changes */
    onChange?: (value: string) => void;
    /** Called when editor is mounted */
    onMount?: (editor: monaco.editor.IStandaloneCodeEditor) => void;
    /** Editor options */
    options?: EditorOptions;
    /** CSS class name */
    className?: string;
    /** Height — fixed px, CSS string, or '100%' (default: '100%'). Ignored when autoHeight=true */
    height?: string | number;
    /** Width (default: '100%') */
    width?: string | number;
    /** Auto-resize height to fit content. Editor grows/shrinks with content lines */
    autoHeight?: boolean;
    /** Min height in px when autoHeight is enabled (default: 100) */
    minHeight?: number;
    /** Max height in px when autoHeight is enabled (default: 600) */
    maxHeight?: number;
}
interface DiffEditorProps {
    /** Original content (left side) */
    original: string;
    /** Modified content (right side) */
    modified: string;
    /** Programming language */
    language?: string;
    /** Editor options */
    options?: EditorOptions;
    /** CSS class name */
    className?: string;
    /** Height (default: '100%') */
    height?: string | number;
}
interface EditorContextValue {
    /** Currently open files */
    openFiles: EditorFile[];
    /** Currently active file */
    activeFile: EditorFile | null;
    /** Monaco instance (null during SSR) */
    monaco: typeof monaco | null;
    /** Editor instance */
    editor: monaco.editor.IStandaloneCodeEditor | null;
    /** Whether editor is ready */
    isReady: boolean;
    openFile: (path: string, content: string, language?: string) => void;
    closeFile: (path: string) => void;
    setActiveFile: (path: string) => void;
    updateContent: (path: string, content: string) => void;
    saveFile: (path: string) => Promise<void>;
    isDirty: (path: string) => boolean;
    getContent: (path: string) => string | null;
    getFile: (path: string) => EditorFile | null;
}
interface UseEditorReturn {
    /** Editor instance */
    editor: monaco.editor.IStandaloneCodeEditor | null;
    /** Whether editor is mounted and ready */
    isReady: boolean;
    /** Set editor reference */
    setEditor: (editor: monaco.editor.IStandaloneCodeEditor | null) => void;
}
interface UseMonacoReturn {
    /** Monaco namespace */
    monaco: typeof monaco | null;
    /** Whether Monaco is loaded */
    isLoading: boolean;
    /** Loading error if any */
    error: Error | null;
}

interface EditorRef {
    /** Get editor instance */
    getEditor: () => monaco.editor.IStandaloneCodeEditor | null;
    /** Get current value */
    getValue: () => string;
    /** Set value */
    setValue: (value: string) => void;
    /** Focus editor */
    focus: () => void;
}
/**
 * Monaco Editor Component
 *
 * A React wrapper around Monaco Editor with full TypeScript support.
 *
 * @example
 * ```tsx
 * <Editor
 *   value={code}
 *   language="typescript"
 *   onChange={(value) => setCode(value)}
 *   options={{ fontSize: 14, minimap: false }}
 * />
 * ```
 */
declare const Editor: React$1.ForwardRefExoticComponent<EditorProps & React$1.RefAttributes<EditorRef>>;

/**
 * Monaco Diff Editor Component
 *
 * Side-by-side or inline diff view for comparing two versions of content.
 *
 * @example
 * ```tsx
 * <DiffEditor
 *   original={originalCode}
 *   modified={modifiedCode}
 *   language="typescript"
 * />
 * ```
 */
declare function DiffEditor({ original, modified, language, options, className, height, }: DiffEditorProps): react_jsx_runtime.JSX.Element;

/**
 * Hook to access editor context
 * Must be used within EditorProvider
 */
declare function useEditorContext(): EditorContextValue;
interface EditorProviderProps {
    children: React.ReactNode;
    /** Callback when file save is requested */
    onSave?: (path: string, content: string) => Promise<void>;
}
/**
 * Editor Context Provider
 *
 * Manages multiple open files, active file state, and editor instance.
 *
 * @example
 * ```tsx
 * <EditorProvider onSave={handleSave}>
 *   <EditorTabs />
 *   <Editor />
 * </EditorProvider>
 * ```
 */
declare function EditorProvider({ children, onSave }: EditorProviderProps): react_jsx_runtime.JSX.Element;

/**
 * Hook to load and access Monaco Editor instance
 *
 * Handles:
 * - Dynamic import of Monaco (client-side only)
 * - Web worker configuration
 * - Loading state management
 *
 * @example
 * ```tsx
 * const { monaco, isLoading, error } = useMonaco();
 *
 * if (isLoading) return <Spinner />;
 * if (error) return <Error message={error.message} />;
 *
 * // Use monaco API
 * monaco.editor.create(...)
 * ```
 */
declare function useMonaco(): UseMonacoReturn;

/**
 * Hook to manage editor instance reference
 *
 * @example
 * ```tsx
 * const { editor, isReady, setEditor } = useEditor();
 *
 * // Pass setEditor to Editor component's onMount
 * <Editor onMount={setEditor} />
 *
 * // Use editor when ready
 * if (isReady) {
 *   editor.getModel()?.getValue();
 * }
 * ```
 */
declare function useEditor(): UseEditorReturn;

/**
 * Hook to detect language from filename
 *
 * @param filename - File name or path
 * @returns Monaco language ID
 *
 * @example
 * ```tsx
 * const language = useLanguage('app.tsx');
 * // Returns: 'typescript'
 *
 * const language2 = useLanguage('/path/to/Dockerfile');
 * // Returns: 'dockerfile'
 * ```
 */
declare function useLanguage(filename: string | undefined): string;

/** Item that can be mentioned via @ trigger */
interface MentionItem {
    id: string;
    label: string;
    description?: string;
    thumbnail?: string;
}
/**
 * Attributes available when rendering a mention to markdown.
 *
 * Same shape Tiptap stores on the `mention` node — `id` is the stable
 * identifier the suggestion popover injected, `label` is the human text
 * shown to the user. Either field may be empty if the upstream config
 * never populated it; renderers should fall back accordingly.
 */
interface MentionAttrs {
    id: string;
    label: string;
}
/**
 * Function that converts a mention node into its markdown serialization.
 *
 * The returned string is what `@tiptap/markdown` writes into the markdown
 * output of `MarkdownEditor.getMarkdown()`.
 */
type MentionMarkdownRenderer = (attrs: MentionAttrs) => string;
/** Mention configuration */
interface MentionConfig {
    /** Trigger character (default: '@') */
    trigger?: string;
    /** Available items */
    items: MentionItem[];
    /** Max dropdown items (default: 5) */
    maxItems?: number;
    /**
     * Custom serializer for mentions when `MarkdownEditor.getMarkdown()` runs.
     *
     * Defaults to `mentionPresets.plainAt` which yields `@<label>` (or `@<id>`
     * when `label` is missing). Use one of `mentionPresets`, or supply your
     * own function for full control over how mentions appear in the output
     * markdown string.
     *
     * Note: this only affects the *markdown* output. `editor.getText()` and
     * the rendered DOM still go through `renderText` (`@<label>` by default).
     */
    renderMarkdown?: MentionMarkdownRenderer;
}

interface MarkdownEditorProps {
    value: string;
    onChange: (value: string) => void;
    placeholder?: string;
    minHeight?: number;
    className?: string;
    disabled?: boolean;
    showToolbar?: boolean;
    /**
     * `@`-mention autocomplete config.
     *
     * IMPORTANT: Tiptap's `useEditor` initialises the editor exactly once.
     * The `Mention` extension is only registered when `mentions` is truthy
     * on the FIRST render — handing in a real config later (e.g. after an
     * async items fetch) silently does nothing, and typing `@` will not
     * open the popover.
     *
     * If you want mentions even with async-loaded items, pass
     * `{ items: [] }` from the very first render and update the array
     * when data arrives. Either keep the `MentionConfig` object identity
     * stable across renders and mutate `items` in place (the suggestion
     * plugin captures the config by closure and reads `items` on each
     * query), or accept that swapping the whole object reference is a
     * no-op for the live editor.
     */
    mentions?: MentionConfig;
    /** Called when mentioned IDs change */
    onMentionIdsChange?: (ids: string[]) => void;
}
declare function MarkdownEditor({ value, onChange, placeholder, minHeight, className, disabled, showToolbar, mentions, onMentionIdsChange, }: MarkdownEditorProps): react_jsx_runtime.JSX.Element;

/**
 * Built-in serializers for the `MentionConfig.renderMarkdown` callback.
 *
 * Pick one based on what consumes the markdown:
 *
 * - LLM / chat composer    → `plainAt`     (the default)
 * - Plain text export      → `plainLabel`
 * - Web app with deep-link → `markdownLink(baseUrl)`
 * - Notion / Linear-style  → `customUri(scheme, kind)`
 * - Slack-style id refs    → `slackStyle`
 * - HTML-allowing renderer → `htmlSpan(className?)`
 *
 * Or pass a custom function — the type is just `(attrs) => string`.
 */
declare const mentionPresets: {
    /** "@Label" — default, ideal for chat where LLMs read the text. */
    plainAt: MentionMarkdownRenderer;
    /** "Label" — bare label, no @ prefix. */
    plainLabel: MentionMarkdownRenderer;
    /** "[@Label](baseUrl/id)" — clickable markdown link. */
    markdownLink: (baseUrl: string) => MentionMarkdownRenderer;
    /** "@[Label](scheme://kind/id)" — Notion / Linear-style custom URI. */
    customUri: (scheme: string, kind: string) => MentionMarkdownRenderer;
    /** "<@id>" — Slack-style id-only reference (label dropped — receivers resolve it). */
    slackStyle: MentionMarkdownRenderer;
    /** Inline HTML span — for products that consume markdown with raw HTML allowed. */
    htmlSpan: (className?: string) => MentionMarkdownRenderer;
};

interface BlobUrlEntry {
    url: string;
    refCount: number;
    createdAt: number;
}
interface ImageDimensions {
    width: number;
    height: number;
}
interface VideoMetadata {
    duration: number;
    width: number;
    height: number;
    codec?: string;
}
interface EffectConfig {
    opacity: number;
    scale: number;
    blur: string;
}
/** Video player settings (persisted) */
interface VideoPlayerSettings {
    volume: number;
    isLooping: boolean;
}
interface MediaCacheState {
    blobUrls: Map<string, BlobUrlEntry>;
    imageDimensions: Map<string, ImageDimensions>;
    audioPlaybackPositions: Map<string, number>;
    audioEffectConfigs: Map<string, EffectConfig>;
    videoStreamUrls: Map<string, {
        url: string;
        timestamp: number;
    }>;
    videoPosterUrls: Map<string, string>;
    videoPlaybackPositions: Map<string, number>;
    videoMetadata: Map<string, VideoMetadata>;
    videoPlayerSettings: VideoPlayerSettings;
}
interface MediaCacheActions {
    getOrCreateBlobUrl: (key: string, content: ArrayBuffer, mimeType: string) => string;
    releaseBlobUrl: (key: string) => void;
    hasBlobUrl: (key: string) => boolean;
    cacheDimensions: (src: string, dims: ImageDimensions) => void;
    getDimensions: (src: string) => ImageDimensions | null;
    saveAudioPosition: (uri: string, time: number) => void;
    getAudioPosition: (uri: string) => number | null;
    getEffectConfig: (key: string) => EffectConfig | null;
    cacheEffectConfig: (key: string, config: EffectConfig) => void;
    getOrCreateStreamUrl: (sessionId: string, path: string, generator: (sessionId: string, path: string) => string) => string;
    getPosterUrl: (title: string) => string | null;
    cachePosterUrl: (title: string, url: string) => void;
    saveVideoPosition: (key: string, time: number) => void;
    getVideoPosition: (key: string) => number | null;
    cacheVideoMetadata: (url: string, meta: VideoMetadata) => void;
    getVideoMetadata: (url: string) => VideoMetadata | null;
    invalidateSession: (sessionId: string) => void;
    getVideoPlayerSettings: () => VideoPlayerSettings;
    saveVideoPlayerSettings: (settings: Partial<VideoPlayerSettings>) => void;
    clearCache: () => void;
    getCacheStats: () => {
        blobUrls: number;
        dimensions: number;
        audioPositions: number;
        videoPositions: number;
    };
}
type MediaCacheStore = MediaCacheState & MediaCacheActions;
declare const useMediaCacheStore: zustand.UseBoundStore<Omit<Omit<zustand.StoreApi<MediaCacheStore>, "setState" | "devtools"> & {
    setState(partial: MediaCacheStore | Partial<MediaCacheStore> | ((state: MediaCacheStore) => MediaCacheStore | Partial<MediaCacheStore>), replace?: false, action?: string | {
        [x: string]: unknown;
        [x: number]: unknown;
        [x: symbol]: unknown;
        type: string;
    }): void;
    setState(state: MediaCacheStore | ((state: MediaCacheStore) => MediaCacheStore), replace: true, action?: string | {
        [x: string]: unknown;
        [x: number]: unknown;
        [x: symbol]: unknown;
        type: string;
    }): void;
    devtools: {
        cleanup: () => void;
    };
}, "setState" | "persist"> & {
    setState(partial: MediaCacheStore | Partial<MediaCacheStore> | ((state: MediaCacheStore) => MediaCacheStore | Partial<MediaCacheStore>), replace?: false, action?: string | {
        [x: string]: unknown;
        [x: number]: unknown;
        [x: symbol]: unknown;
        type: string;
    }): unknown;
    setState(state: MediaCacheStore | ((state: MediaCacheStore) => MediaCacheStore), replace: true, action?: string | {
        [x: string]: unknown;
        [x: number]: unknown;
        [x: symbol]: unknown;
        type: string;
    }): unknown;
    persist: {
        setOptions: (options: Partial<zustand_middleware.PersistOptions<MediaCacheStore, {
            audioPlaybackPositions: [string, number][];
            videoPlaybackPositions: [string, number][];
            videoPosterUrls: [string, string][];
            videoPlayerSettings: VideoPlayerSettings;
        }, unknown>>) => void;
        clearStorage: () => void;
        rehydrate: () => Promise<void> | void;
        hasHydrated: () => boolean;
        onHydrate: (fn: (state: MediaCacheStore) => void) => () => void;
        onFinishHydration: (fn: (state: MediaCacheStore) => void) => () => void;
        getOptions: () => Partial<zustand_middleware.PersistOptions<MediaCacheStore, {
            audioPlaybackPositions: [string, number][];
            videoPlaybackPositions: [string, number][];
            videoPosterUrls: [string, string][];
            videoPlayerSettings: VideoPlayerSettings;
        }, unknown>>;
    };
}>;
/**
 * Hook for image-related cache operations
 * Uses useShallow to prevent infinite re-renders
 */
declare const useImageCache: () => {
    getOrCreateBlobUrl: (key: string, content: ArrayBuffer, mimeType: string) => string;
    releaseBlobUrl: (key: string) => void;
    hasBlobUrl: (key: string) => boolean;
    cacheDimensions: (src: string, dims: ImageDimensions) => void;
    getDimensions: (src: string) => ImageDimensions | null;
};
/**
 * Hook for audio-related cache operations
 * Uses useShallow to prevent infinite re-renders
 */
declare const useAudioCache: () => {
    getOrCreateBlobUrl: (key: string, content: ArrayBuffer, mimeType: string) => string;
    releaseBlobUrl: (key: string) => void;
    hasBlobUrl: (key: string) => boolean;
    saveAudioPosition: (uri: string, time: number) => void;
    getAudioPosition: (uri: string) => number | null;
    getEffectConfig: (key: string) => EffectConfig | null;
    cacheEffectConfig: (key: string, config: EffectConfig) => void;
};
/**
 * Hook for video-related cache operations
 * Uses useShallow to prevent infinite re-renders
 */
declare const useVideoCache: () => {
    getOrCreateBlobUrl: (key: string, content: ArrayBuffer, mimeType: string) => string;
    releaseBlobUrl: (key: string) => void;
    hasBlobUrl: (key: string) => boolean;
    getOrCreateStreamUrl: (sessionId: string, path: string, generator: (sessionId: string, path: string) => string) => string;
    getPosterUrl: (title: string) => string | null;
    cachePosterUrl: (title: string, url: string) => void;
    saveVideoPosition: (key: string, time: number) => void;
    getVideoPosition: (key: string) => number | null;
    cacheVideoMetadata: (url: string, meta: VideoMetadata) => void;
    getVideoMetadata: (url: string) => VideoMetadata | null;
    invalidateSession: (sessionId: string) => void;
    getVideoPlayerSettings: () => VideoPlayerSettings;
    saveVideoPlayerSettings: (settings: Partial<VideoPlayerSettings>) => void;
};
/**
 * Hook for video player settings only
 * Returns current settings and save function
 */
declare const useVideoPlayerSettings: () => {
    settings: VideoPlayerSettings;
    saveSettings: (settings: Partial<VideoPlayerSettings>) => void;
};
/**
 * Hook for blob URL cleanup on unmount
 */
declare function useBlobUrlCleanup(key: string | null): void;
/**
 * Generate a cache key from ArrayBuffer content
 * Uses first and last 1KB + length for fast hashing
 */
declare function generateContentKey(content: ArrayBuffer): string;

export { type ApiKey, ArrayFieldItemTemplate, ArrayFieldTemplate, type AspectRatioValue, type AudioLevels, AudioReactiveCover, type AudioReactiveCoverProps, BaseInputTemplate, type BlobSource, COLOR_SCHEMES, COLOR_SCHEME_INFO, CardLoadingFallback, CheckboxWidget, ColorWidget, type CreateLazyComponentOptions, type CreateVideoErrorFallbackOptions, CronScheduler, type CronSchedulerContextValue, type CronSchedulerProps, CronSchedulerProvider, type CronSchedulerState, CustomInput, type DASHSource, type DataUrlSource, DayChips, DiffEditor, type DiffEditorProps, EFFECT_ANIMATIONS, Editor, type EditorContextValue, type EditorFile, type EditorOptions, type EditorProps, EditorProvider, type EditorRef, type EffectColorScheme, type EffectColors, type EffectConfig$1 as EffectConfig, type EffectIntensity, type EffectLayer, type EffectVariant, type EqualizerOptions, type ErrorFallbackProps, ErrorListTemplate, FieldTemplate, GlowEffect, type GlowEffectData, type HLSSource, type HybridAudioContextValue, type HybridAudioControls, HybridAudioPlayer, type HybridAudioPlayerProps, HybridAudioProvider, type HybridAudioProviderProps, type HybridAudioState, type HybridCompactPlayerProps, HybridSimplePlayer, type HybridSimplePlayerProps, HybridWaveform, type HybridWaveformProps, type HybridWebAudioAPI, INTENSITY_CONFIG, INTENSITY_INFO, type ImageFile, ImageViewer, type ImageViewerProps, JsonSchemaForm, type JsonSchemaFormProps, JsonTreeComponent as JsonTree, type JsonTreeConfig, type JsonTreeProps, LazyCronScheduler, LazyHybridAudioPlayer, LazyHybridCompactPlayer, LazyHybridSimplePlayer, LazyImageViewer, LazyJsonSchemaForm, LazyJsonTree, LazyLottiePlayer, LazyMapContainer, LazyMapView, LazyMermaid, LazyOpenapiViewer, LazyPrettyCode, LazyVideoPlayer, LazyWrapper, type LazyWrapperProps, type LinkRule, LoadingFallback, type LoadingFallbackProps, type LottieDirection, LottiePlayer, type LottiePlayerProps, type LottieSize, type LottieSpeed, type MapContainerProps, MapLoadingFallback, type MapStyleKey, type MapViewport, MarkdownEditor, type MarkdownEditorProps, MarkdownMessage, type MarkdownMessageProps, type MarkerData, type MentionAttrs, type MentionConfig, type MentionItem, type MentionMarkdownRenderer, Mermaid, type MermaidProps, MeshEffect, type MonthDay, MonthDayGrid, NativeProvider, NumberWidget, ObjectFieldTemplate, Playground as OpenapiViewer, OrbsEffect, type PlayerMode, type PlaygroundConfig, type PlaygroundProps$1 as PlaygroundProps, PrettyCode, type PrettyCodeProps$1 as PrettyCodeProps, type ResolveFileSourceOptions, SchedulePreview, type ScheduleType, ScheduleTypeSelector, type SchemaSource, SelectWidget, type SimpleStreamSource, SliderWidget, Spinner, SpotlightEffect, StreamProvider, type StreamSource, SwitchWidget, TextWidget, TimeSelector, type UrlSource, type UseAudioBusReturn, type UseAudioVisualizationReturn, type UseCollapsibleContentOptions, type UseCollapsibleContentResult, type UseEditorReturn, type UseHybridAudioOptions, type UseHybridAudioReturn, type UseLottieOptions, type UseLottieReturn, type UseMonacoReturn, type UseVisualizationReturn, VARIANT_INFO, VideoControls, VideoErrorFallback, type VideoErrorFallbackProps, VideoPlayer, type VideoPlayerContextValue, type VideoPlayerProps, VideoPlayerProvider, type VideoPlayerProviderProps, type VideoPlayerRef, type VideoSourceUnion, VidstackProvider, type VimeoSource, type VisualizationColorScheme, type VisualizationIntensity, VisualizationProvider, type VisualizationProviderProps, type VisualizationSettings, type VisualizationVariant, type WeekDay, type YouTubeSource, buildCron, calculateGlowLayers, calculateMeshGradients, calculateOrbs, calculateSpotlight, createLazyComponent, createVideoErrorFallback, extractTextFromChildren, formatTime, generateContentKey, getColors, getEffectConfig, getRequiredFields, hasRequiredFields, humanizeCron, isSimpleStreamSource, isValidCron, mentionPresets, mergeDefaults, normalizeFormData, parseCron, prepareEffectColors, resolveFileSource, resolvePlayerMode, resolveStreamSource, safeJsonParse, safeJsonStringify, useAudioBus, useAudioBusStore, useAudioCache, useAudioVisualization, useBlobUrlCleanup, useCollapsibleContent, useCronCustom, useCronMonthDays, useCronPreview, useCronScheduler, useCronSchedulerContext, useCronTime, useCronType, useCronWeekDays, useEditor, useEditorContext, useHybridAudio, useHybridAudioAnalysis, useHybridAudioContext, useHybridAudioControls, useHybridAudioLevels, useHybridAudioState, useHybridWebAudio, useImageCache, useLanguage, useLottie, useMediaCacheStore, useMonaco, useVideoCache, useVideoPlayerContext, useVideoPlayerSettings, useVisualization, validateRequiredFields, validateSchema };
