import { default as default_2 } from 'react';
import { ForwardRefExoticComponent } from 'react';
import { NiceBaseProps } from '@nice2dev/ui-core';
import { NiceDataSource } from '@nice2dev/ui-core';
import { NiceEditorSize } from '@nice2dev/ui-core';
import { NiceFormFieldProps } from '@nice2dev/ui-core';
import { NiceOption } from '@nice2dev/ui-core';
import { NiceSize } from '@nice2dev/ui-core';
import { RefAttributes } from 'react';
import { TracelessMode } from '@nice2dev/ui-core';

/** An accounting account entry. */
declare interface AccountEntry {
    /** Account number/code (e.g. "100", "200-01"). */
    code: string;
    /** Account name. */
    name: string;
    /** Account type. */
    type?: 'asset' | 'liability' | 'equity' | 'revenue' | 'expense';
    /** Parent account code (for hierarchical display). */
    parentCode?: string;
    /** Children (for tree support). */
    children?: AccountEntry[];
    /** Whether the account is active. */
    isActive?: boolean;
}

/** Address field definition within a NiceAddressInput. */
declare interface AddressValue {
    street?: string;
    streetNumber?: string;
    apartment?: string;
    city?: string;
    postalCode?: string;
    state?: string;
    country?: string;
}

declare type Annotation = RectangleAnnotation | EllipseAnnotation | ArrowAnnotation | LineAnnotation | TextAnnotation | FreehandAnnotation | BlurAnnotation;

declare interface AnnotationBase {
    id: string;
    tool: AnnotationTool;
    style: AnnotationStyle;
    /** Position and size in image coordinates (not screen coordinates) */
    x: number;
    y: number;
    width: number;
    height: number;
}

declare interface AnnotationStyle {
    strokeColor: string;
    fillColor: string;
    strokeWidth: number;
    opacity: number;
    fontSize?: number;
    fontFamily?: string;
}

declare type AnnotationTool = 'select' | 'rectangle' | 'ellipse' | 'arrow' | 'line' | 'text' | 'freehand' | 'blur';

/** Annotation tool type. */
declare type AnnotationTool_2 = 'highlight' | 'underline' | 'strikethrough' | 'freehand' | 'text' | 'rect' | 'arrow' | 'stamp';

declare interface ArrowAnnotation extends AnnotationBase {
    tool: 'arrow';
    endX: number;
    endY: number;
}

declare type AspectRatio = 'free' | '1:1' | '4:3' | '3:4' | '16:9' | '9:16' | '3:2' | '2:3' | 'custom';

declare interface AspectRatioPreset {
    label: string;
    value: AspectRatio;
    ratio?: number;
}

declare interface BlurAnnotation extends AnnotationBase {
    tool: 'blur';
    intensity: number;
}

declare interface ChunkInfo {
    index: number;
    start: number;
    end: number;
    uploaded: boolean;
    retries: number;
}

/** A contact entry (person or company). */
declare interface ContactEntry {
    id: string | number;
    name: string;
    type?: 'person' | 'company';
    email?: string;
    phone?: string;
    avatarUrl?: string;
    subtitle?: string;
}

declare interface Country {
    code: string;
    name: string;
    dialCode: string;
    flag: string;
}

declare interface CropArea {
    x: number;
    y: number;
    width: number;
    height: number;
}

declare interface CropResult {
    crop: CropArea;
    rotation: number;
    flipH: boolean;
    flipV: boolean;
    zoom: number;
}

/** Currency definition. */
export declare interface CurrencyDef {
    code: string;
    symbol: string;
    name: string;
    decimals?: number;
}

declare interface CustomEmoji {
    id: string;
    name: string;
    url: string;
}

declare interface EllipseAnnotation extends AnnotationBase {
    tool: 'ellipse';
}

declare interface Emoji {
    emoji: string;
    name: string;
    category: string;
    keywords?: string[];
    skinTones?: boolean;
}

export declare const EMOJI_DATA: Emoji[];

declare type EmojiCategory = 'recent' | 'smileys' | 'people' | 'animals' | 'food' | 'travel' | 'activities' | 'objects' | 'symbols' | 'flags';

declare interface FileInfo {
    id: string;
    file: File;
    name: string;
    size: number;
    type: string;
    status: UploadStatus;
    progress: number;
    error?: string;
    previewUrl?: string;
    uploadedUrl?: string;
    uploadedAt?: Date;
    chunks?: ChunkInfo[];
}

declare interface FileItemActions {
    upload: () => void;
    cancel: () => void;
    retry: () => void;
    remove: () => void;
}

declare interface FreehandAnnotation extends AnnotationBase {
    tool: 'freehand';
    points: {
        x: number;
        y: number;
    }[];
}

/** A single invoice/order line item. */
declare interface InvoiceLine {
    id: string | number;
    description: string;
    quantity: number;
    unitPrice: number;
    vatRate?: number;
    discount?: number;
    unit?: string;
    /** Computed net amount (quantity × unitPrice − discount). Auto-calculated. */
    netAmount?: number;
    /** Computed gross amount (net + VAT). Auto-calculated. */
    grossAmount?: number;
}

/** Invoice totals. */
declare interface InvoiceTotals {
    totalNet: number;
    totalVat: number;
    totalGross: number;
    vatBreakdown: Array<{
        rate: number;
        base: number;
        amount: number;
    }>;
}

declare interface LineAnnotation extends AnnotationBase {
    tool: 'line';
    endX: number;
    endY: number;
}

export declare const MASK_PRESETS: Record<NiceMaskPreset, string>;

/** All built-in style preset keys (export for convenience when populating the `presets` prop). */
export declare const NICE_COLOR_PRESET_KEYS: NiceColorPreset[];

/**
 * {@link NiceAccountPicker} — Accounting account selector with search,
 * tree view support, and account type indicators.
 */
export declare const NiceAccountPicker: default_2.ForwardRefExoticComponent<NiceAccountPickerProps & default_2.RefAttributes<HTMLDivElement>>;

/** Props for the {@link NiceAccountPicker} component. */
export declare interface NiceAccountPickerProps extends NiceFormFieldProps {
    /** Selected account code. */
    value?: string;
    /** Fires when selection changes. */
    onChange?: (code: string, account: AccountEntry) => void;
    /** Available accounts (flat or tree). */
    accounts: AccountEntry[];
    /** Whether to display as a tree. */
    treeView?: boolean;
    /** Placeholder. */
    placeholder?: string;
    /** Whether to allow search/filter. */
    searchable?: boolean;
    /** Whether to show account type indicator. */
    showType?: boolean;
    /** Fires on search query change. */
    onSearch?: (query: string) => void;
}

/**
 * {@link NiceAddressInput} — A structured address entry form with street, city, postal code, state and country fields.
 * Supports custom layouts, field visibility, country selection, and postal code validation.
 */
export declare const NiceAddressInput: default_2.ForwardRefExoticComponent<NiceAddressInputProps & default_2.RefAttributes<HTMLDivElement>>;

/** Props for the {@link NiceAddressInput} component — a structured address entry form. */
export declare interface NiceAddressInputProps extends NiceFormFieldProps {
    /** Controlled address value. */
    value?: AddressValue;
    /** Fires when any address field changes. */
    onChange?: (value: AddressValue) => void;
    /** Visible fields — by default all are shown. */
    fields?: Array<keyof AddressValue>;
    /** Placeholder overrides per field. */
    placeholders?: Partial<Record<keyof AddressValue, string>>;
    /** Available countries list (ISO 3166-1 alpha-2 codes). If provided, shows a select for the country field. */
    countries?: Array<{
        code: string;
        name: string;
    }>;
    /** Layout orientation. */
    layout?: 'vertical' | 'horizontal' | 'compact';
    /** Whether to show country field first (common in EU forms). */
    countryFirst?: boolean;
    /** Callback for postal code validation — return error message or undefined. */
    validatePostalCode?: (code: string, country?: string) => string | undefined;
}

export declare const NiceAutocomplete: default_2.FC<NiceAutocompleteProps>;

/** Props for the {@link NiceAutocomplete} component — a text input with filtered suggestion dropdown and optional multi-select. */
export declare interface NiceAutocompleteProps extends NiceFormFieldProps {
    options: NiceOption[];
    /** Single value or array of values if multiple=true. */
    value: string | string[];
    onChange?: (value: string | string[]) => void;
    minSearchLength?: number;
    maxResults?: number;
    onSearch?: (query: string) => void;
    clearable?: boolean;
    loading?: boolean;
    /** Enable multiple selection mode (tag-style). */
    multiple?: boolean;
    /** Custom render function for suggestion items. */
    renderOption?: (option: NiceOption, query: string) => default_2.ReactNode;
    /** Highlight matching text in suggestions (default true). */
    highlightMatch?: boolean;
    /** Alias for options — array of string suggestions. */
    suggestions?: (string | NiceOption)[];
}

export declare const NiceCalendar: default_2.FC<NiceCalendarProps>;

/** Props for the {@link NiceCalendar} component — an inline month calendar with day/month/year views and multi-select support. */
export declare interface NiceCalendarProps extends NiceBaseProps, TracelessStorageProps {
    /** Single selected date (ISO). Use together with onChange for single-select mode. */
    value?: string;
    onChange?: (date: string) => void;
    min?: string;
    max?: string;
    disabledDates?: string[];
    firstDayOfWeek?: 0 | 1;
    size?: NiceSize;
    showWeekNumbers?: boolean;
    onMonthChange?: (year: number, month: number) => void;
    /** Enable multiple date selection. onChange fires for the toggled date; use selectedDates for full list. */
    multiple?: boolean;
    /** Array of selected dates when multiple=true. */
    selectedDates?: string[];
    onSelectedDatesChange?: (dates: string[]) => void;
    /** Custom render for day cells. Return ReactNode to replace default number. */
    renderDay?: (date: string, day: number) => default_2.ReactNode;
    /** Show keyboard hints. */
    showKeyboardHints?: boolean;
    /** Persist view preferences (requires Traceless storage props) */
    persistPreferences?: boolean;
    /** When true, the calendar fills the available horizontal space of its container. Default false (sized to content). */
    fullWidth?: boolean;
}

export declare type NiceCalendarView = 'days' | 'months' | 'years' | 'decade';

export declare const NiceCheckbox: default_2.ForwardRefExoticComponent<NiceCheckboxProps & default_2.RefAttributes<HTMLInputElement>>;

/** Props for the {@link NiceCheckbox} component. */
export declare interface NiceCheckboxProps extends NiceBaseProps {
    /** Checkbox label. */
    label?: default_2.ReactNode;
    /** Controlled checked state. */
    checked?: boolean;
    /** Show a horizontal dash (tri-state). */
    indeterminate?: boolean;
    /** Called with the new checked value on toggle. */
    onChange?: (checked: boolean) => void;
    /** Disables the checkbox. */
    disabled?: boolean;
    /** Visual size. */
    size?: NiceSize;
    /** HTML name attribute. */
    name?: string;
    /** Validation error message. */
    error?: string;
    /** Assistive text shown below the field. */
    helperText?: string;
    /** Marks the field as required. */
    required?: boolean;
    /** Read-only mode. */
    readOnly?: boolean;
    /** Shows a loading spinner inside the control and disables interaction. */
    loading?: boolean;
    /** Show keyboard shortcuts hint. */
    showKeyboardHints?: boolean;
    /** Label position: 'right' (default — to the right of the box) or 'left'. */
    labelPlacement?: 'right' | 'left';
    /** Error/validation position: 'bottom' (default) or 'right'. */
    errorPlacement?: 'bottom' | 'right';
    /** Explicit width for the label column when labelPlacement is 'left'. */
    labelWidth?: string | number;
    /** Explicit width for the control column. */
    controlWidth?: string | number;
}

declare interface NiceCodeCompletionItem {
    /** Label displayed in completion list */
    label: string;
    /** Kind of completion */
    kind: 'text' | 'method' | 'function' | 'constructor' | 'field' | 'variable' | 'class' | 'interface' | 'module' | 'property' | 'keyword' | 'snippet' | 'color' | 'file' | 'reference' | 'folder';
    /** Text to insert */
    insertText: string;
    /** Is snippet (with placeholders) */
    insertTextRules?: 'insertAsSnippet';
    /** Documentation */
    documentation?: string;
    /** Detail */
    detail?: string;
}

