react-ascii-ui/dist/index.d.ts

Complete ASCII-styled React UI library with advanced features: sound system, code editor, network visualizer, and ASCII art generator

import * as React$1 from 'react';
import React__default, { ReactNode } from 'react';

declare const AsciiButton: React__default.FC<React__default.ButtonHTMLAttributes<HTMLButtonElement>>;

declare const AsciiInput: React__default.FC<React__default.InputHTMLAttributes<HTMLInputElement>>;

declare const AsciiSelect: React__default.FC<React__default.SelectHTMLAttributes<HTMLSelectElement>>;

declare const AsciiDivider: React__default.FC;

interface AsciiCheckboxProps extends Omit<React__default.InputHTMLAttributes<HTMLInputElement>, 'type'> {
    label?: string;
}
declare const AsciiCheckbox: React__default.FC<AsciiCheckboxProps>;

interface AsciiCardProps extends React__default.HTMLAttributes<HTMLDivElement> {
    title?: string;
}
declare const AsciiCard: React__default.FC<AsciiCardProps>;

interface AsciiRadioOption {
    label: string;
    value: string;
}
interface AsciiRadioGroupProps {
    name: string;
    options: AsciiRadioOption[];
    value?: string;
    onChange?: (value: string) => void;
    className?: string;
}
declare const AsciiRadioGroup: React__default.FC<AsciiRadioGroupProps>;

declare const AsciiTextarea: React__default.FC<React__default.TextareaHTMLAttributes<HTMLTextAreaElement>>;

interface AsciiAlertProps extends React__default.HTMLAttributes<HTMLDivElement> {
    variant?: 'info' | 'success' | 'warning' | 'error';
    title?: string;
}
declare const AsciiAlert: React__default.FC<AsciiAlertProps>;

interface AsciiBadgeProps extends React__default.HTMLAttributes<HTMLSpanElement> {
    variant?: 'square' | 'curly';
    color?: 'default' | 'primary' | 'success' | 'warning' | 'error';
}
declare const AsciiBadge: React__default.FC<AsciiBadgeProps>;

interface AsciiLoaderProps extends React__default.HTMLAttributes<HTMLDivElement> {
    variant?: 'dots' | 'progress';
    text?: string;
    progress?: number;
}
declare const AsciiLoader: React__default.FC<AsciiLoaderProps>;

interface AsciiNavbarItem {
    label: string;
    href?: string;
    onClick?: () => void;
    active?: boolean;
}
interface AsciiNavbarProps extends React__default.HTMLAttributes<HTMLElement> {
    items: AsciiNavbarItem[];
    brand?: string;
}
declare const AsciiNavbar: React__default.FC<AsciiNavbarProps>;

interface AsciiSidebarItem {
    label: string;
    href?: string;
    onClick?: () => void;
    active?: boolean;
    icon?: string;
}
interface AsciiSidebarProps extends React__default.HTMLAttributes<HTMLElement> {
    items: AsciiSidebarItem[];
    title?: string;
    width?: string;
}
declare const AsciiSidebar: React__default.FC<AsciiSidebarProps>;

interface AsciiTab {
    label: string;
    content: React__default.ReactNode;
    disabled?: boolean;
}
interface AsciiTabsProps extends React__default.HTMLAttributes<HTMLDivElement> {
    tabs: AsciiTab[];
    defaultTab?: number;
    onTabChange?: (index: number) => void;
}
declare const AsciiTabs: React__default.FC<AsciiTabsProps>;

interface AsciiAccordionItem {
    title: string;
    content: React__default.ReactNode;
    defaultOpen?: boolean;
}
interface AsciiAccordionProps extends React__default.HTMLAttributes<HTMLDivElement> {
    items: AsciiAccordionItem[];
    allowMultiple?: boolean;
}
declare const AsciiAccordion: React__default.FC<AsciiAccordionProps>;

interface AsciiTableColumn$1 {
    key: string;
    header: string;
    width?: string;
    align?: 'left' | 'center' | 'right';
}
interface AsciiTableProps extends React__default.HTMLAttributes<HTMLDivElement> {
    columns: AsciiTableColumn$1[];
    data: Record<string, any>[];
    caption?: string;
}
declare const AsciiTable: React__default.FC<AsciiTableProps>;

interface AsciiTableColumn {
    key: string;
    header: string;
    width?: string;
    align?: 'left' | 'center' | 'right';
    sortable?: boolean;
    filterable?: boolean;
    render?: (value: any, row: any, index: number) => React__default.ReactNode;
}
interface AsciiAdvancedTableProps extends React__default.HTMLAttributes<HTMLDivElement> {
    columns: AsciiTableColumn[];
    data: Record<string, any>[];
    caption?: string;
    sortable?: boolean;
    filterable?: boolean;
    paginated?: boolean;
    pageSize?: number;
    searchable?: boolean;
    loading?: boolean;
    emptyMessage?: string;
    onRowClick?: (row: any, index: number) => void;
}
declare const AsciiAdvancedTable: React__default.FC<AsciiAdvancedTableProps>;

interface AsciiPaginationProps extends React__default.HTMLAttributes<HTMLDivElement> {
    currentPage: number;
    totalPages: number;
    onPageChange: (page: number) => void;
    maxVisiblePages?: number;
    showFirstLast?: boolean;
}
declare const AsciiPagination: React__default.FC<AsciiPaginationProps>;

interface AsciiModalProps {
    isOpen: boolean;
    onClose?: () => void;
    title?: string;
    children: React__default.ReactNode;
    showCloseButton?: boolean;
    backdrop?: 'static' | 'clickable';
    size?: 'sm' | 'md' | 'lg';
    className?: string;
}
declare const AsciiModal: React__default.FC<AsciiModalProps>;

interface AsciiToastProps {
    message: string;
    type?: 'info' | 'success' | 'warning' | 'error';
    duration?: number;
    isVisible: boolean;
    onClose?: () => void;
    position?: 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left' | 'top-center' | 'bottom-center';
    showCloseButton?: boolean;
}
declare const AsciiToast: React__default.FC<AsciiToastProps>;
interface ToastItem {
    id: string;
    message: string;
    type?: 'info' | 'success' | 'warning' | 'error';
    duration?: number;
}
interface AsciiToastContainerProps {
    toasts: ToastItem[];
    onRemoveToast: (id: string) => void;
    position?: 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left' | 'top-center' | 'bottom-center';
}
declare const AsciiToastContainer: React__default.FC<AsciiToastContainerProps>;

interface AsciiTooltipProps {
    content: string;
    children: React__default.ReactNode;
    position?: 'top' | 'bottom' | 'left' | 'right';
    delay?: number;
    className?: string;
    disabled?: boolean;
}
declare const AsciiTooltip: React__default.FC<AsciiTooltipProps>;

