@nice2dev/ui 1.0.5 → 1.0.6

package/dist/editors.d.ts

@@ -0,0 +1,2728 @@
+import { default as default_2 } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { RefAttributes } from 'react';
+
+/** 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;
+}
+
+declare type Listener<Args extends unknown[]> = (...args: Args) => void;
+
+/**
+ * Per-component visibility & interaction level used by the access control system.
+ * - `'full'` — fully interactive (default)
+ * - `'readOnly'` — renders but cannot be edited
+ * - `'disabled'` — renders greyed-out
+ * - `'hidden'` — not rendered at all
+ */
+declare type NiceAccessMode = 'full' | 'readOnly' | 'disabled' | 'hidden';
+
+/**
+ * {@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)[];
+}
+
+/** Base props inherited by every NiceToDev component. */
+declare interface NiceBaseProps {
+    /** Additional CSS class name(s). */
+    className?: string;
+    /** Inline style object. */
+    style?: React.CSSProperties;
+    /** HTML `id` attribute. When omitted a stable auto-generated id is used. */
+    id?: string;
+    /** Tooltip text shown on hover. */
+    title?: string;
+    /** Test identifier for integration / e2e test selectors. */
+    'data-testid'?: string;
+    /** Controls component visibility and interaction — see {@link NiceAccessMode}. */
+    accessMode?: NiceAccessMode;
+    /**
+     * Visual presentation style override.
+     * When set, overrides the global `displayStyle` from `NiceThemeProvider`.
+     * @see NiceDisplayStyle
+     */
+    displayStyle?: NiceDisplayStyle;
+}
+
+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;
+}
+
+export declare type NiceCalendarView = 'days' | 'months' | 'years' | 'decade';
+
+/** A cascading option node with optional children for {@link NiceCascadeSelect}. */
+export declare interface NiceCascadeOption {
+    label: string;
+    value: string;
+    children?: NiceCascadeOption[];
+}
+
+export declare const NiceCascadeSelect: default_2.ForwardRefExoticComponent<NiceCascadeSelectProps & default_2.RefAttributes<HTMLDivElement>>;
+
+/** Props for the {@link NiceCascadeSelect} component — a hierarchical dropdown (province → city → district). */
+export declare interface NiceCascadeSelectProps extends NiceBaseProps {
+    options: NiceCascadeOption[];
+    value?: string[];
+    onChange?: (path: string[]) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    size?: NiceSize;
+    optionLabel?: string;
+    optionValue?: string;
+}
+
+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;
+    /** Show keyboard shortcuts hint. */
+    showKeyboardHints?: boolean;
+}
+
+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';
+
+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;
+    /** 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;
+}
+
+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;
+}
+
+export declare const NiceCountryPicker: default_2.FC<NiceCountryPickerProps>;
+
+export declare interface NiceCountryPickerProps {
+    /** 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;
+    /** Disabled state */
+    disabled?: 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;
+    /** Extra class name */
+    className?: string;
+    /** Inline styles */
+    style?: default_2.CSSProperties;
+    /** 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;
+    /** 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;
+}
+
+/**
+ * Universal data source interface for Nice2Dev UI data components.
+ * All data-bound components (NiceDataGrid, NiceList, NiceForm, etc.) accept a `NiceDataSource`.
+ * Create one via `createArrayDataSource`, `createRestDataSource`, `createODataDataSource`,
+ * `createGraphQLDataSource`, or `createCustomDataSource`.
+ */
+declare interface NiceDataSource<T = any> {
+    /** Field name used as unique row key. */
+    readonly keyField: string;
+    /** True when insert/update/remove are available. */
+    readonly writable: boolean;
+    load(options?: NiceLoadOptions): Promise<NiceLoadResult<T>>;
+    byKey(key: unknown): Promise<T | undefined>;
+    insert?(item: Partial<T>): Promise<T>;
+    update?(key: unknown, changes: Partial<T>): Promise<T>;
+    remove?(key: unknown): Promise<void>;
+    on<K extends keyof NiceDataSourceEventMap>(event: K, handler: Listener<NiceDataSourceEventMap[K]>): () => void;
+}
+
+/** Events emitted by all NiceDataSource implementations. */
+declare type NiceDataSourceEventMap = {
+    changed: [];
+    loading: [boolean];
+    error: [Error | null];
+    loaded: [NiceLoadResult<unknown>];
+};
+
+export declare const NiceDatePicker: default_2.ForwardRefExoticComponent<NiceDatePickerProps & default_2.RefAttributes<HTMLInputElement>>;
+
+/** Props for the {@link NiceDatePicker} component — a native date/time input wrapper. */
+export declare interface NiceDatePickerProps extends NiceFormFieldProps {
+    /** ISO date string value (e.g. `'2024-06-15'`). */
+    value?: string;
+    /** Fires with the new ISO date string. */
+    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. */
+    min?: string;
+    /** Maximum selectable date. */
+    max?: string;
+    /** Input type — `'date'`, `'datetime-local'`, `'time'`, `'month'`, or `'week'`. */
+    type?: 'date' | 'datetime-local' | 'time' | 'month' | 'week';
+    /** Placeholder text. */
+    placeholder?: 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 text (when both fields are empty). */
+    placeholder?: string;
+    /** Placeholder for the start input. */
+    startPlaceholder?: string;
+    /** Placeholder for the end input. */
+    endPlaceholder?: string;
+}
+
+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;
+}
+
+/**
+ * Cross-component visual presentation style.
+ * Each style maps 1:1 to a ThemeVariantConfig preset controlling
+ * buttons, inputs, cards, badges, tabs, toggles, tooltips, tables, etc.
+ */
+declare type NiceDisplayStyle = 'default' | 'minimal' | 'rounded' | 'sharp' | 'glass' | 'neumorphic' | 'playful' | 'enterprise' | 'modern3d' | 'brutalist' | 'luxe' | 'pill' | 'flat' | 'editorial' | 'dashboard' | 'softCloud' | 'cosmic' | 'corporate' | 'bank' | 'government' | 'military' | 'legal' | 'medical' | 'swiss' | 'scandinavian' | 'bauhaus' | 'notebook' | 'origami' | 'watercolor' | 'monochrome' | 'paper' | 'zen' | 'terminal' | 'hacker' | 'retro8bit' | 'synthwave' | 'cyberpunk' | 'steampunk' | 'vapor' | 'neon' | 'windows95' | 'material' | 'fluent' | 'cupertino' | 'ant' | 'bootstrap' | 'chakra' | 'notion' | 'linear' | 'vercel' | 'candy' | 'bubblegum' | 'cartoon' | 'kawaii' | 'circus' | 'gaming' | 'kiddo' | 'disco' | 'clown';
+
+/** 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;
+}
+
+/**
+ * Layout sizing for editors, viewers and players.
+ * - `'minimal'` — smallest usable chrome, toolbar hidden or icon-only
+ * - `'compact'` — reduced padding, single-row toolbar
+ * - `'standard'` — default layout with full toolbar
+ * - `'fullscreen'` — expands to fill the viewport
+ */
+declare type NiceEditorSize = 'minimal' | 'compact' | 'standard' | 'fullscreen';
+
+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;
+}
+
+/** A single filter condition in the {@link NiceFilterBuilder} tree. */
+declare type NiceFilterCondition = {
+    type: 'condition';
+    field: string;
+    operator: NiceFilterOperator;
+    value: unknown;
+};
+
+/** A group of conditions joined by AND/OR logic in the {@link NiceFilterBuilder}. */
+declare type NiceFilterGroup = {
+    type: 'group';
+    logic: 'and' | 'or';
+    items: (NiceFilterCondition | NiceFilterGroup)[];
+};
+
+/** Comparison operators available in the {@link NiceFilterBuilder}. */
+declare type NiceFilterOperator = '=' | '<>' | '<' | '<=' | '>' | '>=' | 'contains' | 'notcontains' | 'startswith' | 'endswith' | 'between' | 'isblank' | 'isnotblank' | (string & {});
+
+export declare const NiceFloatingLabelInput: default_2.ForwardRefExoticComponent<NiceFloatingLabelInputProps & default_2.RefAttributes<HTMLInputElement>>;
+
+export declare interface NiceFloatingLabelInputProps extends Omit<default_2.InputHTMLAttributes<HTMLInputElement>, 'size'> {
+    /** Label text (floats up when focused or has value) */
+    label: string;
+    /** Helper text shown below input */
+    helperText?: string;
+    /** Error message (shows instead of helper text when present) */
+    error?: string;
+    /** Success state */
+    success?: boolean;
+    /** Left icon */
+    startIcon?: default_2.ReactNode;
+    /** Right icon */
+    endIcon?: default_2.ReactNode;
+    /** Show character counter */
+    showCounter?: boolean;
+    /** Input variant */
+    variant?: 'outlined' | 'filled' | 'standard';
+    /** Size variant */
+    size?: NiceSize;
+    /** Full width */
+    fullWidth?: boolean;
+    /** Extra class name */
+    className?: string;
+    /** Test ID */
+    'data-testid'?: string;
+}
+
+export declare const NiceForm: default_2.FC<NiceFormProps>;
+
+/** Extended base props for form-field components (inputs, selects, etc.). */
+declare interface NiceFormFieldProps extends NiceBaseProps {
+    /** Field label displayed above or beside the control. */
+    label?: string;
+    /** Assistive text shown below the field. */
+    helperText?: string;
+    /** Validation error message — when set the field is styled as invalid. */
+    error?: string;
+    /** Marks the field as required (adds visual indicator). */
+    required?: boolean;
+    /** Disables the field. */
+    disabled?: boolean;
+    /** Makes the field read-only. */
+    readOnly?: boolean;
+    /** Visual size of the field. */
+    size?: NiceSize;
+    /** HTML `name` attribute used in form serialization. */
+    name?: string;
+    /** When true, pressing Enter will trigger the onSubmit callback (if provided). */
+    submitOnEnter?: boolean;
+    /** Callback triggered when Enter is pressed (if submitOnEnter is true). */
+    onSubmit?: () => void;
+    /** Show a keyboard shortcuts hint icon (?) next to the label. */
+    showKeyboardHints?: boolean;
+}
+
+/** 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: any, onChange: (v: any) => void) => default_2.ReactNode;
+    hint?: string;
+    /** Group name — fields with the same group are rendered together under a section header. */
+    group?: 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>;
+}
+
+/** 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: any) => 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;
+}
+
+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 random button */
+    showRandom?: boolean;
+    /** Maximum number of gradient stops */
+    maxStops?: number;
+    label?: string;
+    disabled?: boolean;
+}
+
+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';
+
+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 NiceInPlaceEditor: default_2.ForwardRefExoticComponent<NiceInPlaceEditorProps & default_2.RefAttributes<HTMLDivElement>>;
+
+declare interface NiceInPlaceEditorOption {
+    label: string;
+    value: string;
+}
+
+/** Props for the {@link NiceInPlaceEditor} component — click-to-edit inline text that toggles between display and editor mode. */
+export declare interface NiceInPlaceEditorProps extends NiceBaseProps {
+    value: string;
+    onChange: (value: string) => void;
+    type?: NiceInPlaceEditorType;
+    options?: NiceInPlaceEditorOption[];
+    submitOnBlur?: boolean;
+    placeholder?: string;
+    disabled?: boolean;
+    size?: NiceSize;
+}
+
+/** Supported editor types for the {@link NiceInPlaceEditor}. */
+declare type NiceInPlaceEditorType = 'text' | 'textarea' | 'select' | 'date' | 'number';
+
+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;
+}
+
+/**
+ * {@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'> {
+    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;
+}
+
+/** Parameters sent to `load()`. All optional — adapters use what they support. */
+declare interface NiceLoadOptions {
+    filter?: NiceFilterGroup;
+    sort?: NiceSortExpression[];
+    skip?: number;
+    take?: number;
+    search?: string;
+    searchFields?: string[];
+    select?: string[];
+    expand?: string[];
+    group?: {
+        field: string;
+        direction?: NiceSortDirection;
+    }[];
+    /** Arbitrary parameters forwarded to the adapter (e.g. custom query strings). */
+    customParams?: Record<string, unknown>;
+}
+
+/** Result returned by {@link NiceDataSource.load}. */
+declare interface NiceLoadResult<T> {
+    data: T[];
+    totalCount: number;
+    summary?: Record<string, unknown>;
+}
+
+export declare const NiceLookup: default_2.FC<NiceLookupProps>;
+
+/** Props for the {@link NiceLookup} component — a simple select-like lookup with optional search. */
+export declare interface NiceLookupProps extends NiceFormFieldProps {
+    /** Available options. */
+    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;
+}
+
+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;
+    /** Character shown for unfilled positions (default: '_') */
+    maskChar?: string;
+    placeholder?: string;
+    /** Show the mask pattern as placeholder when empty */
+    showMaskAsPlaceholder?: boolean;
+    clearable?: boolean;
+    autoFocus?: boolean;
+}
+
+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 NiceMultiColumnComboBox: default_2.ForwardRefExoticComponent<NiceMultiColumnComboBoxProps & default_2.RefAttributes<HTMLDivElement>>;
+
+/** A column definition for the {@link NiceMultiColumnComboBox} dropdown grid. */
+declare interface NiceMultiColumnComboBoxColumn {
+    field: string;
+    header: string;
+    width?: number | string;
+}
+
+/** Props for the {@link NiceMultiColumnComboBox} component — a combo box whose dropdown shows data in columns (like a mini-grid). */
+export declare interface NiceMultiColumnComboBoxProps extends NiceBaseProps {
+    columns: NiceMultiColumnComboBoxColumn[];
+    data: Record<string, any>[];
+    value?: string;
+    onChange?: (value: string) => void;
+    displayExpr?: string;
+    valueExpr?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    size?: NiceSize;
+    filterable?: boolean;
+}
+
+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;
+    /** Suffix content (e.g. unit). */
+    suffix?: default_2.ReactNode;
+    /** Show ▲/▼ stepper buttons (default `true`). */
+    showStepper?: boolean;
+}
+
+/** A single option displayed in selects, radio-groups, autocompletes and similar list-based editors. */
+declare type NiceOption<T = string> = {
+    /** The option's backing value. */
+    value: T;
+    /** Display text shown to the user. */
+    label: string;
+    /** When `true` the option cannot be selected. */
+    disabled?: boolean;
+    /** Optional icon rendered before the label. */
+    icon?: React.ReactNode;
+    /** Secondary description text. */
+    description?: string;
+    /** Grouping key for grouped dropdowns. */
+    group?: string;
+};
+
+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[];
+    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 = any>(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 = any> 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;
+}
+
+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;
+}
+
+/**
+ * {@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. Merged with (or overridden by) `optionsSource`. */
+    options?: NiceOption[];
+    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;
+}
+
+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;
+    /** 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;
+}
+
+/** T-shirt sizing used across all components for consistent visual density. */
+declare type NiceSize = 'xxs' | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
+
+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 NiceFormFieldProps {
+    /** 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;
+}
+
+/** Sort direction for data source queries. */
+declare type NiceSortDirection = 'asc' | 'desc';
+
+/** A single sort expression: field name + direction. */
+declare interface NiceSortExpression {
+    field: string;
+    direction: NiceSortDirection;
+}
+
+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[];
+}
+
+/**
+ * {@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;
+}
+
+export declare const NiceTextInput: default_2.ForwardRefExoticComponent<NiceTextInputProps & default_2.RefAttributes<HTMLInputElement>>;
+
+/** Props for the {@link NiceTextInput} component. */
+export declare interface NiceTextInputProps extends NiceFormFieldProps {
+    /** 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;
+}
+
+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;
+    /** Visual size. */
+    size?: NiceSize;
+    /** HTML name. */
+    name?: string;
+    /** Show keyboard shortcuts hint. */
+    showKeyboardHints?: boolean;
+}
+
+export declare const NiceTransferList: default_2.FC<NiceTransferListProps>;
+
+declare interface NiceTransferListItem {
+    key: string;
+    label: string;
+    disabled?: boolean;
+    group?: string;
+}
+
+export declare interface NiceTransferListProps {
+    /** All available items */
+    dataSource: NiceTransferListItem[];
+    /** Keys of items in the right (target) list */
+    targetKeys?: string[];
+    /** Controlled selection */
+    selectedKeys?: string[];
+    /** Callback when target keys change */
+    onChange?: (targetKeys: string[], direction: 'left' | 'right', moveKeys: string[]) => void;
+    /** Callback when selection changes */
+    onSelectChange?: (sourceSelectedKeys: string[], targetSelectedKeys: string[]) => void;
+    /** Custom render for items */
+    render?: (item: NiceTransferListItem) => default_2.ReactNode;
+    /** Custom render for list title */
+    titles?: [default_2.ReactNode, default_2.ReactNode];
+    /** Enable searching */
+    showSearch?: boolean;
+    /** Search placeholder */
+    searchPlaceholder?: string;
+    /** Filter function for search */
+    filterOption?: (inputValue: string, item: NiceTransferListItem) => boolean;
+    /** Enable select all */
+    showSelectAll?: boolean;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Enable drag and drop transfer */
+    draggable?: boolean;
+    /** One-way mode (items can only move to target) */
+    oneWay?: boolean;
+    /** Custom operations buttons */
+    operations?: [default_2.ReactNode, default_2.ReactNode];
+    /** Group items by group field */
+    showGroups?: boolean;
+    /** Extra class name */
+    className?: string;
+    /** Inline styles */
+    style?: default_2.CSSProperties;
+    /** Height of the lists */
+    listHeight?: number;
+    /** Test ID */
+    'data-testid'?: string;
+}
+
+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;
+    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';
+
+/**
+ * @fileoverview Traceless™ — Zero-Trace Privacy Architecture
+ * @module @nice2dev/ui/core/traceless
+ *
+ * Traceless™ is OmniVerk's flagship privacy feature that allows complete control
+ * over client-side storage (cookies, localStorage, sessionStorage).
+ *
+ * "Żadnych śladów. Żadnych cookies. Żadnego localStorage. Żadnego bannera. Traceless."
+ *
+ * @example
+ * ```tsx
+ * import { TracelessProvider, useTracelessPolicy, StorageAdapter } from '@nice2dev/ui';
+ *
+ * // In your app root:
+ * <TracelessProvider>
+ *   <App />
+ * </TracelessProvider>
+ *
+ * // In components:
+ * const { mode, canUseCookies, canUseLocalStorage } = useTracelessPolicy();
+ * const storage = useStorageAdapter();
+ * storage.set('key', 'value'); // Automatically respects policy
+ * ```
+ */
+/**
+ * Privacy storage modes from most private to most permissive.
+ *
+ * | Mode       | Cookies | localStorage | sessionStorage | Consent Banner |
+ * |------------|---------|--------------|----------------|----------------|
+ * | traceless  | ❌      | ❌           | ❌             | ❌ Never       |
+ * | ephemeral  | ❌      | ❌           | ✅             | ❌ Never       |
+ * | private    | 1 auth  | ❌           | ✅             | ❌ Exempt      |
+ * | balanced   | ❌      | ✅           | ✅             | ⚠️ Maybe       |
+ * | full       | ✅      | ✅           | ✅             | ✅ Required    |
+ * | custom     | Config  | Config       | Config         | Config         |
+ */
+declare type TracelessMode = 'traceless' | 'ephemeral' | 'private' | 'balanced' | 'full' | 'custom';
+
+/**
+ * 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 { }