declare interface NiceCodeDecoration {
    /** Line range */
    range: {
        startLineNumber: number;
        startColumn: number;
        endLineNumber: number;
        endColumn: number;
    };
    /** CSS class for the decoration */
    className?: string;
    /** Glyph margin class */
    glyphMarginClassName?: string;
    /** Hover message */
    hoverMessage?: string;
    /** Is whole line decoration */
    isWholeLine?: boolean;
}

export declare const NiceCodeEditor: default_2.ForwardRefExoticComponent<NiceCodeEditorProps & default_2.RefAttributes<NiceCodeEditorRef>>;

export declare const NiceCodeEditorAI: default_2.ForwardRefExoticComponent<NiceCodeEditorAIProps & default_2.RefAttributes<NiceCodeEditorAIRef>>;

export declare interface NiceCodeEditorAIProps extends Omit<NiceCodeEditorProps, 'ref'> {
    /** Enable AI features (requires NiceAIProvider) */
    enableAI?: boolean;
    /** AI model to use */
    aiModel?: string;
    /** Enable inline completions (ghost text) */
    enableInlineCompletion?: boolean;
    /** Delay before triggering completion (ms) */
    completionDelay?: number;
    /** Enable explain selection action */
    enableExplain?: boolean;
    /** Enable refactor action */
    enableRefactor?: boolean;
    /** Enable generate from comment action */
    enableGenerate?: boolean;
    /** Custom AI system prompt */
    systemPrompt?: string;
    /** Callback when AI explanation is generated */
    onExplain?: (code: string, explanation: string) => void;
    /** Callback when AI refactoring is generated */
    onRefactor?: (original: string, refactored: string) => void;
    /** Show AI toolbar */
    showAIToolbar?: boolean;
    /** AI keyboard shortcut modifier */
    aiShortcutKey?: 'Ctrl' | 'Alt' | 'Meta';
}

declare interface NiceCodeEditorAIRef extends NiceCodeEditorRef {
    /** Trigger AI completion */
    triggerCompletion: () => Promise<void>;
    /** Explain selected code */
    explainSelection: () => Promise<string>;
    /** Refactor selected code */
    refactorSelection: (instruction: string) => Promise<string>;
    /** Generate code from comment */
    generateFromComment: () => Promise<void>;
    /** Accept current completion */
    acceptCompletion: () => void;
    /** Dismiss current completion */
    dismissCompletion: () => void;
}

declare interface NiceCodeEditorOptions {
    /** Read only mode */
    readOnly?: boolean;
    /** Show minimap */
    minimap?: boolean;
    /** Show line numbers */
    lineNumbers?: boolean | 'on' | 'off' | 'relative' | 'interval';
    /** Word wrap */
    wordWrap?: 'off' | 'on' | 'wordWrapColumn' | 'bounded';
    /** Tab size */
    tabSize?: number;
    /** Insert spaces instead of tabs */
    insertSpaces?: boolean;
    /** Font size */
    fontSize?: number;
    /** Font family */
    fontFamily?: string;
    /** Font ligatures */
    fontLigatures?: boolean;
    /** Cursor style */
    cursorStyle?: 'line' | 'block' | 'underline' | 'line-thin' | 'block-outline' | 'underline-thin';
    /** Cursor blinking */
    cursorBlinking?: 'blink' | 'smooth' | 'phase' | 'expand' | 'solid';
    /** Auto closing brackets */
    autoClosingBrackets?: 'always' | 'languageDefined' | 'beforeWhitespace' | 'never';
    /** Auto closing quotes */
    autoClosingQuotes?: 'always' | 'languageDefined' | 'beforeWhitespace' | 'never';
    /** Format on paste */
    formatOnPaste?: boolean;
    /** Format on type */
    formatOnType?: boolean;
    /** Render whitespace */
    renderWhitespace?: 'none' | 'boundary' | 'selection' | 'trailing' | 'all';
    /** Render control characters */
    renderControlCharacters?: boolean;
    /** Scroll beyond last line */
    scrollBeyondLastLine?: boolean;
    /** Smooth scrolling */
    smoothScrolling?: boolean;
    /** Folding */
    folding?: boolean;
    /** Show fold controls */
    showFoldingControls?: 'always' | 'never' | 'mouseover';
    /** Bracket pair colorization */
    bracketPairColorization?: boolean;
    /** Guides for brackets */
    guides?: {
        bracketPairs?: boolean;
        indentation?: boolean;
        highlightActiveIndentation?: boolean;
    };
    /** Sticky scroll (shows current scope) */
    stickyScroll?: boolean;
    /** Quick suggestions */
    quickSuggestions?: boolean | {
        other?: boolean;
        comments?: boolean;
        strings?: boolean;
    };
    /** Suggest on trigger characters */
    suggestOnTriggerCharacters?: boolean;
    /** Accept suggestion on enter */
    acceptSuggestionOnEnter?: 'on' | 'smart' | 'off';
    /** Inlay hints */
    inlayHints?: boolean;
}

export declare interface NiceCodeEditorProps {
    /** Editor layout size (minimal / compact / standard / fullscreen). */
    editorSize?: NiceEditorSize;
    /** Code value */
    value: string;
    /** Value change callback */
    onChange?: (value: string) => void;
    /** Language */
    language?: NiceCodeLanguage;
    /** Theme */
    theme?: NiceCodeTheme;
    /** Editor options */
    options?: NiceCodeEditorOptions;
    /** Height */
    height?: number | string;
    /** Width */
    width?: number | string;
    /** Error markers */
    markers?: NiceCodeMarker[];
    /** Decorations */
    decorations?: NiceCodeDecoration[];
    /** Completion provider */
    completionProvider?: (model: unknown, position: unknown) => NiceCodeCompletionItem[] | Promise<NiceCodeCompletionItem[]>;
    /** On editor mount callback */
    onMount?: (editor: unknown, monaco: unknown) => void;
    /** On cursor position change */
    onCursorPositionChange?: (position: {
        lineNumber: number;
        column: number;
    }) => void;
    /** On selection change */
    onSelectionChange?: (selection: {
        startLineNumber: number;
        startColumn: number;
        endLineNumber: number;
        endColumn: number;
    }) => void;
    /** On save (Ctrl+S) */
    onSave?: (value: string) => void;
    /** Loading content */
    loading?: default_2.ReactNode;
    /** Disabled state */
    disabled?: boolean;
    /** Show toolbar at top */
    showToolbar?: boolean;
    /** Show status bar at bottom */
    showStatusBar?: boolean;
    /** Additional CSS class */
    className?: string;
    /** Test ID */
    'data-testid'?: string;
}

declare interface NiceCodeEditorRef {
    /** Get editor instance */
    getEditor: () => unknown;
    /** Get Monaco instance */
    getMonaco: () => unknown;
    /** Focus editor */
    focus: () => void;
    /** Get current value */
    getValue: () => string;
    /** Set value */
    setValue: (value: string) => void;
    /** Get selection */
    getSelection: () => string;
    /** Insert text at cursor */
    insertText: (text: string) => void;
    /** Format document */
    formatDocument: () => void;
    /** Go to line */
    goToLine: (line: number, column?: number) => void;
    /** Find and replace */
    findReplace: () => void;
    /** Undo */
    undo: () => void;
    /** Redo */
    redo: () => void;
    /** Get cursor position */
    getCursorPosition: () => {
        lineNumber: number;
        column: number;
    };
    /** Set markers (errors/warnings) */
    setMarkers: (markers: NiceCodeMarker[]) => void;
}

export declare type NiceCodeLanguage = 'javascript' | 'typescript' | 'json' | 'html' | 'css' | 'scss' | 'less' | 'markdown' | 'xml' | 'yaml' | 'sql' | 'python' | 'csharp' | 'java' | 'cpp' | 'c' | 'go' | 'rust' | 'php' | 'ruby' | 'shell' | 'powershell' | 'plaintext';

declare interface NiceCodeMarker {
    /** Start line (1-based) */
    startLineNumber: number;
    /** Start column (1-based) */
    startColumn: number;
    /** End line (1-based) */
    endLineNumber: number;
    /** End column (1-based) */
    endColumn: number;
    /** Message */
    message: string;
    /** Severity: 1=Hint, 2=Info, 4=Warning, 8=Error */
    severity: 1 | 2 | 4 | 8;
}

declare type NiceCodeTheme = 'vs' | 'vs-dark' | 'hc-black' | 'hc-light' | 'auto';

export declare const NiceColorPalette: default_2.ForwardRefExoticComponent<NiceColorPaletteProps & default_2.RefAttributes<HTMLDivElement>>;

export declare interface NiceColorPaletteProps extends NiceBaseProps {
    /** Current palette colors */
    value?: string[];
    /** Called when palette changes */
    onChange?: (colors: string[]) => void;
    /** Minimum number of colors */
    minColors?: number;
    /** Maximum number of colors */
    maxColors?: number;
    /** Color harmony mode */
    harmonyMode?: NiceHarmonyMode;
    /** Called when harmony mode changes */
    onHarmonyModeChange?: (mode: NiceHarmonyMode) => void;
    /** Analogous/split-complementary distance in degrees */
    distance?: number;
    /** Called when distance changes */
    onDistanceChange?: (d: number) => void;
    /** Color style preset */
    preset?: NiceColorPreset;
    /** Called when preset changes */
    onPresetChange?: (p: NiceColorPreset) => void;
    /** Show the color wheel */
    showWheel?: boolean;
    /** Show contrast analysis */
    showContrast?: boolean;
    /** Show color info (HSL, RGB, hex) */
    showInfo?: boolean;
    /** Show preset gallery */
    showPresets?: boolean;
    /** List of preset keys to display in the gallery. Defaults to an empty array (no preset cards shown). */
    presets?: NiceColorPreset[];
    /** Show variations (tints/shades) */
    showVariations?: boolean;
    /** Show random palette button */
    showRandom?: boolean;
    /** Number of tint/shade variations per color */
    variationCount?: number;
    /** Label */
    label?: string;
    /** Disabled state */
    disabled?: boolean;
}

export declare const NiceColorPicker: default_2.ForwardRefExoticComponent<NiceColorPickerProps & default_2.RefAttributes<HTMLInputElement>>;

export declare interface NiceColorPickerProps extends NiceFormFieldProps {
    value?: string;
    onChange?: (color: string) => void;
    presets?: string[];
    showInput?: boolean;
    showRandom?: boolean;
    /** When true, the popup includes an alpha (transparency) slider and the
     * emitted value uses 8-character hex `#RRGGBBAA`. Default: `false`. */
    withAlpha?: boolean;
}

declare type NiceColorPreset = 'lightest-pastel' | 'bright-pastel' | 'shiny' | 'pastel' | 'full' | 'dark' | 'deep' | 'muted' | 'earth';

/**
 * {@link NiceContactPicker} — Search-and-select picker for contacts (persons or companies)
 * with avatar display, async search and multi-select chip display.
 */
export declare const NiceContactPicker: default_2.ForwardRefExoticComponent<NiceContactPickerProps & default_2.RefAttributes<HTMLDivElement>>;

/** Props for the {@link NiceContactPicker} component. */
export declare interface NiceContactPickerProps extends NiceFormFieldProps {
    /** Selected contact IDs. */
    value?: Array<string | number>;
    /** Fires when selection changes. */
    onChange?: (ids: Array<string | number>) => void;
    /** Available contacts (for local filtering). */
    contacts?: ContactEntry[];
    /** Async search function (for server-side search). */
    onSearch?: (query: string) => Promise<ContactEntry[]>;
    /** Debounce delay for search (ms). */
    searchDelay?: number;
    /** Whether to allow multiple selection. */
    multiple?: boolean;
    /** Placeholder text. */
    placeholder?: string;
    /** Fires when a contact chip is clicked. */
    onContactClick?: (contact: ContactEntry) => void;
    /** Maximum selections allowed. */
    maxSelections?: number;
}

/** Built-in countdown format presets. */
declare type NiceCountdownFormat = 
/** `1d 02:34:15` / `02:34:15` — leading day count + clock */
'verbose'
/** `1d 2h 34m 15s` — abbreviated units */
| 'compact'
/** `2:34:15` / `34:15` — pure clock */
| 'short'
/** `in 2h` / `in 5m` / `in 30s` — single coarsest unit */
| 'minimal'
/** `1 day, 2 hours, 34 minutes` — verbose words */
| 'words';

export declare const NiceCountryPicker: default_2.FC<NiceCountryPickerProps>;