interface AsciiProgressBarProps$1 extends React__default.HTMLAttributes<HTMLDivElement> {
    value: number;
    max?: number;
    size?: 'sm' | 'md' | 'lg';
    showPercentage?: boolean;
    showValue?: boolean;
    label?: string;
    variant?: 'blocks' | 'bars' | 'dots';
    color?: 'default' | 'success' | 'warning' | 'error';
}
declare const AsciiProgressBar: React__default.FC<AsciiProgressBarProps$1>;

interface AsciiSwitchProps extends Omit<React__default.InputHTMLAttributes<HTMLInputElement>, 'type' | 'size'> {
    label?: string;
    onText?: string;
    offText?: string;
    size?: 'sm' | 'md' | 'lg';
    variant?: 'bracket' | 'slider';
}
declare const AsciiSwitch: React__default.FC<AsciiSwitchProps>;

interface AsciiCalendarProps extends React__default.HTMLAttributes<HTMLDivElement> {
    currentDate?: Date;
    selectedDate?: Date;
    onDateSelect?: (date: Date) => void;
    showNavigation?: boolean;
    onMonthChange?: (date: Date) => void;
}
declare const AsciiCalendar: React__default.FC<AsciiCalendarProps>;

interface AsciiAvatarProps extends React__default.HTMLAttributes<HTMLDivElement> {
    name: string;
    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
    variant?: 'parentheses' | 'brackets' | 'braces';
    color?: 'default' | 'primary' | 'success' | 'warning' | 'error' | 'purple' | 'pink';
    showBorder?: boolean;
}
declare const AsciiAvatar: React__default.FC<AsciiAvatarProps>;

interface AsciiChartProps extends React__default.HTMLAttributes<HTMLDivElement> {
    data: number[];
    type?: 'bar' | 'line' | 'area';
    height?: number;
    width?: number;
    showValues?: boolean;
    color?: 'default' | 'success' | 'warning' | 'error' | 'primary';
    title?: string;
}
declare const AsciiChart: React__default.FC<AsciiChartProps>;

interface AsciiTreeNode {
    id: string;
    label: string;
    children?: AsciiTreeNode[];
    icon?: string;
    metadata?: Record<string, any>;
}
interface AsciiTreeProps extends React__default.HTMLAttributes<HTMLDivElement> {
    data: AsciiTreeNode[];
    expandable?: boolean;
    showIcons?: boolean;
    selectable?: boolean;
    defaultExpanded?: string[];
    selectedNode?: string;
    onNodeSelect?: (node: AsciiTreeNode) => void;
    onNodeExpand?: (node: AsciiTreeNode, expanded: boolean) => void;
    renderNode?: (node: AsciiTreeNode, isSelected: boolean, isExpanded: boolean) => React__default.ReactNode;
}
declare const AsciiTree: React__default.FC<AsciiTreeProps>;

type PopoverPosition = 'top' | 'bottom' | 'left' | 'right';
type PopoverTrigger = 'click' | 'hover';
interface AsciiPopoverProps {
    children: React__default.ReactNode;
    content: React__default.ReactNode;
    position?: PopoverPosition;
    trigger?: PopoverTrigger;
    visible?: boolean;
    onVisibilityChange?: (visible: boolean) => void;
    delay?: number;
    offset?: number;
    className?: string;
    contentClassName?: string;
    arrow?: boolean;
}
declare const AsciiPopover: React__default.FC<AsciiPopoverProps>;

interface AsciiThemeSwitcherProps extends React__default.HTMLAttributes<HTMLDivElement> {
    variant?: 'dropdown' | 'buttons' | 'cycle';
    showPreview?: boolean;
}
declare const AsciiThemeSwitcher: React__default.FC<AsciiThemeSwitcherProps>;

interface FileUploadFile {
    id: string;
    file: File;
    status: 'pending' | 'uploading' | 'completed' | 'error';
    progress: number;
    error?: string;
    preview?: string;
}
interface AsciiFileUploadProps extends Omit<React__default.HTMLAttributes<HTMLDivElement>, 'onDrop' | 'onError'> {
    accept?: string;
    multiple?: boolean;
    maxFiles?: number;
    maxFileSize?: number;
    disabled?: boolean;
    onFilesSelect?: (files: File[]) => void;
    onUpload?: (file: File, progressCallback: (progress: number) => void) => Promise<void>;
    onRemove?: (fileId: string) => void;
    onError?: (error: string, file?: File) => void;
    showPreview?: boolean;
    uploadText?: string;
    dragText?: string;
    allowedTypes?: string[];
    autoUpload?: boolean;
}
declare const AsciiFileUpload: React__default.FC<AsciiFileUploadProps>;

interface TerminalCommand {
    command: string;
    args: string[];
    rawInput: string;
}
interface TerminalHistoryEntry {
    id: string;
    input: string;
    output: React__default.ReactNode;
    timestamp: Date;
    type: 'command' | 'output' | 'error' | 'system';
}
interface TerminalCommandHandler {
    command: string;
    description: string;
    usage?: string;
    handler: (command: TerminalCommand) => React__default.ReactNode | Promise<React__default.ReactNode>;
}
interface AsciiTerminalProps extends React__default.HTMLAttributes<HTMLDivElement> {
    prompt?: string;
    welcomeMessage?: React__default.ReactNode;
    commands?: TerminalCommandHandler[];
    onCommandExecute?: (command: TerminalCommand, output: React__default.ReactNode) => void;
    maxHistorySize?: number;
    showTimestamps?: boolean;
    autoFocus?: boolean;
    placeholder?: string;
    readOnly?: boolean;
    height?: string | number;
}
declare const AsciiTerminal: React__default.FC<AsciiTerminalProps>;