export declare interface NiceCountryPickerProps extends NiceFormFieldProps {
    /** Selected country code */
    value?: string;
    /** Default country code (uncontrolled) */
    defaultValue?: string;
    /** Callback when selection changes */
    onChange?: (country: Country | null) => void;
    /** Placeholder text */
    placeholder?: string;
    /** Enable search */
    showSearch?: boolean;
    /** Search placeholder */
    searchPlaceholder?: string;
    /** Show dial code */
    showDialCode?: boolean;
    /** Show flag */
    showFlag?: boolean;
    /** Filter to only show certain countries */
    countries?: string[];
    /** Priority countries shown at top */
    priorityCountries?: string[];
    /** Allow clearing selection */
    allowClear?: boolean;
    /** Size variant */
    size?: NiceSize;
    /** Test ID */
    'data-testid'?: string;
}

export declare const NiceCropEditor: default_2.FC<NiceCropEditorProps>;

export declare interface NiceCropEditorProps {
    /** Image source (URL or base64) */
    src: string;
    /** Initial crop area */
    initialCrop?: CropArea;
    /** Initial rotation (degrees) */
    initialRotation?: number;
    /** Initial zoom level (1 = 100%) */
    initialZoom?: number;
    /** Aspect ratio presets to show */
    aspectRatios?: AspectRatioPreset[];
    /** Default aspect ratio */
    defaultAspectRatio?: AspectRatio;
    /** Custom aspect ratio (for 'custom' type) */
    customAspectRatio?: number;
    /** Show rotation controls */
    showRotation?: boolean;
    /** Show flip controls */
    showFlip?: boolean;
    /** Show zoom slider */
    showZoom?: boolean;
    /** Min zoom level */
    minZoom?: number;
    /** Max zoom level */
    maxZoom?: number;
    /** Zoom step */
    zoomStep?: number;
    /** Show grid overlay */
    showGrid?: boolean;
    /** Crop overlay color */
    overlayColor?: string;
    /** Position of the controls toolbar relative to the image. Default: 'bottom'. */
    toolbarPosition?: 'top' | 'bottom' | 'left' | 'right';
    /** When true, the toolbar can be collapsed via a toggle button. Default: false. */
    toolbarCollapsible?: boolean;
    /** Initial collapsed state when `toolbarCollapsible` is true. Default: false. */
    defaultToolbarCollapsed?: boolean;
    /** Callback when crop changes */
    onChange?: (result: CropResult) => void;
    /** Extra class name */
    className?: string;
    /** Inline styles */
    style?: default_2.CSSProperties;
    /** Test ID */
    'data-testid'?: string;
}

/**
 * {@link NiceCurrencyInput} — Amount input with currency selector, locale-aware formatting.
 */
export declare const NiceCurrencyInput: default_2.ForwardRefExoticComponent<NiceCurrencyInputProps & default_2.RefAttributes<HTMLDivElement>>;

/** Props for the {@link NiceCurrencyInput} component. */
export declare interface NiceCurrencyInputProps extends NiceFormFieldProps {
    /** Controlled numeric amount (minor unit or major, based on `useMinorUnit`). */
    value?: number | null;
    /** Fires on amount change. */
    onChange?: (value: number | null) => void;
    /** Selected currency code (ISO 4217). */
    currency?: string;
    /** Fires when user changes currency. */
    onCurrencyChange?: (code: string) => void;
    /** Available currencies. */
    currencies?: CurrencyDef[];
    /** Whether to store value in minor units (cents). Default `false`. */
    useMinorUnit?: boolean;
    /** Minimum value. */
    min?: number;
    /** Maximum value. */
    max?: number;
    /** Override locale for formatting (e.g. "pl-PL"). */
    locale?: string;
    /** Placeholder text. */
    placeholder?: string;
    /** Whether to show currency selector (default `true` if currencies provided). */
    showCurrencySelector?: boolean;
    /** Fires on blur with the input event. */
    onBlur?: (e: default_2.FocusEvent<HTMLInputElement>) => void;
}

/** Predefined date-format presets. */
export declare type NiceDateFormatPreset = 'date-local' | 'date-utc' | 'datetime-local' | 'datetime-utc' | 'month-local' | 'month-utc' | 'week' | 'time';

export declare const NiceDatePicker: default_2.ForwardRefExoticComponent<NiceDatePickerProps & default_2.RefAttributes<HTMLInputElement>>;

/** Props for the {@link NiceDatePicker} component — a masked, locale-aware date/time input. */
export declare interface NiceDatePickerProps extends NiceFormFieldProps {
    /** ISO value (e.g. `'2024-06-15'`). Always ISO regardless of display locale. */
    value?: string;
    /** Fires with the new ISO value. Empty string while the input is incomplete. */
    onChange?: (value: string) => void;
    /** Native blur handler. */
    onBlur?: (e: default_2.FocusEvent<HTMLInputElement>) => void;
    /** Native keydown handler. */
    onKeyDown?: (e: default_2.KeyboardEvent<HTMLInputElement>) => void;
    /** Minimum selectable date (passed to the hidden native picker). */
    min?: string;
    /** Maximum selectable date (passed to the hidden native picker). */
    max?: string;
    /**
     * @deprecated Use `dateFormatPreset` instead.
     * Input type — `'date'`, `'datetime-local'`, `'time'`, `'month'`, or `'week'`.
     */
    type?: 'date' | 'datetime-local' | 'time' | 'month' | 'week';
    /** Date format preset. Takes precedence over `type`. */
    dateFormatPreset?: NiceDateFormatPreset;
    /** Placeholder text. Defaults to a derived placeholder (e.g. `dd.MM.yyyy`). */
    placeholder?: string;
    /** Show clear `×` button (default: `false`). Opt-in for nullable values. */
    clearable?: boolean;
    /**
     * Show a calendar / clock icon button that opens the browser's native
     * picker dialog (uses `HTMLInputElement.showPicker`). Default: `true`.
     */
    showPickerButton?: boolean;
    /**
     * BCP 47 locale used for the displayed mask of `*-local` presets. Defaults
     * to the browser locale (`navigator.language`).
     */
    displayLocale?: string;
}

export declare const NiceDateRangeBox: default_2.FC<NiceDateRangeBoxProps>;

/** Props for the {@link NiceDateRangeBox} component — a pair of date pickers for selecting a date range. */
export declare interface NiceDateRangeBoxProps extends NiceFormFieldProps {
    /** Start date (ISO string). */
    startDate: string;
    /** End date (ISO string). */
    endDate: string;
    /** Called when the start date changes. */
    onStartChange: (date: string) => void;
    /** Called when the end date changes. */
    onEndChange: (date: string) => void;
    /** Earliest selectable date. */
    min?: string;
    /** Latest selectable date. */
    max?: string;
    /** Show a clear button. */
    clearable?: boolean;
    /** Placeholder for the start input. */
    startPlaceholder?: string;
    /** Placeholder for the end input. */
    endPlaceholder?: string;
    /** Label shown above (or before) the start picker. */
    startLabel?: string;
    /** Label shown above (or before) the end picker. */
    endLabel?: string;
    /** Layout direction for the two pickers (default `horizontal`). */
    layout?: 'horizontal' | 'vertical';
    /** Custom separator rendered between pickers in horizontal layout (default `–`). Pass `''` to hide. */
    separator?: default_2.ReactNode;
    /** Gap in pixels between the two pickers (default 12). */
    gap?: number;
    /** Stretch each picker to fill available width. */
    fullWidth?: boolean;
}

export declare const NiceDateTimePicker: default_2.ForwardRefExoticComponent<NiceDateTimePickerProps & default_2.RefAttributes<HTMLDivElement>>;

/** Props for the {@link NiceDateTimePicker} component — a combined date and time picker with calendar dropdown. */
export declare interface NiceDateTimePickerProps extends NiceFormFieldProps {
    /** ISO 8601 date-time string (e.g. "2026-03-16T14:30") */
    value?: string;
    onChange?: (value: string) => void;
    onBlur?: (e: default_2.FocusEvent) => void;
    /** Minimum allowed date-time (ISO string) */
    min?: string;
    /** Maximum allowed date-time (ISO string) */
    max?: string;
    /** Display format — 12h shows AM/PM toggle, 24h shows 0–23 */
    hourFormat?: '12' | '24';
    /** Minute increment step */
    minuteStep?: number;
    /** Show seconds input */
    showSeconds?: boolean;
    /** Show "Now" quick button */
    showNow?: boolean;
    /** Show clear button */
    clearable?: boolean;
}

/** A content block in the {@link NiceDocumentEditor}. */
declare interface NiceDocumentBlock {
    id: string;
    type: NiceDocumentBlockType;
    content: string;
    level?: 1 | 2 | 3 | 4 | 5 | 6;
    listType?: 'ordered' | 'unordered' | 'checklist';
    src?: string;
    alt?: string;
    language?: string;
    align?: 'left' | 'center' | 'right';
    bold?: boolean;
    italic?: boolean;
    /** Underline text. */
    underline?: boolean;
    /** Strikethrough text. */
    strikethrough?: boolean;
    /** Block text color override. */
    color?: string;
    /** Block background color override. */
    bgColor?: string;
    /** Callout icon (emoji or class). */
    icon?: string;
    /** Toggle block: is open? */
    open?: boolean;
    /** Checklist items checked status for list blocks with listType='checklist'. */
    checked?: boolean[];
    /** Indentation level (0�4). */
    indent?: number;
    /** Lock block from editing. */
    locked?: boolean;
}

/** Block type options in the {@link NiceDocumentEditor}. */
declare type NiceDocumentBlockType = 'paragraph' | 'heading' | 'list' | 'image' | 'table' | 'divider' | 'code' | 'quote' | 'callout' | 'toggle' | 'video' | 'embed' | 'pageBreak';

export declare const NiceDocumentEditor: ForwardRefExoticComponent<NiceDocumentEditorProps & RefAttributes<HTMLDivElement>>;

/** Props for the {@link NiceDocumentEditor} component � a block-based document editor (Notion-like). */
export declare interface NiceDocumentEditorProps extends NiceBaseProps {
    blocks?: NiceDocumentBlock[];
    onChange?: (blocks: NiceDocumentBlock[]) => void;
    readOnly?: boolean;
    showToolbar?: boolean;
    size?: NiceSize;
    /** Editor layout size (minimal / compact / standard / fullscreen). */
    editorSize?: NiceEditorSize;
    placeholder?: string;
    onExport?: (html: string) => void;
    /** Called when user inserts an image via block. Return a URL string to insert. */
    onImageUpload?: (file: File) => Promise<string>;
    /** Maximum number of undo steps (default 50). */
    maxUndo?: number;
    /** Enable slash commands (default true). */
    slashCommands?: boolean;
    /** Enable word count display (default false). */
    showWordCount?: boolean;
    /** Show table of contents sidebar (default false). */
    showToc?: boolean;
    /** Show find & replace bar (Ctrl+F). */
    showFindReplace?: boolean;
}

export declare const NiceDropDownBox: default_2.FC<NiceDropDownBoxProps>;

/** Props for the {@link NiceDropDownBox} component — a generic dropdown container for custom content. */
export declare interface NiceDropDownBoxProps extends NiceFormFieldProps {
    /** Text shown in the collapsed trigger area. */
    displayValue?: string;
    /** Placeholder when no value is selected. */
    placeholder?: string;
    /** Show a clear button. */
    clearable?: boolean;
    /** Custom dropdown content (any React elements). */
    children: default_2.ReactNode;
    /** Called when the clear button is clicked. */
    onClear?: () => void;
    /** Controlled open state. */
    open?: boolean;
    /** Called when the open state changes. */
    onOpenChange?: (open: boolean) => void;
    /** Width of the dropdown panel. */
    dropdownWidth?: number | string;
}

export declare const NiceEmojiPicker: default_2.FC<NiceEmojiPickerProps>;

export declare interface NiceEmojiPickerProps {
    /** Callback when emoji is selected */
    onSelect?: (emoji: string, data: Emoji | CustomEmoji) => void;
    /** Show search box */
    showSearch?: boolean;
    /** Search placeholder */
    searchPlaceholder?: string;
    /** Show skin tone selector */
    showSkinTones?: boolean;
    /** Default skin tone index (0-5) */
    defaultSkinTone?: number;
    /** Show recently used section */
    showRecent?: boolean;
    /** Max recent emojis */
    maxRecent?: number;
    /** Recent emojis (controlled) */
    recentEmojis?: string[];
    /** Callback when recent changes */
    onRecentChange?: (recent: string[]) => void;
    /** Categories to show */
    categories?: EmojiCategory[];
    /** Custom emojis */
    customEmojis?: CustomEmoji[];
    /** Columns in emoji grid */
    columns?: number;
    /** Size variant */
    size?: NiceSize;
    /** Extra class name */
    className?: string;
    /** Inline styles */
    style?: default_2.CSSProperties;
    /** Test ID */
    'data-testid'?: string;
}

export declare const NiceFileUpload: default_2.ForwardRefExoticComponent<NiceFileUploadProps & default_2.RefAttributes<NiceFileUploadRef>>;

export declare interface NiceFileUploadProps extends NiceBaseProps {
    /** Akceptowane typy plików (np. "image/*,.pdf") */
    accept?: string;
    /** Czy pozwalać na multiple files */
    multiple?: boolean;
    /** Maksymalny rozmiar pliku w bajtach */
    maxFileSize?: number;
    /** Maksymalna liczba plików */
    maxFiles?: number;
    /** Minimalny rozmiar pliku */
    minFileSize?: number;
    /** Rozmiar chunka dla dużych plików (domyślnie 5MB) */
    chunkSize?: number;
    /** Próg rozmiaru pliku dla chunked upload (domyślnie 10MB) */
    chunkThreshold?: number;
    /** Automatycznie rozpocznij upload po dodaniu */
    autoUpload?: boolean;
    /** Handler uploadu */
    uploadHandler?: UploadHandler;
    /** URL do uploadu (jeśli nie podano uploadHandler) */
    uploadUrl?: string;
    /** Nagłówki HTTP dla uploadu */
    uploadHeaders?: Record<string, string>;
    /** Callback po dodaniu plików */
    onFilesAdded?: (files: FileInfo[]) => void;
    /** Callback po zakończeniu uploadu */
    onUploadComplete?: (file: FileInfo) => void;
    /** Callback po błędzie */
    onUploadError?: (file: FileInfo, error: string) => void;
    /** Callback na postęp */
    onProgress?: (file: FileInfo, progress: number) => void;
    /** Callback po usunięciu */
    onFileRemoved?: (file: FileInfo) => void;
    /** Callback po zmianie stanu */
    onChange?: (files: FileInfo[]) => void;
    /** Niestandardowy renderer podglądu */
    renderPreview?: (file: FileInfo) => default_2.ReactNode;
    /** Niestandardowy renderer elementu listy */
    renderFileItem?: (file: FileInfo, actions: FileItemActions) => default_2.ReactNode;
    /** Pokaż podgląd obrazów */
    showPreview?: boolean;
    /** Pokaż listę plików */
    showFileList?: boolean;
    /** Tryb wyświetlania listy */
    listMode?: 'list' | 'grid' | 'compact';
    /** Rozmiar podglądu */
    previewSize?: NiceSize;
    /** Tekst w dropzone */
    dropzoneText?: string;
    /** Tekst pod przyciskiem */
    browseText?: string;
    /** Tekst podczas dragover */
    dragActiveText?: string;
    /** Wyłączony */
    disabled?: boolean;
    /** Read-only (tylko podgląd) */
    readOnly?: boolean;
    /** Customowe klasy CSS */
    dropzoneClassName?: string;
    /** Retry count */
    maxRetries?: number;
    /** Ilość równoczesnych uploadów */
    concurrentUploads?: number;
    /** Walidator plików */
    validateFile?: (file: File) => string | null;
    /** Zachowaj pliki po uploadzięciu */
    keepFilesAfterUpload?: boolean;
    /** Początkowe pliki */
    initialFiles?: FileInfo[];
}

declare interface NiceFileUploadRef {
    addFiles: (files: File[]) => void;
    uploadAll: () => void;
    cancelAll: () => void;
    clearAll: () => void;
    getFiles: () => FileInfo[];
    getFile: (id: string) => FileInfo | undefined;
    retryFailed: () => void;
    openFileBrowser: () => void;
}

export declare const NiceForm: default_2.FC<NiceFormProps>;

/** Describes a single field in a {@link NiceForm} layout. */
declare interface NiceFormItem {
    field: string;
    label?: string;
    colSpan?: number;
    required?: boolean;
    /** Static visibility flag � set to false to always hide. */
    visible?: boolean;
    /**
     * Dynamic visibility: evaluated against current form data.
     * Example: `(data) => data.country === 'PL'`
     */
    visibleWhen?: (data: Record<string, any>) => boolean;
    render?: (value: unknown, onChange: (v: unknown) => void) => default_2.ReactNode;
    hint?: string;
    /** Group name � fields with the same group are rendered together under a section header. */
    group?: string;
    /** Tab name � fields with the same tab are rendered together under a tab. Tabs take precedence over groups for top-level structure. */
    tab?: string;
    /** Field type for auto-rendering (text, number, select, etc.). */
    type?: string;
    /** Options for select/radio type fields. */
    options?: Array<{
        label: string;
        value: string | number;
    } | string>;
    /** Mask pattern for `type: 'masked'`. */
    mask?: string;
    /** Placeholder text shown when no value is selected/entered. */
    placeholder?: string;
    /** Default value applied when no value exists in `data`. */
    defaultValue?: unknown;
    /** Disable this field individually. */
    disabled?: boolean;
    /** Render this field in read-only mode individually. */
    readOnly?: boolean;
    /** Hide this field (alias of `visible: false`). */
    hidden?: boolean;
    /**
     * Optional unit / currency code rendered as a suffix for `type: 'currency'`
     * or `type: 'number'` (e.g. `'PLN'`, `'$'`, `'kg'`). Defaults to `'PLN'`
     * for currency.
     */
    unit?: string;
    /** Decimal precision for `type: 'number'` / `type: 'currency'`. Default 2 for currency, 0 for number. */
    precision?: number;
    /** Stepper increment for `type: 'number'` / `type: 'currency'`. Default 100 for currency, 1 for number. */
    step?: number;
    /** For `type: 'address'` � render sub-fields in 1 or 2 columns. Default 2. */
    columns?: 1 | 2;
}

/** Props for the {@link NiceForm} component � a declarative, data-driven form layout. */
export declare interface NiceFormProps extends NiceBaseProps {
    items: NiceFormItem[];
    /** Inline form data. Ignored when `dataSource` + `recordKey` are provided. */
    data?: Record<string, any>;
    /** Field change callback. Ignored when `dataSource` is provided. */
    onFieldChange?: (field: string, value: unknown) => void;
    onSubmit?: (data: Record<string, any>) => void;
    /**
     * Two-way data source binding.
     * When provided together with `recordKey`, the form loads and edits
     * a single record from the source. `data`/`onFieldChange` are ignored.
     */
    dataSource?: NiceDataSource;
    /** Key of the record to load/edit. */
    recordKey?: unknown;
    columns?: number;
    /**
     * Responsive columns: map of min-width breakpoint (px) ? column count.
     * Example: `{ 0: 1, 600: 2, 1024: 3 }` ? 1 col on small, 2 on medium, 3 on large.
     */
    responsiveColumns?: Record<number, number>;
    gap?: number | string;
    labelPosition?: 'top' | 'left';
    size?: NiceSize;
    readOnly?: boolean;
    disabled?: boolean;
    /** Auto-save delay in ms. When set, form auto-saves after this many ms of inactivity. */
    autoSaveDelay?: number;
    /** Callback when dirty state changes. */
    onDirtyChange?: (isDirty: boolean) => void;
    /** When true, render Submit/Reset buttons at the bottom. */
    showActions?: boolean;
    /** Custom Submit button label. */
    submitLabel?: string;
    /** Custom Reset button label. */
    resetLabel?: string;
    /**
     * When provided, a Cancel button is rendered on the LEFT side of the
     * actions row. Used by popup hosts (NiceDataGrid edit popup, NiceKanban
     * edit popup, etc.) to dismiss the modal without submitting.
     */
    onCancel?: () => void;
    /** Custom Cancel button label. */
    cancelLabel?: string;
}

export declare const NiceGradientPicker: default_2.ForwardRefExoticComponent<NiceGradientPickerProps & default_2.RefAttributes<HTMLDivElement>>;

export declare interface NiceGradientPickerProps extends NiceBaseProps {
    value?: NiceGradientValue;
    onChange?: (value: NiceGradientValue) => void;
    /** Show CSS output field */
    showCssOutput?: boolean;
    /** Show preset gallery */
    showPresets?: boolean;
    /** Show the inline editor (type/angle/stops controls). When false, only preview/presets/random remain. */
    showEditor?: boolean;
    /** Show random button */
    showRandom?: boolean;
    /** Maximum number of gradient stops */
    maxStops?: number;
    label?: string;
    disabled?: boolean;
    /** Fixed width of the whole control. Defaults to 320px so the layout stays stable when stops are added. */
    width?: string | number;
}

declare type NiceGradientShape = 'circle' | 'ellipse';

declare type NiceGradientSizeKeyword = 'closest-side' | 'farthest-side' | 'closest-corner' | 'farthest-corner';

export declare interface NiceGradientStop {
    color: string;
    position: number;
}

declare type NiceGradientType = 'linear' | 'radial' | 'conic';

declare interface NiceGradientValue {
    type: NiceGradientType;
    angle: number;
    shape?: NiceGradientShape;
    size?: NiceGradientSizeKeyword;
    positionX?: number;
    positionY?: number;
    repeating?: boolean;
    stops: NiceGradientStop[];
}

declare type NiceHarmonyMode = 'monochromatic' | 'complementary' | 'split-complementary' | 'analogous' | 'triadic' | 'tetradic' | 'square' | 'custom';

export declare const NiceHtmlEditor: default_2.FC<NiceHtmlEditorProps>;

export declare const NiceHtmlEditorAI: default_2.ForwardRefExoticComponent<NiceHtmlEditorAIProps & default_2.RefAttributes<NiceHtmlEditorAIRef>>;

export declare interface NiceHtmlEditorAIProps extends Omit<NiceHtmlEditorProps, 'toolbar'> {
    /** Enable AI features (requires NiceAIProvider) */
    enableAI?: boolean;
    /** AI model to use */
    aiModel?: string;
    /** Enable text improvement feature */
    enableImprove?: boolean;
    /** Enable translation feature */
    enableTranslate?: boolean;
    /** Enable HTML generation from prompt */
    enableGenerate?: boolean;
    /** Custom toolbar (AI commands will be appended) */
    toolbar?: NiceHtmlEditorCommand[];
    /** Available languages for translation */
    languages?: {
        code: string;
        label: string;
    }[];
    /** Available text styles */
    textStyles?: {
        style: TextStyle;
        label: string;
    }[];
    /** Callback when AI improves text */
    onImprove?: (original: string, improved: string, style: TextStyle) => void;
    /** Callback when AI translates text */
    onTranslate?: (original: string, translated: string, targetLanguage: string) => void;
    /** Callback when AI generates HTML */
    onGenerate?: (prompt: string, html: string) => void;
    /** Show AI toolbar section */
    showAIToolbar?: boolean;
}

declare interface NiceHtmlEditorAIRef {
    /** Get editor element */
    getEditor: () => HTMLDivElement | null;
    /** Focus editor */
    focus: () => void;
    /** Get current HTML value */
    getValue: () => string;
    /** Set HTML value */
    setValue: (html: string) => void;
    /** Get selected text */
    getSelection: () => string;
    /** Insert HTML at cursor */
    insertHtml: (html: string) => void;
    /** Improve selected text */
    improveSelection: (style?: TextStyle) => Promise<string>;
    /** Translate selected text */
    translateSelection: (targetLanguage: string) => Promise<string>;
    /** Generate HTML from prompt */
    generateHtml: (prompt: string) => Promise<string>;
}

/** Available toolbar commands for the {@link NiceHtmlEditor}. */
declare type NiceHtmlEditorCommand = 'bold' | 'italic' | 'underline' | 'strikethrough' | 'h1' | 'h2' | 'h3' | 'ul' | 'ol' | 'link' | 'unlink' | 'undo' | 'redo' | 'clear' | 'table' | 'image' | 'code' | 'markdown' | 'blockquote' | 'hr' | 'fontSize' | 'fontColor' | 'bgColor' | 'subscript' | 'superscript' | 'indent' | 'outdent' | 'alignLeft' | 'alignCenter' | 'alignRight' | 'alignJustify' | 'fullscreen' | 'removeFormat' | 'print' | 'source' | 'emoji' | 'findReplace';