interface AsciiThemeColors {
    primary: string;
    secondary: string;
    success: string;
    warning: string;
    error: string;
    errorBackground: string;
    info: string;
    background: string;
    surface: string;
    text: string;
    textSecondary: string;
    muted: string;
    border: string;
    accent: string;
}
interface AsciiThemeCharacters {
    boxTopLeft: string;
    boxTopRight: string;
    boxBottomLeft: string;
    boxBottomRight: string;
    boxHorizontal: string;
    boxVertical: string;
    boxCross: string;
    boxTeeTop: string;
    boxTeeBottom: string;
    boxTeeLeft: string;
    boxTeeRight: string;
    bulletPoint: string;
    arrow: string;
    arrowUp: string;
    arrowDown: string;
    arrowLeft: string;
    arrowRight: string;
    checkmark: string;
    cross: string;
    radioSelected: string;
    radioUnselected: string;
    expand: string;
    collapse: string;
    progressFilled: string;
    progressEmpty: string;
    loadingSpinner: string[];
    bracketLeft: string;
    bracketRight: string;
    separator: string;
    divider: string;
}
interface AsciiThemeTypography {
    fontFamily: string;
    fontSize: {
        xs: string;
        sm: string;
        base: string;
        lg: string;
        xl: string;
        '2xl': string;
        '3xl': string;
    };
    fontWeight: {
        normal: string;
        bold: string;
    };
    lineHeight: string;
}
interface AsciiThemeSpacing {
    xs: string;
    sm: string;
    md: string;
    lg: string;
    xl: string;
    '2xl': string;
}
interface AsciiTheme {
    name: string;
    description: string;
    colors: AsciiThemeColors;
    characters: AsciiThemeCharacters;
    typography: AsciiThemeTypography;
    spacing: AsciiThemeSpacing;
    borderRadius: string;
    shadows: {
        sm: string;
        md: string;
        lg: string;
    };
}
type ThemeName = 'classic' | 'cyberpunk' | 'matrix' | 'retro' | 'terminal' | 'neon' | 'minimal' | 'hacker';

declare const themes: Record<ThemeName, AsciiTheme>;
declare const getTheme: (name: ThemeName) => AsciiTheme;
declare const getAllThemes: () => AsciiTheme[];
declare const getThemeNames: () => ThemeName[];
declare const defaultTheme: AsciiTheme;

interface ThemeContextValue {
    theme: AsciiTheme;
    themeName: ThemeName;
    setTheme: (themeName: ThemeName) => void;
    toggleTheme: () => void;
}
interface AsciiThemeProviderProps {
    children: ReactNode;
    initialTheme?: ThemeName;
}
declare const AsciiThemeProvider: React__default.FC<AsciiThemeProviderProps>;
declare const useAsciiTheme: () => ThemeContextValue;
declare const useThemeCharacters: () => AsciiThemeCharacters;
declare const useThemeColors: () => AsciiThemeColors;

interface AnimationConfig {
    duration?: number;
    delay?: number;
    repeat?: boolean | number;
    direction?: 'normal' | 'reverse' | 'alternate';
    easing?: 'linear' | 'ease-in' | 'ease-out' | 'ease-in-out';
}
interface TypewriterConfig extends AnimationConfig {
    speed?: number;
    cursor?: string;
    showCursor?: boolean;
    deleteSpeed?: number;
    pauseAfterComplete?: number;
}
interface MatrixRainConfig extends AnimationConfig {
    density?: number;
    speed?: number;
    characters?: string[];
    columns?: number;
    fadeEffect?: boolean;
}
interface LoadingSpinnerConfig extends AnimationConfig {
    frames?: string[];
    size?: 'sm' | 'md' | 'lg';
}
interface TransitionConfig extends AnimationConfig {
    type?: 'fade' | 'slide' | 'glitch' | 'matrix';
    intensity?: number;
}
type AnimationState = 'idle' | 'running' | 'paused' | 'completed';

declare const defaultAnimationConfig: AnimationConfig;
declare const easingFunctions: {
    linear: (t: number) => number;
    'ease-in': (t: number) => number;
    'ease-out': (t: number) => number;
    'ease-in-out': (t: number) => number;
};
declare const useAnimationFrame: (callback: (deltaTime: number) => void, deps?: any[]) => void;
declare const generateRandomChar: (charset?: string) => string;
declare const matrixCharset = "01\u30A2\u30A4\u30A6\u30A8\u30AA\u30AB\u30AD\u30AF\u30B1\u30B3\u30B5\u30B7\u30B9\u30BB\u30BD\u30BF\u30C1\u30C4\u30C6\u30C8\u30CA\u30CB\u30CC\u30CD\u30CE\u30CF\u30D2\u30D5\u30D8\u30DB\u30DE\u30DF\u30E0\u30E1\u30E2\u30E4\u30E6\u30E8\u30E9\u30EA\u30EB\u30EC\u30ED\u30EF\u30F2\u30F3";
declare const glitchCharset = "\u2588\u2589\u258A\u258B\u258C\u258D\u258E\u258F\u2590\u2591\u2592\u2593\u2594\u2595\u2596\u2597\u2598\u2599\u259A\u259B\u259C\u259D\u259E\u259F";
declare const progressChars: {
    filled: string;
    empty: string;
    partial: string[];
};
declare const spinnerFrames: {
    dots: string[];
    line: string[];
    arrow: string[];
    bounce: string[];
    pulse: string[];
    binary: string[];
    matrix: string[];
    classic: string[];
};

interface UseAnimationReturn {
    state: AnimationState;
    progress: number;
    start: () => void;
    pause: () => void;
    resume: () => void;
    stop: () => void;
    reset: () => void;
}
declare const useAnimation: (config?: AnimationConfig) => UseAnimationReturn;

interface UseTypewriterReturn {
    displayText: string;
    isComplete: boolean;
    isTyping: boolean;
    start: () => void;
    pause: () => void;
    resume: () => void;
    reset: () => void;
    setSpeed: (speed: number) => void;
}
declare const useTypewriter: (text: string | string[], config?: TypewriterConfig) => UseTypewriterReturn;

interface AsciiSpinnerProps extends React__default.HTMLAttributes<HTMLSpanElement> {
    variant?: keyof typeof spinnerFrames;
    speed?: number;
    size?: 'sm' | 'md' | 'lg';
    color?: string;
    config?: LoadingSpinnerConfig;
}
declare const AsciiSpinner: React__default.FC<AsciiSpinnerProps>;

interface AsciiProgressBarProps extends React__default.HTMLAttributes<HTMLDivElement> {
    value?: number;
    width?: number;
    animated?: boolean;
    animationSpeed?: number;
    showPercentage?: boolean;
    label?: string;
    variant?: 'filled' | 'gradient' | 'pulse';
}
declare const AsciiAnimatedProgressBar: React__default.FC<AsciiProgressBarProps>;

interface AsciiTypewriterProps extends React__default.HTMLAttributes<HTMLSpanElement> {
    text: string | string[];
    config?: TypewriterConfig;
    onComplete?: () => void;
    onStart?: () => void;
    autoStart?: boolean;
}
declare const AsciiTypewriter: React__default.FC<AsciiTypewriterProps>;
declare const AsciiTypewriterLine: React__default.FC<AsciiTypewriterProps>;
interface AsciiTypewriterMultiProps extends Omit<AsciiTypewriterProps, 'text'> {
    lines: string[];
    lineDelay?: number;
}
declare const AsciiTypewriterMulti: React__default.FC<AsciiTypewriterMultiProps>;