/** Props for the {@link NiceHtmlEditor} component � a WYSIWYG rich-text editor with toolbar, mentions, and image upload. */
export declare interface NiceHtmlEditorProps extends NiceFormFieldProps {
    value: string;
    onChange: (html: string) => void;
    placeholder?: string;
    height?: number | string;
    toolbar?: NiceHtmlEditorCommand[];
    readOnly?: boolean;
    /** Called when user selects an image via toolbar. Return a URL string to insert. */
    onImageUpload?: (file: File) => Promise<string>;
    /** Mention trigger character (default '@'). Set to enable @mentions in the editor. */
    mentionTrigger?: string;
    /** Mention suggestion items. */
    mentionSuggestions?: {
        key: string;
        label: string;
    }[];
    /** Called when mention query text changes. */
    onMentionSearch?: (query: string) => void;
    /** Called when files are dropped into the editor. */
    onFileDrop?: (files: File[]) => Promise<string[]>;
    /** Enable paste cleanup (strips Word/external formatting). */
    pasteCleanup?: boolean;
    /** Maximum content length in characters (0 = unlimited). */
    maxLength?: number;
    /** Show word count status bar. */
    showWordCount?: boolean;
    /** Templates available for insertion. */
    templates?: {
        label: string;
        html: string;
    }[];
}

declare type NiceImageAnnotationType = 'text' | 'rect' | 'circle' | 'line' | 'arrow';

export declare const NiceImageAnnotator: default_2.ForwardRefExoticComponent<NiceImageAnnotatorProps & default_2.RefAttributes<NiceImageAnnotatorRef>>;

export declare interface NiceImageAnnotatorProps {
    /** Image source (URL, data URI, or Blob URL) */
    src: string;
    /** Alt text */
    alt?: string;
    /** Initial annotations */
    annotations?: Annotation[];
    /** Active tool */
    activeTool?: AnnotationTool;
    /** Default annotation style */
    defaultStyle?: Partial<AnnotationStyle>;
    /** Callback when annotations change */
    onAnnotationsChange?: (annotations: Annotation[]) => void;
    /** Custom class name */
    className?: string;
    /** Whether the annotator is read-only */
    readOnly?: boolean;
    /** Min zoom */
    minZoom?: number;
    /** Max zoom */
    maxZoom?: number;
}

declare interface NiceImageAnnotatorRef {
    /** Export image with annotations as data URL */
    exportAsDataURL: (format?: 'png' | 'jpeg', quality?: number) => Promise<string>;
    /** Export annotations only as JSON */
    exportAnnotations: () => Annotation[];
    /** Import annotations from JSON */
    importAnnotations: (annotations: Annotation[]) => void;
    /** Export as SVG overlay string */
    exportAsSVG: () => string;
    /** Undo last annotation action */
    undo: () => void;
    /** Redo last undone action */
    redo: () => void;
    /** Set zoom level */
    setZoom: (zoom: number) => void;
    /** Fit image to viewport */
    fitToScreen: () => void;
    /** Clear all annotations */
    clear: () => void;
}

export declare const NiceImageEditor: ForwardRefExoticComponent<NiceImageEditorProps & RefAttributes<HTMLDivElement>>;

declare interface NiceImageEditorAnnotation {
    type: NiceImageAnnotationType;
    x: number;
    y: number;
    width?: number;
    height?: number;
    text?: string;
    color?: string;
    fontSize?: number;
    strokeWidth?: number;
}

/** Props for the {@link NiceImageEditor} component — an image editor with crop, rotate, flip, filters, and annotations. */
export declare interface NiceImageEditorProps extends NiceBaseProps {
    src: string;
    size?: NiceSize;
    /** Editor layout size (minimal / compact / standard / fullscreen). */
    editorSize?: NiceEditorSize;
    tools?: NiceImageEditorTool[];
    showToolbar?: boolean;
    showZoom?: boolean;
    maxUndo?: number;
    onSave?: (dataUrl: string, state: NiceImageEditorState) => void;
    onCancel?: () => void;
    onChange?: (state: NiceImageEditorState) => void;
    width?: number | string;
    height?: number | string;
}

declare interface NiceImageEditorState {
    rotation: number;
    flipH: boolean;
    flipV: boolean;
    brightness: number;
    contrast: number;
    saturate: number;
    blur: number;
    crop: {
        x: number;
        y: number;
        width: number;
        height: number;
    } | null;
    annotations: NiceImageEditorAnnotation[];
}

/** Available tools in the {@link NiceImageEditor} toolbar. */
declare type NiceImageEditorTool = 'crop' | 'rotate' | 'flip' | 'brightness' | 'contrast' | 'saturate' | 'blur' | 'annotate';

export declare const NiceInputOtp: default_2.ForwardRefExoticComponent<NiceInputOtpProps & default_2.RefAttributes<HTMLDivElement>>;

/** Props for the {@link NiceInputOtp} component — a one-time-password input with separate digit boxes. */
export declare interface NiceInputOtpProps extends NiceFormFieldProps {
    /** Number of OTP digits */
    length?: number;
    /** Current value */
    value?: string;
    onChange?: (value: string) => void;
    /** Use password dots instead of visible digits */
    masked?: boolean;
    /** Called when all digits are filled */
    onComplete?: (value: string) => void;
    autoFocus?: boolean;
    /** Width of a single digit cell (number = px). Defaults per `size`. */
    cellWidth?: number | string;
}

/**
 * {@link NiceInvoiceLineEditor} — Editable grid for invoice/order line items with auto-calculated
 * net/gross amounts, VAT breakdown, discounts and totals.
 */
export declare const NiceInvoiceLineEditor: default_2.ForwardRefExoticComponent<NiceInvoiceLineEditorProps & default_2.RefAttributes<HTMLDivElement>>;

/** Props for the {@link NiceInvoiceLineEditor} component. */
export declare interface NiceInvoiceLineEditorProps extends NiceFormFieldProps {
    /** Controlled line items. */
    value?: InvoiceLine[];
    /** Fires when lines change. */
    onChange?: (lines: InvoiceLine[]) => void;
    /** Default currency symbol for display. */
    currencySymbol?: string;
    /** Default VAT rate for new lines (e.g. 23). */
    defaultVatRate?: number;
    /** Available VAT rates for dropdown. */
    vatRates?: number[];
    /** Available units for dropdown. */
    units?: string[];
    /** Whether to show the discount column. */
    showDiscount?: boolean;
    /** Whether to show the unit column. */
    showUnit?: boolean;
    /** Whether to show totals summary row. */
    showTotals?: boolean;
    /** Whether to allow adding/removing lines. */
    editable?: boolean;
    /** Maximum number of lines. */
    maxLines?: number;
    /** Fires with computed totals whenever lines change. */
    onTotalsChange?: (totals: InvoiceTotals) => void;
}

export declare const NiceKnob: default_2.ForwardRefExoticComponent<NiceKnobProps & default_2.RefAttributes<HTMLDivElement>>;

/** Props for the {@link NiceKnob} component — a rotary knob for numeric input (SVG-based). */
export declare interface NiceKnobProps extends Omit<NiceFormFieldProps, 'size' | 'labelPlacement'> {
    value?: number;
    onChange?: (value: number) => void;
    min?: number;
    max?: number;
    step?: number;
    /** Show numeric value label */
    showValue?: boolean;
    /** Value template string, e.g. "{value}%" */
    valueTemplate?: string;
    /** Knob diameter in pixels or NiceSize preset. */
    size?: number | NiceSize;
    /** Where to place the label relative to the knob. Defaults to 'top'. */
    labelPlacement?: 'top' | 'bottom' | 'left' | 'right';
    /**
     * When true (default), centers the label horizontally over/under the knob in
     * top/bottom placements, or vertically next to the knob in left/right
     * placements. Set to false to keep the label at the start of its axis.
     */
    isLabelCentered?: boolean;
}

export declare const NiceLookup: default_2.FC<NiceLookupProps>;

/** Column definition for the mini-grid lookup mode. */
declare interface NiceLookupColumn {
    /** Field key in the row record. */
    key: string;
    /** Header label for the column. */
    header: string;
    /** Column width (CSS, e.g. '60px' or '20%'). */
    width?: string | number;
}

/** Props for the {@link NiceLookup} component — a select-like lookup with optional search or a mini data grid. */
export declare interface NiceLookupProps extends NiceFormFieldProps {
    /** Available options. Used when `data`/`columns` aren't provided. */
    options?: NiceOption[];
    /** Selected value. */
    value: string;
    /** Called when the selection changes. */
    onChange: (value: string) => void;
    /** Enable search/filter in the dropdown. */
    searchable?: boolean;
    /** Show a clear button. */
    clearable?: boolean;
    /** Show a loading spinner in the dropdown. */
    loading?: boolean;
    /** Input placeholder text. */
    placeholder?: string;
    /** Tabular data rows for the mini-grid mode. */
    data?: Record<string, unknown>[];
    /** Column definitions for the mini-grid mode. Required when `data` is provided. */
    columns?: NiceLookupColumn[];
    /** Field key in each row used as the selected value. Defaults to `'id'`. */
    valueField?: string;
    /** Field key in each row used for the displayed text. Defaults to the first column's key. */
    displayField?: string;
    /** Width of the dropdown when in mini-grid mode (CSS). */
    dropdownWidth?: string | number;
}

export declare const NiceMarkdownEditor: default_2.ForwardRefExoticComponent<NiceMarkdownEditorProps & default_2.RefAttributes<HTMLDivElement>>;

export declare interface NiceMarkdownEditorProps extends NiceBaseProps {
    value?: string;
    onChange?: (value: string) => void;
    preview?: NiceMarkdownPreviewMode | boolean;
    placeholder?: string;
    disabled?: boolean;
    readOnly?: boolean;
    size?: NiceSize;
    /** Editor layout size (minimal / compact / standard / fullscreen). */
    editorSize?: NiceEditorSize;
    toolbar?: boolean;
    minHeight?: number | string;
    showWordCount?: boolean;
    showLineNumbers?: boolean;
    onExportHtml?: (html: string) => void;
    onImageUpload?: (file: File) => Promise<string>;
}

declare type NiceMarkdownPreviewMode = 'side' | 'tab' | 'none';

export declare const NiceMaskedInput: default_2.ForwardRefExoticComponent<NiceMaskedInputProps & default_2.RefAttributes<HTMLInputElement>>;

/** Props for the {@link NiceMaskedInput} component — a text input that enforces a mask pattern (e.g. phone, credit card). */
export declare interface NiceMaskedInputProps extends NiceFormFieldProps {
    /** Raw unmasked value */
    value?: string;
    onChange?: (value: string, maskedValue: string) => void;
    onBlur?: (e: default_2.FocusEvent<HTMLInputElement>) => void;
    onKeyDown?: (e: default_2.KeyboardEvent<HTMLInputElement>) => void;
    /**
     * Mask pattern. Characters:
     * - `9` = digit (0-9)
     * - `a` = letter (a-z, A-Z)
     * - `*` = alphanumeric (a-z, A-Z, 0-9)
     * - Any other character is a literal separator
     *
     * Examples: `(999) 999-9999`, `9999 9999 9999 9999`, `99/99/9999`
     */
    mask?: string;
    /** Predefined mask preset — sets the mask pattern automatically. `mask` takes precedence. */
    maskPreset?: NiceMaskPreset;
    /** Character shown for unfilled positions (default: '_') */
    maskChar?: string;
    placeholder?: string;
    /** Show the mask pattern as placeholder when empty */
    showMaskAsPlaceholder?: boolean;
    clearable?: boolean;
    autoFocus?: boolean;
}

/** Predefined mask presets. */
export declare type NiceMaskPreset = 'phone' | 'credit-card' | 'date' | 'ssn' | 'zip' | 'time' | 'iban';

export declare const NiceMention: default_2.ForwardRefExoticComponent<NiceMentionProps & default_2.RefAttributes<HTMLTextAreaElement>>;

/** Props for the {@link NiceMention} component — a textarea with @mention triggers and suggestion popup. */
export declare interface NiceMentionProps extends NiceFormFieldProps {
    value?: string;
    onChange?: (value: string) => void;
    /** Array of suggestions or async search callback */
    suggestions?: (NiceMentionSuggestion | string)[];
    /** Async search handler */
    onSearch?: (query: string) => void;
    /** Trigger character */
    trigger?: string;
    /** Custom suggestion renderer */
    renderSuggestion?: (item: NiceMentionSuggestion) => default_2.ReactNode;
    placeholder?: string;
    rows?: number;
}

/** A suggestion item displayed in the {@link NiceMention} dropdown. */
export declare interface NiceMentionSuggestion {
    key: string;
    label: string;
    icon?: default_2.ReactNode;
    [k: string]: unknown;
}

export declare const NiceNumberInput: default_2.ForwardRefExoticComponent<NiceNumberInputProps & default_2.RefAttributes<HTMLInputElement>>;

/** Props for the {@link NiceNumberInput} component — a numeric field with stepper and precision control. */
export declare interface NiceNumberInputProps extends NiceFormFieldProps {
    /** Controlled numeric value (`null` = empty). */
    value?: number | null;
    /** Fires with the new value or `null` when cleared. */
    onChange?: (value: number | null) => void;
    /** Native blur handler. */
    onBlur?: (e: default_2.FocusEvent<HTMLInputElement>) => void;
    /** Native keydown handler. */
    onKeyDown?: (e: default_2.KeyboardEvent<HTMLInputElement>) => void;
    /** Placeholder text. */
    placeholder?: string;
    /** Minimum allowed value. */
    min?: number;
    /** Maximum allowed value. */
    max?: number;
    /** Increment/decrement step (default `1`). */
    step?: number;
    /** Decimal precision (number of fraction digits). */
    precision?: number;
    /** Prefix content (e.g. currency symbol). */
    prefix?: default_2.ReactNode;
    /** Prefix mode: 'label' (static, default) or 'select' (dropdown). */
    prefixType?: 'label' | 'select';
    /** Options for the prefix select dropdown. */
    prefixOptions?: NiceSuffixOption[];
    /** Currently selected prefix value (controlled). */
    prefixValue?: string;
    /** Called when the prefix select changes. */
    onPrefixChange?: (value: string, prevWeight: number | undefined, newWeight: number | undefined) => void;
    /** Suffix content (e.g. unit label or ReactNode). */
    suffix?: default_2.ReactNode;
    /** Show ▲/▼ stepper buttons (default `true`). */
    showStepper?: boolean;
    /** Display format preset applied on blur: 'integer', 'decimal', 'money', 'percent'. */
    formatPreset?: 'integer' | 'decimal' | 'money' | 'percent';
    /** Custom display formatter applied on blur. Takes precedence over formatPreset. */
    format?: (value: number) => string;
    /** Suffix mode: 'label' (static, default) or 'select' (dropdown). */
    suffixType?: 'label' | 'select';
    /** Options for the suffix select dropdown. */
    suffixOptions?: NiceSuffixOption[];
    /** Currently selected suffix value (controlled). */
    suffixValue?: string;
    /** Called when the suffix select changes. */
    onSuffixChange?: (value: string, prevWeight: number | undefined, newWeight: number | undefined) => void;
}

export declare const NicePasswordInput: default_2.ForwardRefExoticComponent<NicePasswordInputProps & default_2.RefAttributes<HTMLInputElement>>;

/** Props for the {@link NicePasswordInput} component — a password field with visibility toggle and strength meter. */
export declare interface NicePasswordInputProps extends NiceFormFieldProps {
    value?: string;
    onChange?: (value: string) => void;
    onBlur?: (e: default_2.FocusEvent<HTMLInputElement>) => void;
    onKeyDown?: (e: default_2.KeyboardEvent<HTMLInputElement>) => void;
    placeholder?: string;
    maxLength?: number;
    /** Show visibility toggle button (default: true) */
    showToggle?: boolean;
    /** Show password strength meter (default: false) */
    showStrength?: boolean;
    /** Custom strength rules — overrides default rules */
    strengthRules?: NicePasswordRule[];
    /** Where to display the strength/validation section: 'bottom' (default, below control) or 'right' (beside control). */
    validationPlacement?: 'bottom' | 'right';
    autoFocus?: boolean;
    autoComplete?: string;
}

/** A validation rule for the password strength meter in {@link NicePasswordInput}. */
declare interface NicePasswordRule {
    /** Rule identifier */
    id: string;
    /** Human-readable rule label */
    label: string;
    /** Test function — returns true if the rule is satisfied */
    test: (value: string) => boolean;
}

/**
 * {@link NicePDFAnnotationEditor} — PDF viewer shell with annotation overlay.
 * PDF rendering is external (expects an iframe/embed or a custom renderer).
 * This component provides the toolbar, annotation layer, and page navigation.
 */
export declare const NicePDFAnnotationEditor: default_2.ForwardRefExoticComponent<NicePDFAnnotationEditorProps & default_2.RefAttributes<HTMLDivElement>>;

/** Props for the {@link NicePDFAnnotationEditor} component. */
export declare interface NicePDFAnnotationEditorProps extends NiceFormFieldProps {
    /** URL or data URL of the PDF document. */
    src: string;
    /** Current annotations. */
    annotations?: PDFAnnotation[];
    /** Fires when annotations change. */
    onAnnotationsChange?: (annotations: PDFAnnotation[]) => void;
    /** Active tool. */
    activeTool?: AnnotationTool_2 | null;
    /** Fires when user switches tool. */
    onToolChange?: (tool: AnnotationTool_2 | null) => void;
    /** Current page number (1-based). */
    currentPage?: number;
    /** Fires on page change. */
    onPageChange?: (page: number) => void;
    /** Total pages (provided externally if PDF parsing is done elsewhere). */
    totalPages?: number;
    /** Default annotation color. */
    defaultColor?: string;
    /** Available tools. */
    tools?: AnnotationTool_2[];
    /** Current author name for new annotations. */
    author?: string;
    /** Zoom level (1 = 100%). */
    zoom?: number;
    /** Fires on zoom change. */
    onZoomChange?: (zoom: number) => void;
    /** Fires when an annotation is clicked. */
    onAnnotationClick?: (annotation: PDFAnnotation) => void;
    /** Fires when an annotation is deleted. */
    onAnnotationDelete?: (id: string) => void;
}

/**
 * {@link NicePhoneInput} — Phone number input with country code selector, masking, and E.164 formatting.
 */
export declare const NicePhoneInput: default_2.ForwardRefExoticComponent<NicePhoneInputProps & default_2.RefAttributes<HTMLDivElement>>;

/** Props for the {@link NicePhoneInput} component. */
export declare interface NicePhoneInputProps extends NiceFormFieldProps {
    /** Controlled phone value. */
    value?: PhoneValue;
    /** Fires on value change with parsed phone value. */
    onChange?: (value: PhoneValue) => void;
    /** Available country codes. */
    countryCodes?: PhoneCountryCode[];
    /** Default country code (ISO alpha-2, e.g. "PL"). */
    defaultCountry?: string;
    /** Placeholder for the number part. */
    placeholder?: string;
    /** Whether to show the country flag emoji. */
    showFlag?: boolean;
    /** Whether to validate as E.164 on blur. */
    validateE164?: boolean;
    /** Fires with the raw input event. */
    onBlur?: (e: default_2.FocusEvent<HTMLInputElement>) => void;
}

export declare const NicePickList: <T = unknown>(props: NicePickListProps<T> & default_2.RefAttributes<HTMLDivElement>) => default_2.ReactElement | null;

/** Props for the {@link NicePickList} component — a dual-list control for moving items between source and target. */
export declare interface NicePickListProps<T = unknown> extends NiceBaseProps {
    /** Items in the source list */
    source: T[];
    /** Items in the target list */
    target: T[];
    /** Called when items move between lists */
    onChange: (source: T[], target: T[]) => void;
    /** Unique key extractor */
    keyField?: string;
    /** Label extractor */
    labelField?: string;
    /** Custom item renderer */
    renderItem?: (item: T) => default_2.ReactNode;
    /** Enable filtering/search */
    filterable?: boolean;
    /** Source list header */
    sourceHeader?: default_2.ReactNode;
    /** Target list header */
    targetHeader?: default_2.ReactNode;
    disabled?: boolean;
    size?: NiceSize;
}

/**
 * {@link NicePinCodeInput} — PIN code entry with individual digit boxes,
 * optional numeric keypad, masking, and auto-submit.
 */
export declare const NicePinCodeInput: default_2.ForwardRefExoticComponent<NicePinCodeInputProps & default_2.RefAttributes<HTMLDivElement>>;

/** Props for the {@link NicePinCodeInput} component. */
export declare interface NicePinCodeInputProps extends NiceFormFieldProps {
    /** Current PIN value. */
    value?: string;
    /** Fires when value changes. */
    onChange?: (value: string) => void;
    /** Fires when PIN is fully entered. */
    onComplete?: (pin: string) => void;
    /** Number of PIN digits. */
    length?: number;
    /** Whether to mask digits (show dots). */
    masked?: boolean;
    /** Whether to show a numeric keypad below the input. */
    showKeypad?: boolean;
    /** Whether to auto-submit when all digits are filled. */
    autoSubmit?: boolean;
    /** Error shake animation trigger (toggle to replay). */
    shake?: boolean;
    /** Placeholder character. */
    placeholderChar?: string;
}

export declare const NiceRadioGroup: default_2.FC<NiceRadioGroupProps>;

/** Props for the {@link NiceRadioGroup} component — a set of mutually exclusive radio options. */
export declare interface NiceRadioGroupProps extends NiceFormFieldProps {
    /** Available options. */
    options: NiceOption[];
    /** Currently selected value. */
    value?: string;
    /** Called when the selection changes. */
    onChange?: (value: string) => void;
    /** Arrange options horizontally or vertically. */
    direction?: 'horizontal' | 'vertical';
}

export declare const NiceRangeSlider: default_2.FC<NiceRangeSliderProps>;

/** Props for the {@link NiceRangeSlider} component — a dual-thumb slider for selecting a numeric range. */
export declare interface NiceRangeSliderProps extends NiceFormFieldProps {
    /** Minimum track value. */
    min?: number;
    /** Maximum track value. */
    max?: number;
    /** Step increment. */
    step?: number;
    /** Start (lower) thumb value. */
    startValue: number;
    /** End (upper) thumb value. */
    endValue: number;
    /** Called when either thumb moves. */
    onChange: (start: number, end: number) => void;
    /** Show value labels at each thumb. */
    showLabels?: boolean;
    /** Custom label formatter. */
    formatLabel?: (value: number) => string;
    /** Where to show the range value text. */
    valuePlacement?: 'right' | 'bottom' | 'none';
}

export declare const NiceRating: default_2.ForwardRefExoticComponent<NiceRatingProps & default_2.RefAttributes<HTMLDivElement>>;

/** Props for the {@link NiceRating} component — a star/icon rating input with half-step support. */
export declare interface NiceRatingProps extends NiceBaseProps {
    /** Current value (0 to count) */
    value?: number;
    onChange?: (value: number) => void;
    /** Number of stars/icons */
    count?: number;
    /** Allow half-star selection */
    half?: boolean;
    /** Read-only display */
    readOnly?: boolean;
    disabled?: boolean;
    size?: NiceSize;
    label?: string;
    /** Custom icon render (receives filled state) */
    icon?: (filled: 'full' | 'half' | 'empty') => default_2.ReactNode;
    /** Name for form submission */
    name?: string;
    error?: string;
    /** Assistive text shown below the field. */
    helperText?: string;
    /** Marks the field as required. */
    required?: boolean;
    /** Shows a loading spinner inside the control and disables interaction. */
    loading?: boolean;
    /** Label placement: top (default) or left. */
    labelPlacement?: 'top' | 'left';
    /** Error placement: bottom (default) or right. */
    errorPlacement?: 'bottom' | 'right';
    /** Explicit width for the label column when labelPlacement is 'left'. */
    labelWidth?: string | number;
    /** Explicit width for the control column. */
    controlWidth?: string | number;
    /** Value display placement. */
    valuePlacement?: 'right' | 'bottom' | 'none';
    /** Custom value format, e.g. "{value}/5" */
    valueTemplate?: string;
}

/**
 * {@link NiceScannerControl} — QR/barcode scanner UI with camera preview placeholder,
 * manual text entry, beep feedback, and scan history.
 */