interface AsciiMatrixRainProps extends React__default.HTMLAttributes<HTMLDivElement> {
    width?: number;
    height?: number;
    config?: MatrixRainConfig;
    color?: string;
    backgroundColor?: string;
}
declare const AsciiMatrixRain: React__default.FC<AsciiMatrixRainProps>;
declare const AsciiMatrixRainFullscreen: React__default.FC<Omit<AsciiMatrixRainProps, 'width' | 'height'>>;

interface AsciiTransitionProps extends React__default.HTMLAttributes<HTMLDivElement> {
    show: boolean;
    children: React__default.ReactNode;
    config?: TransitionConfig;
    fallback?: React__default.ReactNode;
}
declare const AsciiTransition: React__default.FC<AsciiTransitionProps>;
declare const AsciiFadeTransition: React__default.FC<Omit<AsciiTransitionProps, 'config'> & {
    duration?: number;
}>;
declare const AsciiSlideTransition: React__default.FC<Omit<AsciiTransitionProps, 'config'> & {
    duration?: number;
}>;
declare const AsciiGlitchTransition: React__default.FC<Omit<AsciiTransitionProps, 'config'> & {
    duration?: number;
    intensity?: number;
}>;
declare const AsciiMatrixTransition: React__default.FC<Omit<AsciiTransitionProps, 'config'> & {
    duration?: number;
    intensity?: number;
}>;

interface SoundEffect {
    frequency: number;
    duration: number;
    type: 'sine' | 'square' | 'sawtooth' | 'triangle';
    volume?: number;
    fadeOut?: boolean;
}
interface BeepSequence {
    effects: SoundEffect[];
    interval?: number;
}
interface AsciiSoundContextValue {
    audioContext: AudioContext | null;
    masterVolume: number;
    setMasterVolume: (volume: number) => void;
    isEnabled: boolean;
    setIsEnabled: (enabled: boolean) => void;
    playBeep: (effect: SoundEffect) => void;
    playSequence: (sequence: BeepSequence) => void;
    playPreset: (presetName: keyof typeof soundPresets) => void;
}
declare const soundPresets: {
    keyPress: {
        frequency: number;
        duration: number;
        type: "square";
        volume: number;
    };
    enter: {
        frequency: number;
        duration: number;
        type: "sine";
        volume: number;
    };
    backspace: {
        frequency: number;
        duration: number;
        type: "square";
        volume: number;
    };
    buttonClick: {
        frequency: number;
        duration: number;
        type: "square";
        volume: number;
    };
    buttonHover: {
        frequency: number;
        duration: number;
        type: "sine";
        volume: number;
    };
    tabSwitch: {
        frequency: number;
        duration: number;
        type: "triangle";
        volume: number;
    };
    modalOpen: {
        frequency: number;
        duration: number;
        type: "sine";
        volume: number;
        fadeOut: boolean;
    };
    modalClose: {
        frequency: number;
        duration: number;
        type: "sine";
        volume: number;
        fadeOut: boolean;
    };
    formSubmit: {
        frequency: number;
        duration: number;
        type: "sine";
        volume: number;
    };
    formError: {
        frequency: number;
        duration: number;
        type: "sawtooth";
        volume: number;
    };
    uploadComplete: {
        frequency: number;
        duration: number;
        type: "sine";
        volume: number;
    };
    gameStart: BeepSequence;
    gameOver: BeepSequence;
    notification: {
        frequency: number;
        duration: number;
        type: "sine";
        volume: number;
    };
    alert: {
        frequency: number;
        duration: number;
        type: "square";
        volume: number;
    };
    success: BeepSequence;
    bootUp: BeepSequence;
    staticNoise: {
        frequency: number;
        duration: number;
        type: "sawtooth";
        volume: number;
    };
};

declare const getAudioContext: () => AudioContext | null;
declare const resumeAudioContext: () => Promise<void>;
declare const playBeep: (effect: SoundEffect, masterVolume?: number) => Promise<void>;
declare const playSequence: (sequence: BeepSequence, masterVolume?: number) => Promise<void>;
declare const generateWhiteNoise: (audioContext: AudioContext, duration: number, volume?: number) => AudioBuffer;
declare const playWhiteNoise: (duration: number, volume?: number, masterVolume?: number) => Promise<void>;
declare const createSweepEffect: (startFreq: number, endFreq: number, duration: number, type?: OscillatorType, volume?: number, masterVolume?: number) => Promise<void>;
declare const soundGenerators: {
    dial: () => Promise<void>;
    powerUp: () => Promise<void>;
    powerDown: () => Promise<void>;
    error: () => Promise<void>;
    coin: () => Promise<void>;
    laser: () => Promise<void>;
};

interface AsciiSoundProviderProps {
    children: ReactNode;
    defaultVolume?: number;
    defaultEnabled?: boolean;
    autoResume?: boolean;
}
declare const AsciiSoundProvider: React__default.FC<AsciiSoundProviderProps>;
declare const useAsciiSound: () => AsciiSoundContextValue;

declare const useButtonSounds: () => {
    playClick: () => void;
    playHover: () => void;
};
declare const useTerminalSounds: () => {
    playKeyPress: () => void;
    playEnter: () => void;
    playBackspace: () => void;
};
declare const useFormSounds: () => {
    playSubmit: () => void;
    playError: () => void;
    playSuccess: () => void;
};
declare const useModalSounds: () => {
    playOpen: () => void;
    playClose: () => void;
};
declare const useSystemSounds: () => {
    playNotification: () => void;
    playAlert: () => void;
    playBootUp: () => void;
};
declare const useGameSounds: () => {
    playGameStart: () => void;
    playGameOver: () => void;
};
declare const useTypingSounds: (enabled?: boolean) => {
    startTyping: () => void;
    stopTyping: () => void;
};
declare const useAmbientSounds: () => {
    startAmbient: (type?: "static" | "hum") => void;
    stopAmbient: () => void;
};
declare const useSoundEnabled: (soundType?: keyof typeof soundPresets) => {
    playSound: () => void;
    soundEnabled: boolean;
};

interface AsciiArtOptions {
    width?: number;
    height?: number;
    characters?: string;
    style?: 'detailed' | 'simple' | 'blocks' | 'dots' | 'custom';
    invert?: boolean;
    contrast?: number;
    brightness?: number;
    preserveAspectRatio?: boolean;
}
interface AsciiArtResult {
    ascii: string;
    width: number;
    height: number;
    originalImage: {
        width: number;
        height: number;
    };
    processingTime: number;
}
interface ImageData {
    data: Uint8ClampedArray;
    width: number;
    height: number;
}
interface AsciiCharacterSet {
    name: string;
    characters: string;
    description: string;
}
declare const ASCII_CHARACTER_SETS: Record<string, AsciiCharacterSet>;
interface AsciiArtConfig {
    maxWidth: number;
    maxHeight: number;
    defaultCharacterSet: keyof typeof ASCII_CHARACTER_SETS;
    enableWebGL: boolean;
    cacheEnabled: boolean;
}
declare const DEFAULT_ASCII_CONFIG: AsciiArtConfig;