export declare const NiceScannerControl: default_2.ForwardRefExoticComponent<NiceScannerControlProps & default_2.RefAttributes<HTMLDivElement>>;

/** Props for the {@link NiceScannerControl} component. */
export declare interface NiceScannerControlProps extends NiceFormFieldProps {
    /** Current input mode. */
    mode?: ScannerMode;
    /** Fires when a code is scanned/entered. */
    onScan?: (result: ScanResult) => void;
    /** Fires when mode changes. */
    onModeChange?: (mode: ScannerMode) => void;
    /** Whether to play a beep sound on successful scan. */
    beepOnScan?: boolean;
    /** Beep frequency in Hz. */
    beepFrequency?: number;
    /** Beep duration in ms. */
    beepDuration?: number;
    /** Placeholder for manual input. */
    placeholder?: string;
    /** History of recent scans. */
    scanHistory?: ScanResult[];
    /** Whether to show scan history. */
    showHistory?: boolean;
    /** Max history entries to display. */
    maxHistory?: number;
    /** Whether to auto-focus the manual input. */
    autoFocus?: boolean;
    /** Note: Actual camera barcode detection requires a library like `@nicetoDev/scanner-adapter`.
     *  This component provides the UI shell and manual input. Camera mode renders a placeholder
     *  with an external `onCameraFrame` callback. */
    onCameraFrame?: (video: HTMLVideoElement) => void;
}

export declare const NiceSelect: default_2.ForwardRefExoticComponent<NiceSelectProps & default_2.RefAttributes<HTMLButtonElement>>;

/** Props for the {@link NiceSelect} component. */
export declare interface NiceSelectProps extends NiceFormFieldProps {
    /** Static options array. Plain strings are treated as `{ value: s, label: s }`. Merged with (or overridden by) `optionsSource`. */
    options?: Array<NiceOption | string>;
    value?: string | string[];
    onChange?: (value: string | string[]) => void;
    placeholder?: string;
    multiple?: boolean;
    searchable?: boolean;
    clearable?: boolean;
    emptyText?: string;
    maxHeight?: number;
    /**
     * Load options from a data source.
     * When provided, options are fetched from this source using
     * `valueField` and `labelField` to map records to NiceOption[].
     */
    optionsSource?: NiceDataSource;
    /** Field used as option value. Default: keyField of the data source. */
    valueField?: string;
    /** Field used as option label. Default: 'name'. */
    labelField?: string;
    /** Enable virtual scrolling for large option sets. */
    virtualScroll?: boolean;
    /** Fixed height for each option row (default 36). Used with virtualScroll. */
    optionHeight?: number;
    /** Async search callback. Called on search input change. Return options via `options` prop update. */
    onSearch?: (query: string) => void;
    /** Loading state for async search. */
    loading?: boolean;
    /** Custom render function for option items. */
    renderOption?: (option: NiceOption, isSelected: boolean) => default_2.ReactNode;
    /** When true (default false), the trigger width grows to fit selected items in `multiple` mode. When false, width stays fixed. */
    multipleAutosize?: boolean;
}

export declare const NiceSignature: default_2.ForwardRefExoticComponent<NiceSignatureProps & default_2.RefAttributes<NiceSignatureRef>>;

declare interface NiceSignatureData {
    /** Strokes */
    strokes: NiceSignatureStroke[];
    /** Width at time of creation */
    width: number;
    /** Height at time of creation */
    height: number;
    /** Timestamp */
    timestamp: number;
}

declare type NiceSignatureOutput = 'png' | 'jpeg' | 'svg';

export declare const NiceSignaturePad: ForwardRefExoticComponent<NiceSignaturePadProps & RefAttributes<HTMLDivElement>>;

/** Props for the {@link NiceSignaturePad} component — a canvas-based digital signature capture pad. */
export declare interface NiceSignaturePadProps extends NiceBaseProps {
    /** Signature image (data URL) — controlled value */
    value?: string | null;
    onChange?: (dataUrl: string | null) => void;
    penColor?: string;
    penWidth?: number;
    backgroundColor?: string;
    width?: number;
    height?: number;
    size?: NiceSize;
    disabled?: boolean;
    readOnly?: boolean;
    showClear?: boolean;
    showUndo?: boolean;
    label?: string;
    exportFormat?: 'image/png' | 'image/jpeg' | 'image/svg+xml';
}

declare interface NiceSignaturePoint {
    x: number;
    y: number;
    time: number;
    pressure?: number;
}

export declare interface NiceSignatureProps {
    /** Current signature data */
    value?: NiceSignatureData | null;
    /** Value change callback */
    onChange?: (data: NiceSignatureData | null) => void;
    /** Width */
    width?: number | string;
    /** Height */
    height?: number;
    /** Pen color */
    penColor?: string;
    /** Pen width */
    penWidth?: number;
    /** Min pen width (for pressure sensitivity) */
    minWidth?: number;
    /** Max pen width (for pressure sensitivity) */
    maxWidth?: number;
    /** Background color */
    backgroundColor?: string;
    /** Placeholder text */
    placeholder?: string;
    /** Show clear button */
    showClearButton?: boolean;
    /** Show undo button */
    showUndoButton?: boolean;
    /** Show color picker */
    showColorPicker?: boolean;
    /** Show size slider */
    showSizeSlider?: boolean;
    /** Velocity filter weight (smoothness) */
    velocityFilterWeight?: number;
    /** Throttle (ms between points) */
    throttle?: number;
    /** Disabled state */
    disabled?: boolean;
    /** Read only (shows signature but can't edit) */
    readOnly?: boolean;
    /** Display mode — hides toolbar and prevents editing. Equivalent to readOnly + showClearButton/showUndoButton/showColorPicker/showSizeSlider all false. */
    displayMode?: boolean;
    /** On begin stroke */
    onBegin?: () => void;
    /** On end stroke */
    onEnd?: () => void;
    /** Additional CSS class */
    className?: string;
    /** Test ID */
    'data-testid'?: string;
}

declare interface NiceSignatureRef {
    /** Clear signature */
    clear: () => void;
    /** Undo last stroke */
    undo: () => void;
    /** Check if signature is empty */
    isEmpty: () => boolean;
    /** Get signature data */
    getData: () => NiceSignatureData | null;
    /** Set signature data */
    setData: (data: NiceSignatureData) => void;
    /** Get as data URL */
    toDataURL: (type?: NiceSignatureOutput, quality?: number) => string;
    /** Get as Blob */
    toBlob: (type?: NiceSignatureOutput, quality?: number) => Promise<Blob | null>;
    /** Get as SVG string */
    toSVG: () => string;
    /** Get canvas element */
    getCanvas: () => HTMLCanvasElement | null;
}

declare interface NiceSignatureStroke {
    points: NiceSignaturePoint[];
    color: string;
    width: number;
}

export declare const NiceSlider: default_2.ForwardRefExoticComponent<NiceSliderProps & default_2.RefAttributes<HTMLInputElement>>;

/** Props for the {@link NiceSlider} component — a single-thumb range slider for numeric input. */
export declare interface NiceSliderProps extends Omit<NiceFormFieldProps, 'labelPlacement'> {
    /** Where to place the label relative to the slider. 'top' (default) shows label and value above the track; 'bottom' shows label and value above the track but in a row above (legacy 'left' behaviour); 'left' places label to the left and value to the right of the slider on a single row. */
    labelPlacement?: 'top' | 'bottom' | 'left';
    /** Current value. */
    value?: number;
    /** Called when the value changes. */
    onChange?: (value: number) => void;
    /** Minimum value. */
    min?: number;
    /** Maximum value. */
    max?: number;
    /** Step increment. */
    step?: number;
    /** Display the current numeric value next to the thumb. */
    showValue?: boolean;
    /** Display min/max labels at the ends of the track. */
    showMinMax?: boolean;
    /** Custom formatter for the displayed value. */
    formatValue?: (v: number) => string;
    /** Show tick marks on the slider track. */
    showTicks?: boolean;
    /**
     * Distance between ticks expressed in slider value units. Defaults to `step`
     * when `showTicks` is true. If the resulting tick count would exceed
     * {@link maxTicks}, the renderer falls back to evenly spaced ticks.
     */
    tickInterval?: number;
    /** Maximum number of ticks rendered. Defaults to 21 (so a 0–100 step=5 shows 21 marks). */
    maxTicks?: number;
    /** Render numeric labels under each tick. Defaults to `false`. */
    showTickLabels?: boolean;
}

/** An option for the prefix/suffix select dropdown with optional conversion weight. */
export declare interface NiceSuffixOption {
    /** Option value. */
    value: string;
    /** Display label. */
    label: string;
    /** Conversion weight relative to the base unit. When set and the user switches units, the numeric value is multiplied by `(prevWeight / newWeight)`. */
    weight?: number;
}

export declare const NiceTagBox: default_2.FC<NiceTagBoxProps>;

/** Props for the {@link NiceTagBox} component — a multi-select input that displays selected items as tags/chips. */
export declare interface NiceTagBoxProps extends NiceFormFieldProps {
    /** Available options. */
    options?: NiceOption[];
    /** Array of selected values. */
    value: string[];
    /** Called when the selection changes. */
    onChange: (value: string[]) => void;
    /** Enable search/filter within the dropdown. */
    searchable?: boolean;
    /** Show a clear-all button. */
    clearable?: boolean;
    /** Maximum number of tags allowed. */
    maxTags?: number;
    /** Allow the user to type custom values not in the options list. */
    allowCustom?: boolean;
    /** Input placeholder. */
    placeholder?: string;
    /** Alias for options — array of string suggestions. */
    suggestions?: string[];
    /**
     * When true, the control grows vertically as more tags are added (tags wrap to
     * new rows). When false (default), the control keeps a fixed single-row height
     * and tags overflow horizontally with a scroll. Set to true to opt in to the
     * legacy auto-expanding behaviour.
     */
    autoExpand?: boolean;
}

/**
 * {@link NiceTaxRatePicker} — VAT/tax rate selector with country-specific defaults.
 * Supports Polish rates out-of-the-box, custom rates per country, and displays
 * percentage values.
 */
export declare const NiceTaxRatePicker: default_2.ForwardRefExoticComponent<NiceTaxRatePickerProps & default_2.RefAttributes<HTMLDivElement>>;

/** Props for the {@link NiceTaxRatePicker} component. */
export declare interface NiceTaxRatePickerProps extends NiceFormFieldProps {
    /** Selected tax rate id. */
    value?: string;
    /** Fires when selection changes. */
    onChange?: (rateId: string, rate: TaxRate) => void;
    /** Available tax rates. If empty, defaults to Polish VAT rates. */
    rates?: TaxRate[];
    /** Country code filter. */
    countryCode?: string;
    /** Placeholder text. */
    placeholder?: string;
    /** Whether to show rate percentage in the label. */
    showPercentage?: boolean;
}

export declare const NiceTextArea: default_2.ForwardRefExoticComponent<NiceTextAreaProps & default_2.RefAttributes<HTMLTextAreaElement>>;

export declare interface NiceTextAreaProps extends NiceFormFieldProps {
    value?: string;
    defaultValue?: string;
    onChange?: (value: string) => void;
    onBlur?: (e: default_2.FocusEvent<HTMLTextAreaElement>) => void;
    onKeyDown?: (e: default_2.KeyboardEvent<HTMLTextAreaElement>) => void;
    placeholder?: string;
    rows?: number;
    maxLength?: number;
    resize?: 'none' | 'vertical' | 'horizontal' | 'both';
    autoFocus?: boolean;
    showCount?: boolean;
    /** Where to display the character counter: 'bottom' (default, below control) or 'right' (beside control). */
    counterPlacement?: 'bottom' | 'right';
}

export declare const NiceTextInput: default_2.ForwardRefExoticComponent<NiceTextInputProps & default_2.RefAttributes<HTMLInputElement>>;