/**
 * Load an image from a URL or File and return ImageData
 */
declare const loadImageData: (source: string | File) => Promise<ImageData>;
/**
 * Calculate brightness of a pixel (0-255)
 */
declare const calculateBrightness: (r: number, g: number, b: number, a?: number) => number;
/**
 * Resize image data to target dimensions
 */
declare const resizeImageData: (imageData: ImageData, targetWidth: number, targetHeight: number, preserveAspectRatio?: boolean) => ImageData;
/**
 * Apply brightness and contrast adjustments
 */
declare const adjustImageData: (imageData: ImageData, brightness?: number, contrast?: number) => ImageData;
/**
 * Convert brightness value to ASCII character
 */
declare const brightnessToCharacter: (brightness: number, characters: string, invert?: boolean) => string;
/**
 * Convert ImageData to ASCII art
 */
declare const imageDataToAscii: (imageData: ImageData, options?: AsciiArtOptions) => AsciiArtResult;
/**
 * Convert image source to ASCII art (main function)
 */
declare const convertToAsciiArt: (source: string | File, options?: AsciiArtOptions) => Promise<AsciiArtResult>;
/**
 * Advanced ASCII art with dithering
 */
declare const convertToAsciiArtWithDithering: (source: string | File, options?: AsciiArtOptions) => Promise<AsciiArtResult>;
/**
 * Apply Floyd-Steinberg dithering to image data
 */
declare const applyFloydSteinbergDithering: (imageData: ImageData) => ImageData;
/**
 * Generate ASCII art from webcam stream
 */
declare const captureWebcamFrame: (video: HTMLVideoElement, options?: AsciiArtOptions) => Promise<AsciiArtResult>;

interface AsciiArtGeneratorProps {
    onResult?: (result: AsciiArtResult) => void;
    onError?: (error: string) => void;
    defaultOptions?: Partial<AsciiArtOptions>;
    showControls?: boolean;
    showPreview?: boolean;
    maxFileSize?: number;
    allowedTypes?: string[];
}
declare const AsciiArtGenerator: React__default.FC<AsciiArtGeneratorProps>;

interface UseAsciiArtState {
    result: AsciiArtResult | null;
    isProcessing: boolean;
    error: string | null;
    progress: number;
}
interface UseAsciiArtActions {
    convertImage: (source: string | File, options?: AsciiArtOptions) => Promise<void>;
    convertWithDithering: (source: string | File, options?: AsciiArtOptions) => Promise<void>;
    clear: () => void;
    downloadResult: () => void;
    copyToClipboard: () => Promise<boolean>;
}
/**
 * Hook for ASCII art conversion with state management
 */
declare const useAsciiArt: () => UseAsciiArtState & UseAsciiArtActions;
/**
 * Hook for webcam ASCII art conversion
 */
declare const useWebcamAsciiArt: () => {
    videoRef: React$1.RefObject<HTMLVideoElement>;
    stream: MediaStream | null;
    isCapturing: boolean;
    error: string | null;
    startWebcam: () => Promise<void>;
    stopWebcam: () => void;
    captureFrame: (options?: AsciiArtOptions) => Promise<AsciiArtResult | null>;
};
/**
 * Hook for batch ASCII art conversion
 */
declare const useBatchAsciiArt: () => {
    results: AsciiArtResult[];
    isProcessing: boolean;
    progress: number;
    currentFile: string;
    errors: string[];
    convertBatch: (files: File[], options?: AsciiArtOptions, onProgress?: (current: number, total: number, filename: string) => void) => Promise<void>;
    downloadAllResults: () => void;
    clearResults: () => void;
};
/**
 * Hook for real-time ASCII art effects
 */
declare const useRealTimeAsciiArt: () => {
    isRunning: boolean;
    currentFrame: AsciiArtResult | null;
    startRealTime: (videoElement: HTMLVideoElement, options?: AsciiArtOptions, fps?: number, onFrame?: (result: AsciiArtResult) => void) => void;
    stopRealTime: () => void;
};

interface CodeEditorTheme {
    name: string;
    colors: {
        background: string;
        text: string;
        selection: string;
        cursor: string;
        lineNumber: string;
        gutter: string;
        keyword: string;
        string: string;
        number: string;
        comment: string;
        operator: string;
        function: string;
        variable: string;
        type: string;
        constant: string;
        punctuation: string;
        whitespace: string;
        identifier: string;
        unknown: string;
        error: string;
        warning: string;
        info: string;
    };
    styles: {
        fontFamily: string;
        fontSize: string;
        lineHeight: number;
        tabSize: number;
    };
}
interface SyntaxToken {
    type: TokenType;
    value: string;
    start: number;
    end: number;
    line: number;
    column: number;
}
type TokenType = 'keyword' | 'string' | 'number' | 'comment' | 'operator' | 'punctuation' | 'function' | 'variable' | 'type' | 'constant' | 'whitespace' | 'identifier' | 'unknown';
interface LanguageDefinition {
    name: string;
    extensions: string[];
    keywords: string[];
    operators: string[];
    punctuation: string[];
    stringDelimiters: string[];
    commentDelimiters: {
        line: string[];
        block: Array<{
            start: string;
            end: string;
        }>;
    };
    brackets: Array<{
        open: string;
        close: string;
    }>;
    caseInsensitive?: boolean;
    tokenizer: (text: string) => SyntaxToken[];
}
interface CodeEditorOptions {
    language?: string;
    theme?: string | CodeEditorTheme;
    readOnly?: boolean;
    lineNumbers?: boolean;
    wordWrap?: boolean;
    tabSize?: number;
    insertSpaces?: boolean;
    fontSize?: string;
    minimap?: boolean;
    autoIndent?: boolean;
    bracketMatching?: boolean;
    foldingEnabled?: boolean;
    searchEnabled?: boolean;
    autoComplete?: boolean;
    linting?: boolean;
    soundEffects?: boolean;
}
interface CodeEditorState {
    content: string;
    cursorPosition: CursorPosition;
    selection: Selection | null;
    scrollPosition: {
        x: number;
        y: number;
    };
    highlightedTokens: SyntaxToken[];
    errors: DiagnosticMessage[];
    warnings: DiagnosticMessage[];
}
interface CursorPosition {
    line: number;
    column: number;
}
interface Selection {
    start: CursorPosition;
    end: CursorPosition;
}
interface DiagnosticMessage {
    message: string;
    severity: 'error' | 'warning' | 'info';
    line: number;
    column: number;
    endLine?: number;
    endColumn?: number;
}
interface AutoCompleteItem {
    label: string;
    kind: 'keyword' | 'function' | 'variable' | 'type' | 'constant' | 'snippet';
    detail?: string;
    documentation?: string;
    insertText?: string;
    sortText?: string;
}
interface CodeAction {
    title: string;
    kind: 'quickfix' | 'refactor' | 'format';
    isPreferred?: boolean;
    action: () => void;
}
declare const ASCII_CODE_THEMES: Record<string, CodeEditorTheme>;
declare const DEFAULT_CODE_EDITOR_OPTIONS: CodeEditorOptions;