/** Props for the {@link NiceTextInput} component. */
export declare interface NiceTextInputProps extends Omit<NiceFormFieldProps, 'labelPlacement'> {
    /** Where to place the label. 'inside' renders a Material-style floating label that sits as a placeholder inside the input and animates upward when focused or filled. Defaults to 'top'. */
    labelPlacement?: 'top' | 'left' | 'inside';
    /** Controlled input value. */
    value?: string;
    /** Uncontrolled default value. */
    defaultValue?: string;
    /** Fires on every value change with the new string value. */
    onChange?: (value: string) => void;
    /** Native blur event handler. */
    onBlur?: (e: default_2.FocusEvent<HTMLInputElement>) => void;
    /** Native keydown event handler. */
    onKeyDown?: (e: default_2.KeyboardEvent<HTMLInputElement>) => void;
    /** Placeholder text. */
    placeholder?: string;
    /** HTML input type. */
    type?: 'text' | 'email' | 'password' | 'search' | 'tel' | 'url';
    /** Maximum character count. */
    maxLength?: number;
    /** Content rendered before the input (e.g. icon). */
    prefix?: default_2.ReactNode;
    /** Content rendered after the input (e.g. unit label). */
    suffix?: default_2.ReactNode;
    /** Shows a clear (×) button when the input has a value. */
    clearable?: boolean;
    /** Auto-focuses the input on mount. */
    autoFocus?: boolean;
    /** Visual variant. */
    variant?: 'outlined' | 'filled' | 'underlined' | string;
}

export declare const NiceTimePicker: default_2.ForwardRefExoticComponent<NiceTimePickerProps & default_2.RefAttributes<HTMLDivElement>>;

/** Props for the {@link NiceTimePicker} component — a time-only picker with hour/minute/second spinners. */
export declare interface NiceTimePickerProps extends NiceFormFieldProps {
    /** Time string in HH:mm or HH:mm:ss format */
    value?: string;
    onChange?: (value: string) => void;
    onBlur?: (e: default_2.FocusEvent) => void;
    /** Display format — 12h shows AM/PM toggle, 24h shows 0–23 */
    hourFormat?: '12' | '24';
    /** Minute increment step */
    minuteStep?: number;
    /** Show seconds input */
    showSeconds?: boolean;
    /** Minimum time (HH:mm) */
    min?: string;
    /** Maximum time (HH:mm) */
    max?: string;
    /** Show clear button */
    clearable?: boolean;
    /**
     * Optional explicit target date to combine with the picked time
     * (`Date` or `YYYY-MM-DD` string). When omitted while {@link countdown}
     * is enabled, the target auto-resolves to the **next occurrence**:
     * today if the picked time hasn't passed yet, tomorrow if it has.
     */
    targetDate?: string | Date;
    /** Fires whenever the resolved target Date changes. */
    onTargetChange?: (target: Date) => void;
    /** Show a live countdown label beside the picker. */
    countdown?: boolean;
    /** Built-in countdown format preset (default `'verbose'`). */
    countdownFormat?: NiceCountdownFormat;
    /** Custom formatter (overrides {@link countdownFormat}). */
    formatCountdown?: (msRemaining: number, target: Date) => string;
    /** Label rendered before the countdown text (e.g. `'starts in'`). */
    countdownLabel?: default_2.ReactNode;
    /** Update interval in ms (default `1000`). */
    countdownInterval?: number;
    /** Text shown when the target time has elapsed (default `'now'`). */
    countdownDoneText?: string;
}

export declare const NiceToggle: default_2.ForwardRefExoticComponent<NiceToggleProps & default_2.RefAttributes<HTMLInputElement>>;

/** Props for the {@link NiceToggle} component — a boolean switch/toggle. */
export declare interface NiceToggleProps extends NiceBaseProps {
    /** Toggle label. */
    label?: default_2.ReactNode;
    /** Controlled on/off state. */
    checked?: boolean;
    /** Called on toggle. */
    onChange?: (checked: boolean) => void;
    /** Disables the toggle. */
    disabled?: boolean;
    /** Read-only mode. */
    readOnly?: boolean;
    /** Shows a loading spinner inside the control and disables interaction. */
    loading?: boolean;
    /** Marks the field as required. */
    required?: boolean;
    /** Visual size. */
    size?: NiceSize;
    /** HTML name. */
    name?: string;
    /** Validation error message. */
    error?: string;
    /** Assistive text shown below the field. */
    helperText?: string;
    /** Show keyboard shortcuts hint. */
    showKeyboardHints?: boolean;
    /** Label position: 'right' (default — to the right of the toggle) or 'left'. */
    labelPlacement?: 'right' | 'left';
    /** Error/validation position: 'bottom' (default) or 'right'. */
    errorPlacement?: 'bottom' | 'right';
    /** Explicit width for the label column when labelPlacement is 'left'. */
    labelWidth?: string | number;
    /** Explicit width for the control column. */
    controlWidth?: string | number;
}

export declare const NiceTreeSelect: default_2.ForwardRefExoticComponent<NiceTreeSelectProps & default_2.RefAttributes<HTMLDivElement>>;

/** A node in the tree hierarchy for {@link NiceTreeSelect}. */
declare interface NiceTreeSelectNode {
    key: string | number;
    label: string;
    children?: NiceTreeSelectNode[];
    disabled?: boolean;
    /** @deprecated Icons are no longer rendered — prop kept for backward compatibility. */
    icon?: default_2.ReactNode;
}

/** Props for the {@link NiceTreeSelect} component — a dropdown that lets the user pick from a tree hierarchy. */
export declare interface NiceTreeSelectProps extends NiceFormFieldProps {
    nodes: NiceTreeSelectNode[];
    /** Selected value(s) */
    value?: string | number | (string | number)[];
    onChange?: (value: string | number | (string | number)[]) => void;
    /** Allow multiple selection */
    multiple?: boolean;
    /** Allow searching/filtering nodes */
    searchable?: boolean;
    placeholder?: string;
    /** Only allow selection of leaf nodes */
    selectableLeafsOnly?: boolean;
    clearable?: boolean;
}

/**
 * {@link NiceVatInput} — VAT/NIP number input with country selector,
 * prefix auto-prepend, pattern validation, and optional VIES verification.
 */
export declare const NiceVatInput: default_2.ForwardRefExoticComponent<NiceVatInputProps & default_2.RefAttributes<HTMLDivElement>>;

/** Props for the {@link NiceVatInput} component. */
export declare interface NiceVatInputProps extends NiceFormFieldProps {
    /** Current VAT number value (with or without prefix). */
    value?: string;
    /** Fires when value changes. */
    onChange?: (value: string, isValid: boolean) => void;
    /** Selected country code (ISO 3166-1 alpha-2). */
    countryCode?: string;
    /** Fires when country changes. */
    onCountryChange?: (code: string) => void;
    /** Custom country configs. */
    countries?: VatCountryConfig[];
    /** Whether to show the country selector. */
    showCountrySelector?: boolean;
    /** Whether to auto-prepend VAT prefix. */
    autoPrefixVat?: boolean;
    /** External validation result. */
    validationResult?: {
        valid: boolean;
        companyName?: string;
        error?: string;
    } | null;
    /** Fires when user requests online validation (e.g. VIES). */
    onValidateRequest?: (vatNumber: string, countryCode: string) => void;
    /** Placeholder override. */
    placeholder?: string;
}

/**
 * {@link NiceWiki} — Wiki module with page tree sidebar, rich content area,
 * inline editor (edit mode), page create/delete, and version history hooks.
 */
export declare const NiceWiki: default_2.ForwardRefExoticComponent<NiceWikiProps & default_2.RefAttributes<HTMLDivElement>>;

/** Props for the {@link NiceWiki} component. */
export declare interface NiceWikiProps extends NiceFormFieldProps {
    /** Page tree. */
    pages: WikiPage[];
    /** Currently selected page id. */
    selectedPageId?: string | number;
    /** Content of the currently selected page (HTML or Markdown). */
    content?: string;
    /** Content format. */
    contentFormat?: 'html' | 'markdown';
    /** Whether the editor is in edit mode. */
    editing?: boolean;
    /** Fires when a page is selected. */
    onPageSelect?: (page: WikiPage) => void;
    /** Fires when content changes (in edit mode). */
    onContentChange?: (content: string) => void;
    /** Fires when save is clicked. */
    onSave?: (pageId: string | number, content: string) => void;
    /** Fires when a new page is created. */
    onCreatePage?: (parentId: string | number | null, title: string) => void;
    /** Fires when a page is deleted. */
    onDeletePage?: (pageId: string | number) => void;
    /** Fires when edit mode is toggled. */
    onEditToggle?: (editing: boolean) => void;
    /** Fires when version history is requested. */
    onVersionHistory?: (pageId: string | number) => void;
    /** Width of the sidebar in px. */
    sidebarWidth?: number;
    /** Whether the sidebar is collapsed. */
    sidebarCollapsed?: boolean;
    /** Fires on sidebar toggle. */
    onSidebarToggle?: (collapsed: boolean) => void;
    /** Whether to show search in sidebar. */
    searchable?: boolean;
    /** Fires on search. */
    onSearch?: (query: string) => void;
}

/** A single PDF annotation. */
declare interface PDFAnnotation {
    id: string;
    tool: AnnotationTool_2;
    page: number;
    /** Coordinates relative to page (0-1 normalized). */
    x: number;
    y: number;
    width?: number;
    height?: number;
    color?: string;
    text?: string;
    author?: string;
    createdAt?: string;
    /** Free-form path points for freehand tool. */
    points?: Array<{
        x: number;
        y: number;
    }>;
}

/** Country phone prefix entry. */
declare interface PhoneCountryCode {
    code: string;
    dialCode: string;
    name: string;
    mask?: string;
}

/** Parsed phone value. */
declare interface PhoneValue {
    countryCode?: string;
    dialCode?: string;
    number?: string;
    /** Full E.164 formatted number (e.g. "+48123456789"). */
    e164?: string;
}

declare interface RectangleAnnotation extends AnnotationBase {
    tool: 'rectangle';
}

/** Scanner input mode. */
declare type ScannerMode = 'camera' | 'manual';

/** Scan result. */
declare interface ScanResult {
    /** The decoded value. */
    value: string;
    /** Format of the code (QR, EAN-13, Code128, etc.). */
    format?: string;
    /** Timestamp of the scan. */
    scannedAt: Date;
}

/** A tax rate entry. */
declare interface TaxRate {
    /** Rate identifier. */
    id: string;
    /** Display label (e.g. "23%", "8%", "zw."). */
    label: string;
    /** Numeric rate as decimal (0.23 = 23%). */
    rate: number;
    /** Country code this rate applies to. */
    countryCode?: string;
    /** Category (e.g. "standard", "reduced", "zero", "exempt"). */
    category?: string;
    /** Whether this is the default rate. */
    isDefault?: boolean;
}

declare interface TextAnnotation extends AnnotationBase {
    tool: 'text';
    text: string;
}

declare type TextStyle = 'professional' | 'casual' | 'formal' | 'concise';

/**
 * Standard props that can be added to any component to support Traceless policy.
 */
declare interface TracelessStorageProps {
    /** Whether this component may use cookies */
    cookies?: boolean;
    /** Whether this component may use localStorage */
    localStorage?: boolean;
    /** Whether this component may use sessionStorage */
    sessionStorage?: boolean;
    /** Override storage mode for this component */
    storageMode?: TracelessMode;
    /** Storage key for persisting component state */
    storageKey?: string;
}

declare type UploadHandler = (request: UploadRequest) => Promise<UploadResponse>;

declare interface UploadRequest {
    file: File;
    chunk?: Blob;
    chunkIndex?: number;
    totalChunks?: number;
    fileId?: string;
    onProgress?: (progress: number) => void;
    signal?: AbortSignal;
}

declare interface UploadResponse {
    success: boolean;
    url?: string;
    error?: string;
    fileId?: string;
    metadata?: Record<string, any>;
}

declare type UploadStatus = 'pending' | 'uploading' | 'success' | 'error' | 'cancelled';

/** Country-specific VAT/NIP validation config. */
declare interface VatCountryConfig {
    /** ISO 3166‑1 alpha-2 code. */
    code: string;
    /** Display name. */
    label: string;
    /** VAT prefix (e.g. "PL", "DE"). */
    prefix: string;
    /** Regex pattern for the numeric part (without prefix). */
    pattern: RegExp;
    /** Mask/placeholder hint. */
    placeholder?: string;
}

/** A wiki page tree node. */
declare interface WikiPage {
    id: string | number;
    title: string;
    /** Slug or path segment. */
    slug: string;
    /** Parent page id (null for root). */
    parentId?: string | number | null;
    /** Children pages. */
    children?: WikiPage[];
    /** ISO date of last update. */
    updatedAt?: string;
    /** Last editor name. */
    updatedBy?: string;
    /** Whether this page is a draft. */
    isDraft?: boolean;
}

export { }