/**
 * Simple tokenizer that identifies different types of tokens in code
 */
declare const createTokenizer: (language: LanguageDefinition) => (text: string) => SyntaxToken[];
declare const LANGUAGE_DEFINITIONS: Record<string, LanguageDefinition>;
declare const getLanguageFromExtension: (filename: string) => string | null;
declare const getLanguageDefinition: (language: string) => LanguageDefinition | null;

interface AsciiCodeEditorProps {
    value?: string;
    onChange?: (value: string) => void;
    onCursorPositionChange?: (position: CursorPosition) => void;
    onSelectionChange?: (selection: Selection | null) => void;
    options?: Partial<CodeEditorOptions>;
    filename?: string;
    placeholder?: string;
    className?: string;
    style?: React__default.CSSProperties;
}
declare const AsciiCodeEditor: React__default.FC<AsciiCodeEditorProps>;

interface UseCodeEditorState {
    content: string;
    cursorPosition: CursorPosition;
    selection: Selection | null;
    isModified: boolean;
    canUndo: boolean;
    canRedo: boolean;
    autoCompleteItems: AutoCompleteItem[];
    diagnostics: DiagnosticMessage[];
    availableActions: CodeAction[];
}
interface UseCodeEditorActions {
    setContent: (content: string) => void;
    insertText: (text: string, position?: CursorPosition) => void;
    replaceSelection: (text: string) => void;
    selectAll: () => void;
    selectLine: (lineNumber: number) => void;
    selectWord: (position: CursorPosition) => void;
    undo: () => void;
    redo: () => void;
    format: () => void;
    commentToggle: () => void;
    duplicateLine: () => void;
    deleteLine: () => void;
    moveLinesUp: () => void;
    moveLinesDown: () => void;
    indentSelection: () => void;
    outdentSelection: () => void;
    findText: (query: string, options?: {
        caseSensitive?: boolean;
        wholeWord?: boolean;
    }) => void;
    replaceText: (query: string, replacement: string, replaceAll?: boolean) => void;
    gotoLine: (lineNumber: number) => void;
}
/**
 * Main hook for code editor functionality
 */
declare const useCodeEditor: (initialContent?: string, language?: string) => UseCodeEditorState & UseCodeEditorActions;
/**
 * Hook for managing multiple code editor tabs
 */
interface CodeTab {
    id: string;
    filename: string;
    content: string;
    language: string;
    isModified: boolean;
    isActive: boolean;
}
declare const useCodeTabs: () => {
    tabs: CodeTab[];
    activeTab: CodeTab | null;
    activeTabId: string | null;
    addTab: (tab: Omit<CodeTab, "id" | "isActive">) => string;
    closeTab: (tabId: string) => void;
    updateTab: (tabId: string, updates: Partial<CodeTab>) => void;
    setActiveTab: (tabId: string) => void;
};

interface NetworkNode {
    id: string;
    label: string;
    type: NodeType;
    x?: number;
    y?: number;
    status: NodeStatus;
    properties?: Record<string, any>;
    icon?: string;
    color?: string;
    size?: 'small' | 'medium' | 'large';
    metadata?: {
        ip?: string;
        mac?: string;
        os?: string;
        version?: string;
        uptime?: number;
        description?: string;
    };
}
interface NetworkEdge {
    id: string;
    source: string;
    target: string;
    type: EdgeType;
    status: EdgeStatus;
    label?: string;
    properties?: Record<string, any>;
    color?: string;
    style?: 'solid' | 'dashed' | 'dotted';
    weight?: number;
    bidirectional?: boolean;
    metadata?: {
        protocol?: string;
        port?: number;
        bandwidth?: string;
        latency?: number;
        packetLoss?: number;
    };
}
type NodeType = 'server' | 'workstation' | 'router' | 'switch' | 'firewall' | 'database' | 'cloud' | 'mobile' | 'printer' | 'camera' | 'sensor' | 'unknown';
type EdgeType = 'ethernet' | 'wifi' | 'fiber' | 'wan' | 'vpn' | 'bluetooth' | 'serial' | 'usb' | 'api' | 'unknown';
type NodeStatus = 'online' | 'offline' | 'warning' | 'error' | 'unknown';
type EdgeStatus = 'active' | 'inactive' | 'congested' | 'error' | 'unknown';
interface NetworkTopology {
    nodes: NetworkNode[];
    edges: NetworkEdge[];
    metadata?: {
        name?: string;
        description?: string;
        created?: Date;
        updated?: Date;
        version?: string;
    };
}
interface NetworkVisualizerOptions {
    width: number;
    height: number;
    showLabels?: boolean;
    showStatus?: boolean;
    showMetrics?: boolean;
    interactive?: boolean;
    layout?: LayoutType;
    animation?: boolean;
    clustering?: boolean;
    zoom?: boolean;
    pan?: boolean;
    selection?: boolean;
    theme?: NetworkTheme;
    asciiStyle?: boolean;
    gridSize?: number;
    nodeSpacing?: number;
    edgeLength?: number;
    soundEffects?: boolean;
}
type LayoutType = 'force' | 'hierarchical' | 'circular' | 'grid' | 'manual' | 'tree';
interface NetworkTheme {
    name: string;
    colors: {
        background: string;
        grid: string;
        text: string;
        border: string;
        nodeOnline: string;
        nodeOffline: string;
        nodeWarning: string;
        nodeError: string;
        edgeActive: string;
        edgeInactive: string;
        edgeCongested: string;
        edgeError: string;
        selection: string;
        hover: string;
    };
    ascii: {
        nodeChars: {
            server: string;
            workstation: string;
            router: string;
            switch: string;
            firewall: string;
            database: string;
            cloud: string;
            mobile: string;
            printer: string;
            camera: string;
            sensor: string;
            unknown: string;
        };
        edgeChars: {
            horizontal: string;
            vertical: string;
            corner: string;
            junction: string;
            arrow: string;
        };
        statusChars: {
            online: string;
            offline: string;
            warning: string;
            error: string;
            unknown: string;
        };
    };
}
interface NetworkEvent {
    type: NetworkEventType;
    nodeId?: string;
    edgeId?: string;
    data?: any;
    timestamp: Date;
}
type NetworkEventType = 'node-click' | 'node-hover' | 'node-select' | 'edge-click' | 'edge-hover' | 'edge-select' | 'background-click' | 'zoom-change' | 'pan-change' | 'layout-change';
interface NetworkPosition {
    x: number;
    y: number;
}
interface NetworkBounds {
    minX: number;
    maxX: number;
    minY: number;
    maxY: number;
}
declare const ASCII_NETWORK_THEMES: Record<string, NetworkTheme>;
declare const DEFAULT_NETWORK_OPTIONS: NetworkVisualizerOptions;

/**
 * Layout algorithms for network visualization
 */
declare class NetworkLayoutEngine {
    private nodes;
    private edges;
    private width;
    private height;
    constructor(topology: NetworkTopology, width: number, height: number);
    /**
     * Apply force-directed layout
     */
    applyForceLayout(iterations?: number): NetworkNode[];
    /**
     * Apply hierarchical layout
     */
    applyHierarchicalLayout(): NetworkNode[];
    /**
     * Apply circular layout
     */
    applyCircularLayout(): NetworkNode[];
    /**
     * Apply grid layout
     */
    applyGridLayout(): NetworkNode[];
    /**
     * Apply tree layout
     */
    applyTreeLayout(): NetworkNode[];
    private buildTree;
    private positionTree;
    /**
     * Get layout by type
     */
    applyLayout(type: LayoutType): NetworkNode[];
}
/**
 * Calculate distance between two points
 */
declare const calculateDistance: (p1: NetworkPosition, p2: NetworkPosition) => number;
/**
 * Calculate network bounds
 */
declare const calculateNetworkBounds: (nodes: NetworkNode[]) => NetworkBounds;
/**
 * Generate sample network data
 */
declare const generateSampleNetwork: () => NetworkTopology;
/**
 * Export network to different formats
 */
declare const exportNetwork: (topology: NetworkTopology, format: "json" | "dot" | "gml" | "csv") => string;
/**
 * Network analysis utilities
 */
declare const analyzeNetwork: (topology: NetworkTopology) => {
    nodeCount: number;
    edgeCount: number;
    density: number;
    avgDegree: number;
    maxDegree: number;
    hubs: {
        nodeId: string;
        degree: number;
    }[];
};

interface AsciiNetworkVisualizerProps {
    topology: NetworkTopology;
    options?: Partial<NetworkVisualizerOptions>;
    onNodeClick?: (node: NetworkNode) => void;
    onNodeHover?: (node: NetworkNode | null) => void;
    onEdgeClick?: (edge: NetworkEdge) => void;
    onEdgeHover?: (edge: NetworkEdge | null) => void;
    onNetworkEvent?: (event: NetworkEvent) => void;
    className?: string;
    style?: React__default.CSSProperties;
}
declare const AsciiNetworkVisualizer: React__default.FC<AsciiNetworkVisualizerProps>;

interface UseNetworkVisualizerState {
    topology: NetworkTopology;
    selectedNodes: string[];
    selectedEdges: string[];
    hoveredNode: string | null;
    hoveredEdge: string | null;
    isLoading: boolean;
    error: string | null;
    layoutApplied: boolean;
}
interface UseNetworkVisualizerActions {
    updateTopology: (topology: NetworkTopology) => void;
    addNode: (node: NetworkNode) => void;
    updateNode: (nodeId: string, updates: Partial<NetworkNode>) => void;
    removeNode: (nodeId: string) => void;
    addEdge: (edge: NetworkEdge) => void;
    updateEdge: (edgeId: string, updates: Partial<NetworkEdge>) => void;
    removeEdge: (edgeId: string) => void;
    selectNode: (nodeId: string, multiSelect?: boolean) => void;
    selectEdge: (edgeId: string, multiSelect?: boolean) => void;
    clearSelection: () => void;
    applyLayout: (layoutType: string, options?: any) => void;
    importTopology: (data: string, format: 'json' | 'csv') => Promise<void>;
    exportTopology: (format: 'json' | 'dot' | 'gml' | 'csv') => string;
}
/**
 * Main hook for network visualization functionality
 */
declare const useNetworkVisualizer: (initialTopology?: NetworkTopology, options?: NetworkVisualizerOptions) => UseNetworkVisualizerState & UseNetworkVisualizerActions;
/**
 * Hook for network analysis and metrics
 */
declare const useNetworkAnalysis: (topology: NetworkTopology) => {
    analysis: any;
    isAnalyzing: boolean;
    runAnalysis: () => void;
};
/**
 * Hook for real-time network monitoring
 */
declare const useNetworkMonitoring: () => {
    isMonitoring: boolean;
    events: NetworkEvent[];
    metrics: Record<string, any>;
    startMonitoring: (topology: NetworkTopology, updateInterval?: number, onUpdate?: (topology: NetworkTopology) => void) => void;
    stopMonitoring: () => void;
    clearEvents: () => void;
};
/**
 * Hook for network path finding
 */
declare const useNetworkPaths: (topology: NetworkTopology) => {
    findPath: (sourceId: string, targetId: string) => string[] | null;
    findAllPaths: (sourceId: string, targetId: string) => string[][];
};

interface ChartDataPoint {
    label: string;
    value: number;
    color?: string;
}
interface ChartConfig {
    width?: number;
    height?: number;
    showLabels?: boolean;
    showValues?: boolean;
    showGrid?: boolean;
    animate?: boolean;
    animationDuration?: number;
}
interface BarChartProps extends React.HTMLAttributes<HTMLDivElement> {
    data: ChartDataPoint[];
    config?: ChartConfig;
    orientation?: 'horizontal' | 'vertical';
    maxBarLength?: number;
}
interface LineChartProps extends React.HTMLAttributes<HTMLDivElement> {
    data: ChartDataPoint[];
    config?: ChartConfig;
    smooth?: boolean;
    fill?: boolean;
}
interface SparklineProps extends React.HTMLAttributes<HTMLSpanElement> {
    data: number[];
    width?: number;
    height?: number;
    color?: string;
    showTrend?: boolean;
}
interface DonutChartProps extends React.HTMLAttributes<HTMLDivElement> {
    data: ChartDataPoint[];
    innerRadius?: number;
    showPercentages?: boolean;
    showLegend?: boolean;
}
type ChartType = 'bar' | 'line' | 'sparkline' | 'donut';

declare const AsciiBarChart: React__default.FC<BarChartProps>;

declare const AsciiLineChart: React__default.FC<LineChartProps>;

declare const AsciiSparkline: React__default.FC<SparklineProps>;

declare const AsciiDonutChart: React__default.FC<DonutChartProps>;

interface ValidationRule {
    type: 'required' | 'email' | 'minLength' | 'maxLength' | 'pattern' | 'custom';
    value?: string | number | RegExp;
    message: string;
    validator?: (value: any) => boolean;
}
interface FormField {
    name: string;
    label: string;
    type: 'text' | 'email' | 'password' | 'number' | 'textarea' | 'select' | 'checkbox' | 'radio';
    placeholder?: string;
    defaultValue?: any;
    options?: Array<{
        value: string | number;
        label: string;
    }>;
    validation?: ValidationRule[];
    disabled?: boolean;
    hidden?: boolean;
    width?: 'full' | 'half' | 'third' | 'quarter';
    description?: string;
}
interface FormStep {
    id: string;
    title: string;
    description?: string;
    fields: FormField[];
    validation?: (values: Record<string, any>) => Record<string, string>;
}
interface FormError {
    field: string;
    message: string;
}
interface FormState {
    values: Record<string, any>;
    errors: Record<string, string>;
    touched: Record<string, boolean>;
    isSubmitting: boolean;
    isValid: boolean;
}
interface MultiStepFormProps extends React.HTMLAttributes<HTMLFormElement> {
    steps: FormStep[];
    onSubmit: (values: Record<string, any>) => Promise<void> | void;
    onStepChange?: (step: number, values: Record<string, any>) => void;
    initialValues?: Record<string, any>;
    showProgress?: boolean;
    allowSkipSteps?: boolean;
    submitButtonText?: string;
    nextButtonText?: string;
    prevButtonText?: string;
}
interface SingleFormProps extends React.HTMLAttributes<HTMLFormElement> {
    fields: FormField[];
    onSubmit: (values: Record<string, any>) => Promise<void> | void;
    initialValues?: Record<string, any>;
    submitButtonText?: string;
    resetButtonText?: string;
    showReset?: boolean;
}

declare const AsciiForm: React__default.FC<SingleFormProps>;

declare const AsciiMultiStepForm: React__default.FC<MultiStepFormProps>;

interface AsciiFormFieldProps {
    field: FormField;
    value: any;
    error?: string;
    touched?: boolean;
    onChange: (value: any) => void;
    onBlur?: () => void;
}
declare const AsciiFormField: React__default.FC<AsciiFormFieldProps>;

declare const validateField: (value: any, rules?: ValidationRule[]) => string | null;
declare const validateRule: (value: any, rule: ValidationRule) => string | null;
declare const validateForm: (values: Record<string, any>, fields: FormField[]) => Record<string, string>;
declare const isFormValid: (errors: Record<string, string>) => boolean;
declare const createValidationRules: {
    required: (message?: string) => ValidationRule;
    email: (message?: string) => ValidationRule;
    minLength: (min: number, message?: string) => ValidationRule;
    maxLength: (max: number, message?: string) => ValidationRule;
    pattern: (regex: RegExp, message: string) => ValidationRule;
    custom: (validator: (value: any) => boolean, message: string) => ValidationRule;
};

interface AsciiGridProps extends React__default.HTMLAttributes<HTMLDivElement> {
    columns?: number | {
        sm?: number;
        md?: number;
        lg?: number;
        xl?: number;
    };
    gap?: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | number;
    rows?: number | 'auto';
    alignItems?: 'start' | 'center' | 'end' | 'stretch';
    justifyContent?: 'start' | 'center' | 'end' | 'between' | 'around' | 'evenly';
    autoFit?: boolean;
    minColumnWidth?: string;
}
interface AsciiGridItemProps extends React__default.HTMLAttributes<HTMLDivElement> {
    colSpan?: number | {
        sm?: number;
        md?: number;
        lg?: number;
        xl?: number;
    };
    rowSpan?: number;
    colStart?: number;
    colEnd?: number;
    rowStart?: number;
    rowEnd?: number;
    order?: number;
}
declare const AsciiGrid: React__default.FC<AsciiGridProps>;
declare const AsciiGridItem: React__default.FC<AsciiGridItemProps>;

interface AsciiContainerProps extends React__default.HTMLAttributes<HTMLDivElement> {
    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'full' | 'auto';
    padding?: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'none';
    border?: boolean | 'single' | 'double' | 'thick' | 'dashed';
    title?: string;
    centered?: boolean;
    fluid?: boolean;
    rounded?: boolean;
}
declare const AsciiContainer: React__default.FC<AsciiContainerProps>;

interface AsciiBoxProps extends React__default.HTMLAttributes<HTMLDivElement> {
    direction?: 'row' | 'column' | 'row-reverse' | 'column-reverse';
    wrap?: boolean | 'reverse';
    gap?: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | number;
    alignItems?: 'start' | 'center' | 'end' | 'stretch' | 'baseline';
    justifyContent?: 'start' | 'center' | 'end' | 'between' | 'around' | 'evenly';
    alignContent?: 'start' | 'center' | 'end' | 'stretch' | 'between' | 'around';
    flex?: string | number;
    grow?: number;
    shrink?: number;
    basis?: string;
    padding?: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'none';
    margin?: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'none';
}
declare const AsciiBox: React__default.FC<AsciiBoxProps>;
declare const AsciiStack: React__default.FC<Omit<AsciiBoxProps, 'direction'>>;
declare const AsciiInline: React__default.FC<Omit<AsciiBoxProps, 'direction'>>;
declare const AsciiCenter: React__default.FC<AsciiBoxProps>;
declare const AsciiSpacer: React__default.FC<{
    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | number;
}>;

interface AsciiWindowProps extends React__default.HTMLAttributes<HTMLDivElement> {
    title?: string;
    closable?: boolean;
    minimizable?: boolean;
    maximizable?: boolean;
    resizable?: boolean;
    draggable?: boolean;
    initialWidth?: number;
    initialHeight?: number;
    minWidth?: number;
    minHeight?: number;
    maxWidth?: number;
    maxHeight?: number;
    onClose?: () => void;
    onMinimize?: () => void;
    onMaximize?: () => void;
    onRestore?: () => void;
    defaultPosition?: {
        x: number;
        y: number;
    };
    zIndex?: number;
}
declare const AsciiWindow: React__default.FC<AsciiWindowPro