import * as React$1 from 'react';
import React__default, { RefObject, ReactNode, ComponentType, InputHTMLAttributes, Ref, ImgHTMLAttributes, MouseEvent, MouseEventHandler, CSSProperties } from 'react';
import { b as NajmDesignConfig, f as NajmThemeProviderProps, g as NajmAppearance, N as NajmMode, h as NajmThemeConfig, i as NajmAccent, j as NajmThemeTokens, k as NajmPreset, l as NajmComponentName, m as NajmComponentStyleConfig, a as NajmComponentThemeConfig, d as NajmTypographyConfig, c as NajmLayoutConfig, n as NajmResponsiveBreakpoint, o as NajmResponsiveValue } from './design-types-CJYLgxmw.js';
export { p as NAJM_COMPONENT_NAMES, q as NajmComponentRadius, r as NajmDensity, s as NajmSlotStyle, e as NajmVariantStyle, R as RADIUS_VALUE_MAP, t as resolveRadiusValue } from './design-types-CJYLgxmw.js';
export { a as NAJM_CURRENCIES, b as NAJM_CURRENCY_OPTIONS, d as NAJM_TIME_ZONES, e as NajmCurrency, N as NajmTimeZone, f as defineNajmDesignConfig, p as parseNajmDesignConfig, r as resolveVariantAlias, s as stringifyNajmDesignConfig } from './design-config-CdpHWwvE.js';
export { F as FormLocationInput, N as NLocationDialog, a as NLocationInput, b as NLocationProvider, i as isCompleteCoordinatePair, n as normalizeLocationValue, u as useNLocationProvider } from './contracts-GKNJ-pXo.js';
import { T as TailwindColor, n as TextInputProps, o as NumberInputProps, P as PasswordInputProps, O as OtpInputProps, p as TextAreaInputProps, S as SelectInputProps, C as ComboboxInputProps, M as MultiSelectInputProps, R as RadioGroupInputProps, q as CheckboxInputProps, r as CheckboxGroupInputProps, s as SwitchInputProps, D as DateInputProps, t as FileInputProps, I as ImageInputProps, A as AvatarInputProps, u as StarRatingInputProps, v as ColorArrayInputProps, w as ColorPickerInputProps, E as EmojiInputProps, x as LangInputProps, y as PhoneInputProps, z as TimeInputProps, B as TimeZoneInputProps, H as FormProps, J as FormInputProps, K as FormVariant } from './types-B-o4sfPa.js';
export { Q as AvatarInputRadius, U as ColorFormat, V as FormInputBackground, F as FormLocationInputProps, W as FormSlotClassNames, X as ImageInputPreviewError, Y as ImageInputPreviewSource, Z as InputIcon, c as NCoordinates, d as NLocationCandidate, e as NLocationClassNames, f as NLocationDialogProps, a as NLocationGeocoderAdapter, g as NLocationInputProps, b as NLocationLabels, N as NLocationMapAdapter, i as NLocationMapProps, j as NLocationProviderProps, m as NLocationValue, _ as NSlider, $ as NSliderProps, a0 as SelectItemType, a1 as Slider, a2 as SliderInput, a3 as SliderInputProps, a4 as SliderOrientation, a5 as SliderProps, a6 as SliderSize, a7 as SliderVariant, a8 as VariantProvider, a9 as detectFormat, aa as formatColor, ab as parseColor, ac as sliderVariants, ad as toPickerHex, ae as useVariant, af as useVariantPreset } from './types-B-o4sfPa.js';
import { d as NTableToolbarLabels, B as BadgeColor, e as BadgeShape } from './NajmUIProvider-wCcltXO6.js';
export { f as Badge, g as BadgeIcon, h as BadgeLook, i as BadgeProps, j as BadgeSize, k as BadgeVariant, D as DEFAULT_FEEDBACK_KEY_PREFIX, l as DEFAULT_TIME_ZONE, F as FeedbackKey, m as NBadge, n as NBadgeDefaults, o as NBadgeLook, p as NBadgeProps, N as NFeedbackDefaults, a as NFeedbackLabelKeys, b as NFeedbackLabels, q as NTableDefaults, r as NTableDefaultsProvider, s as NajmPreferencesContextValue, t as NajmPreferencesProvider, u as NajmPreferencesProviderProps, v as NajmUIProvider, c as NajmUIProviderProps, w as badgeColorVariants, x as badgeVariants, y as useDocumentDirection, z as useNTableDefaults, A as useNajmPreferencesContext, C as useNajmTheme, E as useNajmTimeZone, G as useResolvedToolbarLabels } from './NajmUIProvider-wCcltXO6.js';
import { N as NajmTranslate, c as NTablePaginationVariant, b as NTablePaginationLabels, a as NTableCardPagination } from './paginationLabels-dZLSNxfo.js';
export { D as DEFAULT_PAGINATION_KEY_PREFIX, d as NTableInfinitePagination, e as NTableLoadMorePagination, f as buildPaginationLabels } from './paginationLabels-dZLSNxfo.js';
import * as class_variance_authority_types from 'class-variance-authority/types';
import { VariantProps } from 'class-variance-authority';
import { N as NIconSource } from './NIcon-D73-C51g.js';
export { a as NIcon, b as NIconProps } from './NIcon-D73-C51g.js';
import { NajmFormatConfig } from './format.js';
export { DEFAULT_PLACEHOLDER, DEFAULT_STATUS_KEY_PREFIX, DEFAULT_STATUS_LABEL_LANGUAGE, NAJM_STATUS_LABELS, NajmStatusLabelOptions, SlugifyOptions, findPackagedStatusLabel, findStatusLabel, formatCurrency, formatDate, formatDateTime, formatNumber, formatPercent, formatRelativeTime, formatStatusLabel, formatTime, humanizeToken, localDateInput, resolveStatusLabelLanguage, slugify } from './format.js';
import * as LabelPrimitive from '@radix-ui/react-label';
import * as DialogPrimitive from '@radix-ui/react-dialog';
import * as zustand from 'zustand';
import { StoreApi } from 'zustand';
import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
import * as PopoverPrimitive from '@radix-ui/react-popover';
import * as SelectPrimitive from '@radix-ui/react-select';
import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
import * as RadioGroupPrimitive from '@radix-ui/react-radio-group';
import * as SwitchPrimitive from '@radix-ui/react-switch';
import * as TabsPrimitive from '@radix-ui/react-tabs';
import * as TooltipPrimitive from '@radix-ui/react-tooltip';
import * as ProgressPrimitive from '@radix-ui/react-progress';
import * as SeparatorPrimitive from '@radix-ui/react-separator';
import { OverlayScrollbarsComponentProps } from 'overlayscrollbars-react';
export { l as NBrandingEditorValue, N as NBrandingInput, m as NBrandingPayload, n as NBrandingProvider, o as NBrandingStateProvider, p as NBrandingStateProviderProps, q as NBrandingValue, a as NEmptyState, b as NEmptyStateProps, c as NErrorState, d as NErrorStateProps, e as NFeedbackSurface, f as NForbiddenState, g as NForbiddenStateProps, h as NLoadingState, i as NLoadingStateProps, j as NNotFoundState, k as NNotFoundStateProps, r as normalizeBranding, u as useNBranding, s as useNBrandingEditor } from './NNotFoundState-Z2n2gbhS.js';
import * as AvatarPrimitive from '@radix-ui/react-avatar';
import { Command as Command$1 } from 'cmdk';
import * as CollapsiblePrimitive from '@radix-ui/react-collapsible';
import * as TogglePrimitive from '@radix-ui/react-toggle';
import { ToasterProps } from 'sonner';
export { toast } from 'sonner';
import * as react_hook_form from 'react-hook-form';
import { FieldValues, FieldPath, ControllerProps, UseFormProps, UseFormReturn } from 'react-hook-form';
import { Slot } from '@radix-ui/react-slot';
import { LucideProps, LucideIcon } from 'lucide-react';
import { ZodTypeAny, TypeOf } from 'zod';
import { F as FormDevToolsOptions, a as FormDevTools } from './formFill-CQkTA0JS.js';
export { b as FormDevToolsConfig, c as FormFillOverride, d as FormFillOverrides, e as buildFormFill } from './formFill-CQkTA0JS.js';
import { SortingState, ExpandedState, ColumnDef, Row, ColumnFiltersState, VisibilityState, RowSelectionState } from '@tanstack/react-table';
export { N as NTableJson } from './NTableJson-BHXwRVvL.js';
import * as _tanstack_table_core from '@tanstack/table-core';
export { C as CardPaginationKey, a as CardPaginationLabels, b as CardPaginationState, D as DEFAULT_CARD_PAGINATION_KEY_PREFIX, L as ListStrategy, R as ResolvedListMode, c as buildCardPaginationLabels, d as createCardPagination } from './cardPagination-Bwf3tEeN.js';
import { ClassValue } from 'clsx';
export { ApiPage, DEFAULT_MAX_PAGE_SIZE, DEFAULT_PAGE_SIZE, OffsetPage, OffsetPageFetcher, OffsetPageOptions, OffsetPagination, QueryValue, cleanQuery, createOffsetPagination, fetchOffsetPage, getPageIndex } from './pagination.js';
import 'culori';
import '@radix-ui/react-slider';

/**
 * Shared so the identity is stable across renders — `NajmDesignProvider`
 * memoizes on `config.components`, `config.typography` and `config.layout`, and
 * a fresh literal here would invalidate that on every render of the tree.
 */
declare const EMPTY_DESIGN: NajmDesignConfig;
interface NajmDesignEditorValue {
    /** `draft ?? committed`. What the tree is currently rendered against. */
    design: NajmDesignConfig;
    /** The last design the application saved. */
    committed: NajmDesignConfig;
    /** The unsaved edit layered over `committed`, or `null`. */
    draft: NajmDesignConfig | null;
    hasDraft: boolean;
    /** Clones `committed` into a draft. A no-op while one is already open. */
    beginDraft: () => void;
    setDraft: (design: NajmDesignConfig) => void;
    cancelDraft: () => void;
    /** Adopt a design the application persisted, discarding any draft. */
    setCommitted: (design: NajmDesignConfig) => void;
}
/**
 * The draft/commit layer a runtime theme editor needs.
 *
 * Returns `null` outside a provider, so a component that only *offers* theme
 * editing stays mountable in an application that has none.
 *
 * The editor holds no opinion about persistence: an application saves through
 * whatever its own API is, then hands the result back via `setCommitted`. That
 * is the same split `NajmPreferencesProvider` draws for theme and time zone.
 */
declare function useNajmDesignEditor(): NajmDesignEditorValue | null;
interface NajmDesignEditorProviderProps {
    children: React$1.ReactNode;
    /**
     * Controlled design. When given, this provider only forwards it and every
     * command below is inert — the application already owns the state.
     */
    design?: NajmDesignConfig;
    /**
     * Seeds design state this provider owns from then on; ignored after mount.
     *
     * Uncontrolled on purpose, matching `initialTheme` and `initialTimeZone`:
     * the page is rendered once against what the server resolved, and every
     * change after that originates in the editor.
     */
    initialDesign?: NajmDesignConfig;
}
declare function NajmDesignEditorProvider({ children, design, initialDesign, }: NajmDesignEditorProviderProps): React$1.JSX.Element;

declare const DEFAULT_TOOLBAR_KEY_PREFIX = "common.table";
type DefaultToolbarPrefix = typeof DEFAULT_TOOLBAR_KEY_PREFIX;
/** The twelve catalog keys `buildToolbarLabels` reads under `Prefix`. */
type ToolbarKey<Prefix extends string = DefaultToolbarPrefix> = `${Prefix}.settings` | `${Prefix}.view` | `${Prefix}.columns` | `${Prefix}.modeTable` | `${Prefix}.modeCards` | `${Prefix}.modeJson` | `${Prefix}.modeFiles` | `${Prefix}.modeOption` | `${Prefix}.filters` | `${Prefix}.filterRegion` | `${Prefix}.allOption` | `${Prefix}.create`;
/**
 * Projects a translator onto the toolbar labels, matching
 * `buildPaginationLabels` — same prefix convention, same key-per-field naming.
 *
 * `modeOption` interpolates `mode` with the already-translated visible name, so
 * a catalog writes one template rather than four accessible names.
 *
 * No result is inspected or second-guessed, for the reason given on
 * `buildPaginationLabels`: a translator that echoes a missing key renders that
 * key, which is the signal the entry is missing.
 */
declare function buildToolbarLabels<Prefix extends string = DefaultToolbarPrefix>(t: NajmTranslate<ToolbarKey<Prefix>>, prefix?: Prefix): NTableToolbarLabels;

/** Returns the active mode inherited from the nearest Najm theme provider. */
declare function useNajmThemeMode(): NajmMode | undefined;
declare function useNajmAppearance(): NajmAppearance;
declare function NajmThemeProvider({ config, preset, mode, accent, tokens, accentOnly, appearance, radius, className, asChild, children, }: NajmThemeProviderProps): React$1.JSX.Element;

declare const THEME_TOKEN_KEYS: readonly ["background", "foreground", "card", "card-foreground", "popover", "popover-foreground", "primary", "primary-foreground", "secondary", "secondary-foreground", "tertiary", "tertiary-foreground", "muted", "muted-foreground", "accent", "accent-foreground", "destructive", "destructive-foreground", "border", "input", "ring", "sidebar", "sidebar-foreground", "sidebar-primary", "sidebar-primary-foreground", "sidebar-accent", "sidebar-accent-foreground", "sidebar-border", "sidebar-ring", "chart-1", "chart-2", "chart-3", "chart-4", "chart-5"];
type ThemeCustomizerTokenKey = (typeof THEME_TOKEN_KEYS)[number];

type NThemeCustomizerTab = "theme" | "typography";
interface NThemeCustomizerFontOption {
    value: string;
    label: React$1.ReactNode;
}
type NThemeCustomizerTokenLabels = {
    [K in ThemeCustomizerTokenKey]: React$1.ReactNode;
};
interface NThemeCustomizerOptionLabels {
    scale: Partial<Record<"compact" | "default" | "comfortable", React$1.ReactNode>>;
}
interface NThemeCustomizerLabels {
    themeTab: React$1.ReactNode;
    typographyTab: React$1.ReactNode;
    lightMode: React$1.ReactNode;
    darkMode: React$1.ReactNode;
    resetField: React$1.ReactNode;
    resetSection: React$1.ReactNode;
    importTheme: React$1.ReactNode;
    exportTheme: React$1.ReactNode;
    invalidThemeFile: React$1.ReactNode;
    /** Override the swatch button's accessible name when no token label is provided. */
    colorSwatchFallback: React$1.ReactNode;
    defaultOption: React$1.ReactNode;
    themeSection: React$1.ReactNode;
    typographySection: React$1.ReactNode;
    layoutSubsection: React$1.ReactNode;
    pageHeaderSubsection: React$1.ReactNode;
    sidebarSubsection: React$1.ReactNode;
    tableSubsection: React$1.ReactNode;
    inputSubsection: React$1.ReactNode;
    previewMode: React$1.ReactNode;
    surfaceGroup: React$1.ReactNode;
    brandGroup: React$1.ReactNode;
    feedbackGroup: React$1.ReactNode;
    borderFocusGroup: React$1.ReactNode;
    sidebarGroup: React$1.ReactNode;
    chartsGroup: React$1.ReactNode;
    globalRadius: React$1.ReactNode;
    globalBorderWidth: React$1.ReactNode;
    fontSans: React$1.ReactNode;
    fontHeading: React$1.ReactNode;
    fontMono: React$1.ReactNode;
    advancedTypography: React$1.ReactNode;
    baseSize: React$1.ReactNode;
    scale: React$1.ReactNode;
    lineHeight: React$1.ReactNode;
    letterSpacing: React$1.ReactNode;
    pageGutter: React$1.ReactNode;
    sectionGap: React$1.ReactNode;
    pageHeaderCard: React$1.ReactNode;
    sidebarSections: React$1.ReactNode;
    sidebarNoSections: React$1.ReactNode;
    sidebarSectionLabels: React$1.ReactNode;
    sidebarSectionSeparators: React$1.ReactNode;
    sidebarExpandedWidth: React$1.ReactNode;
    sidebarCollapsedWidth: React$1.ReactNode;
    sidebarMobileWidth: React$1.ReactNode;
    tableHeaderColor: React$1.ReactNode;
    tableHeaderTextColor: React$1.ReactNode;
    tableBorderColor: React$1.ReactNode;
    inputBorderWidth: React$1.ReactNode;
    /** Per-token display labels keyed by `ThemeCustomizerTokenKey`. */
    tokens: Partial<NThemeCustomizerTokenLabels>;
    /** Localized labels for the enum-style options. */
    options: Partial<NThemeCustomizerOptionLabels>;
}
/** A named design the host has stored somewhere and can restore later. */
interface NThemePreset {
    id: string;
    name: string;
    design: NajmDesignConfig;
    /** Marks a preset the host ships rather than one the user created. */
    isBuiltIn?: boolean;
}
type NThemePresetsStatus = "idle" | "loading" | "error";
interface NThemePresetsLabels {
    title: React$1.ReactNode;
    description: React$1.ReactNode;
    empty: React$1.ReactNode;
    loadError: React$1.ReactNode;
    select: React$1.ReactNode;
    selectPlaceholder: React$1.ReactNode;
    /** Row that restores the host's currently stored design. */
    savedOption: React$1.ReactNode;
    saveCurrent: React$1.ReactNode;
    saveTitle: React$1.ReactNode;
    saveDescription: React$1.ReactNode;
    saveAction: React$1.ReactNode;
    nameLabel: React$1.ReactNode;
    namePlaceholder: React$1.ReactNode;
    delete: React$1.ReactNode;
    deleteTitle: React$1.ReactNode;
    /** Supports a `{name}` placeholder. */
    deleteDescription: React$1.ReactNode;
    cancel: React$1.ReactNode;
}
interface NThemePresetsProps {
    presets: readonly NThemePreset[];
    /** `null` means the host's stored design is showing, not a preset. */
    selectedPresetId?: string | null;
    /** Shown as the first row so the user can drop a preview. Omit to hide it. */
    savedDesign?: NajmDesignConfig;
    status?: NThemePresetsStatus;
    /** Receives `null` when the user picks the stored-design row. */
    onSelect: (preset: NThemePreset | null) => void;
    /** Omit to hide the save control. */
    onSave?: (name: string) => void | Promise<void>;
    /** Omit to hide every delete control. */
    onDelete?: (preset: NThemePreset) => void | Promise<void>;
    labels: NThemePresetsLabels;
    disabled?: boolean;
    className?: string;
}
interface NThemeCustomizerProps {
    value: NajmDesignConfig;
    factoryValue: NajmDesignConfig;
    onChange: (value: NajmDesignConfig) => void;
    /** Overrides the active mode inherited from the nearest Najm theme provider. */
    previewMode?: NajmMode;
    /** Handles the opt-in internal light/dark control in standalone editors. */
    onPreviewModeChange?: (mode: NajmMode) => void;
    /** Whether to show the internal light/dark control. Defaults to `false`. */
    showPreviewMode?: boolean;
    /** Whether to show JSON import/export actions. Defaults to `true`. */
    showFileActions?: boolean;
    /** Whether to show the internal section reset action. Defaults to `true`. */
    showResetAction?: boolean;
    /** Download filename used by the Export action. Defaults to `najm-theme.json`. */
    exportFileName?: string;
    /** Receives strict JSON parsing or design-contract validation failures. */
    onImportError?: (error: Error) => void;
    /**
     * Whether to render the internal Theme/Typography tab bar. Defaults to `true`.
     * When `false`, the first resolved entry from `tabs` is rendered directly so
     * a host application can present a single section inside its own tabs.
     */
    showTabs?: boolean;
    tabs?: readonly NThemeCustomizerTab[];
    fontOptions?: readonly NThemeCustomizerFontOption[];
    labels?: Partial<NThemeCustomizerLabels>;
    /**
     * Saved designs offered above the editor. Provide this plus `onPresetSelect`
     * to render the picker; the customizer stays presentational and never stores
     * a preset itself.
     */
    presets?: readonly NThemePreset[];
    selectedPresetId?: string | null;
    presetsStatus?: NThemePresetsStatus;
    /**
     * The design the host currently has stored, offered as the "current saved
     * theme" row so a preview can be dropped. Defaults to `factoryValue`, which
     * is only correct when the host has not persisted anything of its own.
     */
    savedDesign?: NajmDesignConfig;
    onPresetSelect?: (preset: NThemePreset | null) => void;
    onPresetSave?: (name: string) => void | Promise<void>;
    onPresetDelete?: (preset: NThemePreset) => void | Promise<void>;
    presetLabels?: Partial<NThemePresetsLabels>;
    disabled?: boolean;
    className?: string;
}

declare function NThemeCustomizer({ value, factoryValue, onChange, previewMode, onPreviewModeChange, showPreviewMode, showFileActions, showResetAction, exportFileName, onImportError, showTabs, tabs, fontOptions, labels, presets, selectedPresetId, presetsStatus, savedDesign, onPresetSelect, onPresetSave, onPresetDelete, presetLabels, disabled, className, }: NThemeCustomizerProps): React$1.JSX.Element;

/** Sentinel row that drops the preview and shows the host's saved design. */
declare const NAJM_SAVED_THEME_VALUE = "__najm_saved_theme__";
/**
 * Saved-theme picker for `NThemeCustomizer`. Presentational only: the host owns
 * where presets live and what saving one means. Selecting a row hands the
 * design back through `onSelect` so the host can preview it before persisting.
 */
declare function NThemePresets({ presets, selectedPresetId, savedDesign, status, onSelect, onSave, onDelete, labels, disabled, className, }: NThemePresetsProps): React$1.JSX.Element;

declare const DEFAULT_THEME_FILE_NAME = "najm-theme.json";
declare function parseThemeFile(content: string): NajmDesignConfig;
declare function stringifyThemeFile(config: NajmDesignConfig): string;
declare function normalizeThemeFileName(fileName: string | undefined): string;

/** Keeps authored TypeScript theme objects type-checked without changing them. */
declare function defineNajmThemeConfig(config: NajmThemeConfig): NajmThemeConfig;
/** Parses and validates theme settings loaded from JSON, an API, or local storage. */
declare function parseNajmThemeConfig(input: unknown): NajmThemeConfig;
declare function stringifyNajmThemeConfig(config: NajmThemeConfig, space?: number): string;

declare function composePreset(mode: NajmMode, accent: NajmAccent): NajmThemeTokens;
declare function resolvePreset(preset: NajmPreset): NajmThemeTokens;

interface NajmDesignContextValue {
    components: NajmComponentThemeConfig;
    typography?: NajmTypographyConfig;
    layout?: NajmLayoutConfig;
}
declare function useNajmDesign(): NajmDesignContextValue;
/** Returns the resolved component style recipe for a given component name. */
declare function useNajmComponentStyle(name: NajmComponentName): NajmComponentStyleConfig | undefined;
interface NajmDesignProviderProps {
    config: NajmDesignConfig;
    mode?: NajmMode;
    className?: string;
    children: React$1.ReactNode;
}
/**
 * Applies a full design config: wraps children in NajmThemeProvider for theme
 * tokens, applies typography CSS variables, and exposes component recipes via
 * context. NajmThemeProvider continues to work standalone for token-only needs.
 */
declare function NajmDesignProvider({ config, mode, className, children, }: NajmDesignProviderProps): React$1.JSX.Element;

type NajmBorderSide = 'all' | 'top' | 'right' | 'bottom' | 'left' | 'start' | 'end';
/**
 * Border utility for structural surfaces (cards, tables, dividers, side rails).
 * `bordered === false` returns a per-side reset so primitives that already
 * include a base Tailwind `border`/`border-r`/etc. still drop the border.
 */
declare function surfaceBorderClasses(bordered?: boolean | undefined, side?: NajmBorderSide): string;
/**
 * Border utility for sidebar surfaces. Uses the dedicated `sidebar-border`
 * token so the sidebar edge can be themed independently from the main
 * `border` token.
 */
declare function sidebarBorderClasses(bordered?: boolean | undefined, side?: NajmBorderSide): string;
/** Border utility for form fields (inputs, selects). */
declare function inputBorderClasses(bordered?: boolean | undefined): string;

/**
 * The kit's keyboard focus indicator.
 *
 * `:focus-visible` rather than `:focus`, so a mouse click on a button does not
 * leave a ring behind — the indicator appears for the users who navigate by
 * keyboard and need to know where they are.
 */
declare const focusRingClasses = "outline-none focus-visible:ring-[3px] focus-visible:ring-ring/50";
/**
 * The same indicator, for a wrapper that owns the field a child is focused in.
 *
 * Composite inputs put the border, padding and background on a wrapper and
 * strip the inner control bare, so focus lands on an element that is invisible
 * by design while the thing the user sees as "the field" is its parent. Ringing
 * the inner control would draw inside the border; the wrapper has to light up.
 *
 * Both selectors, because both happen: the multi-select trigger is itself the
 * focusable element, and the number field holds a real `<input>` inside. `:has`
 * rather than `:focus-within` so this stays a keyboard indicator either way.
 */
declare const focusRingWithinClasses = "focus-visible:ring-[3px] focus-visible:ring-ring/50 has-[:focus-visible]:ring-[3px] has-[:focus-visible]:ring-ring/50";

interface KeyboardOptions {
    enabled?: boolean;
    preventDefault?: boolean;
    /**
     * When `true` (default), ignore key events that originate inside editable
     * text fields: `<input type="text|search|email|password|tel|url|number|...">`,
     * `<textarea>`, `<select>`, `[contenteditable]`, and `[role="combobox"]`.
     * Non-text inputs (checkbox, radio, button, submit) still pass through so
     * shortcuts like Ctrl+A keep working from a focused row checkbox.
     */
    ignoreInputs?: boolean;
    /**
     * When provided, only fire when the keydown's `e.target` is contained by
     * this element. Useful for scoping shortcuts to one mounted component
     * instance (e.g., one NTable on a page that contains several).
     */
    scopeRef?: RefObject<HTMLElement | null>;
}
declare function useKeyboard(shortcut: string, handler: (e: KeyboardEvent) => void, options?: KeyboardOptions): void;

declare function useDelayedLoading(delay?: number): boolean;

interface UseClickOutsideOptions {
    enabled?: boolean;
    onClickOutside: () => void;
}
declare function useClickOutside(ref: React.RefObject<HTMLElement | null>, options: UseClickOutsideOptions): void;

declare function useDebouncedValue<T>(value: T, delay: number): T;

declare function useLocalStorageState<T>(key: string, initialValue: T): [T, React.Dispatch<React.SetStateAction<T>>];

declare function useInfiniteScroll(hasMore: boolean, onLoadMore: () => void, options?: {
    rootMargin?: string;
}): {
    sentinelRef: React$1.RefObject<HTMLDivElement>;
    scrollContainerRef: React$1.RefObject<HTMLElement>;
    observe: () => () => void;
    doneLoading: () => void;
};

declare function useSelection(visibleIds: string[]): {
    selectedIds: Set<string>;
    toggleRow: (id: string) => void;
    toggleAllVisible: () => void;
    clearSelection: () => void;
    allVisibleSelected: boolean;
    someVisibleSelected: boolean;
};

/**
 * A media query read during render rather than after it.
 *
 * `matchMedia` answers synchronously, so the answer belongs in the render that
 * asks for it. Holding it in state and filling it from an effect makes every
 * mount paint one frame of the wrong viewport: on a desktop table page that
 * frame renders the card skeleton, which is then torn down for the table
 * skeleton, so a single load appears to load twice.
 *
 * `useSyncExternalStore` still uses `serverSnapshot` for SSR and for the
 * hydration render — nothing can be measured before the document exists — but
 * every render after that, including every client-side navigation, reads the
 * live value on its first pass.
 */
declare function useMediaQuery(query: string, serverSnapshot?: boolean): boolean;
/**
 * The viewport width below which a table renders as cards. Matches the `lg`
 * breakpoint, which is where a row of table columns stops fitting.
 */
declare const DEFAULT_CARD_BREAKPOINT = 1024;
/** Whether the viewport is narrow enough that a table should render as cards. */
declare function useCardViewport(breakpoint?: number): boolean;
/** The same decision as `useCardViewport`, as the mode name NTable takes. */
declare function useDesktopTableMode(breakpoint?: number): "table" | "cards";

declare const buttonVariants: (props?: {
    variant?: "secondary" | "tertiary" | "destructive" | "default" | "link" | "ghost" | "outline" | "success" | "warning" | "info" | "soft" | "subtle" | "plain";
    size?: "default" | "icon" | "sm" | "md" | "lg" | "xl" | "2xl" | "xs" | "2xs" | "icon-xs" | "icon-sm" | "icon-lg" | "icon-xl";
    rounded?: "none" | "default" | "sm" | "md" | "lg" | "xl" | "2xl" | "full";
    fullWidth?: boolean;
} & class_variance_authority_types.ClassProp) => string;
type ButtonVariantProps = VariantProps<typeof buttonVariants>;
type AsyncClickHandler = (event: React$1.MouseEvent<HTMLButtonElement>) => void | Promise<unknown>;
type ButtonVariant = NonNullable<ButtonVariantProps["variant"]>;
type ButtonSize = NonNullable<ButtonVariantProps["size"]>;
type ButtonRounded = NonNullable<ButtonVariantProps["rounded"]>;
type ButtonLoaderPosition = "left" | "right" | "center";
type ButtonIcon = NIconSource;
interface ButtonProps extends Omit<React$1.ButtonHTMLAttributes<HTMLButtonElement>, "onClick">, ButtonVariantProps {
    asChild?: boolean;
    loading?: boolean;
    autoLoading?: boolean;
    disabledWhileLoading?: boolean;
    loadingText?: React$1.ReactNode;
    loader?: React$1.ReactNode;
    loaderPosition?: ButtonLoaderPosition;
    leftIcon?: ButtonIcon;
    rightIcon?: ButtonIcon;
    bordered?: boolean;
    onClick?: AsyncClickHandler;
}
type NButtonProps = ButtonProps;
declare const Button: React$1.ForwardRefExoticComponent<ButtonProps & React$1.RefAttributes<HTMLButtonElement>>;
declare const NButton: React$1.ForwardRefExoticComponent<ButtonProps & React$1.RefAttributes<HTMLButtonElement>>;

/**
 * The status vocabulary every dashboard ends up retyping: lifecycle, review,
 * fulfilment and money states mapped onto the semantic badge colors.
 *
 * Shipped as a default so `<NBadge status="approved" />` is already correct
 * without a per-app table. A consumer's own `statusMap` is consulted first and
 * merges rather than replaces, so overriding one key costs only that key.
 */
declare const NAJM_STATUS_COLORS: Record<string, BadgeColor>;
/**
 * Text-only colors per badge color, for the `text`/`minimal` looks and for
 * plain text that has to agree with a nearby badge — an amount rendered in the
 * color of the payment it belongs to, say.
 *
 * `neutral` is `text-muted-foreground`, not `text-neutral-foreground`: the
 * `-foreground` token is the contrast color *on* a solid neutral fill, so it
 * reads as near-white in light mode and near-black in dark, and is unreadable
 * anywhere else.
 */
declare const NAJM_COLOR_TEXT_CLASSES: Record<BadgeColor, string>;
/**
 * `Out_For_Delivery `, `out-for-delivery` and `out for delivery` are the same
 * status key.
 *
 * Exported because it is the *one* rule: colors, icons, and labels all key off
 * a status the same way, and an application whose own status handling has to
 * agree with a badge should not have to guess it.
 */
declare function normalizeStatusToken(status: string): string;
/** The looked-up color, or `undefined` when nothing claims this status. */
declare function findStatusColor(status: string | undefined, statusMap?: Record<string, BadgeColor>): BadgeColor | undefined;
/**
 * Resolves a status token to a badge color: the consumer's map first, then the
 * built-in vocabulary, then `fallback`.
 *
 * The fallback is `neutral` rather than `primary` because an unrecognized
 * status is exactly the thing that must not shout.
 */
declare function resolveStatusColor(status: string | undefined, statusMap?: Record<string, BadgeColor>, fallback?: BadgeColor): BadgeColor;
/** The text-only class for a badge color. */
declare function colorTextClass(color: BadgeColor): string;
/**
 * The text-only class for a status token, for text that is *not* a badge — an
 * amount that should carry the color of the payment beside it.
 *
 * An unmapped status returns `""` so the text keeps the surrounding color;
 * pass `fallback` to color it anyway.
 */
declare function statusTextClass(status: string | undefined, statusMap?: Record<string, BadgeColor>, fallback?: BadgeColor): string;

type IndicatorVertical = "top" | "middle" | "bottom";
type IndicatorHorizontal = "start" | "center" | "end";
type IndicatorPosition = `${IndicatorVertical}-${IndicatorHorizontal}`;
type IndicatorResponsivePosition = Partial<Record<"base" | "sm" | "md" | "lg" | "xl" | "2xl", IndicatorPosition>>;
type IndicatorOverlay = "dot" | "status" | "badge" | "button" | "custom";
type IndicatorSize = "sm" | "md" | "lg";
interface IndicatorProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "children" | "content" | "color" | "default"> {
    children: React$1.ReactNode;
    position?: IndicatorPosition | IndicatorResponsivePosition;
    overlay?: IndicatorOverlay;
    color?: BadgeColor;
    size?: IndicatorSize;
    shape?: BadgeShape;
    content?: React$1.ReactNode;
    ping?: boolean;
    pulse?: boolean;
    className?: string;
    overlayClassName?: string;
}
declare const indicatorVariants: (props?: {} & class_variance_authority_types.ClassProp) => string;
declare function NIndicator({ children, position, overlay, color, size, shape, content, ping, pulse, className, overlayClassName, ...rest }: IndicatorProps): React$1.JSX.Element;
declare namespace NIndicator {
    var displayName: string;
}
declare const Indicator: typeof NIndicator;

declare const Input: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref"> & React$1.RefAttributes<HTMLInputElement>>;

declare const Textarea: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.TextareaHTMLAttributes<HTMLTextAreaElement>, HTMLTextAreaElement>, "ref"> & React$1.RefAttributes<HTMLTextAreaElement>>;

declare function Label({ className, ...props }: React$1.ComponentProps<typeof LabelPrimitive.Root>): React$1.JSX.Element;

declare function Card({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
declare function CardHeader({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
declare function CardTitle({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
declare function CardDescription({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
declare function CardAction({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
declare function CardContent({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
declare function CardFooter({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;

declare function Dialog({ ...props }: React$1.ComponentProps<typeof DialogPrimitive.Root>): React$1.JSX.Element;
declare function DialogTrigger({ ...props }: React$1.ComponentProps<typeof DialogPrimitive.Trigger>): React$1.JSX.Element;
declare function DialogPortal({ ...props }: React$1.ComponentProps<typeof DialogPrimitive.Portal>): React$1.JSX.Element;
declare function DialogClose({ ...props }: React$1.ComponentProps<typeof DialogPrimitive.Close>): React$1.JSX.Element;
declare function DialogOverlay({ className, ...props }: React$1.ComponentProps<typeof DialogPrimitive.Overlay>): React$1.JSX.Element;
type DialogPadding = "none" | "sm" | "md" | "lg";
interface DialogContentProps extends React$1.ComponentProps<typeof DialogPrimitive.Content> {
    /** Controls the padding of the dialog surface. `none` also collapses the header/body/footer gap. Defaults to `sm` on mobile, `md` on desktop. */
    padding?: DialogPadding;
    /** Hides the built-in close (X) in the top inline-end corner. Use when the content provides its own close control (e.g. inside a page header). */
    hideClose?: boolean;
    /** Optional layer classes for the portal overlay. Useful for dialogs opened from another modal surface. */
    overlayClassName?: string;
}
declare function DialogContent({ className, children, padding, hideClose, overlayClassName, onOpenAutoFocus, onCloseAutoFocus, ...props }: DialogContentProps): React$1.JSX.Element;
declare function DialogHeader({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
declare function DialogFooter({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
declare function DialogTitle({ className, ...props }: React$1.ComponentProps<typeof DialogPrimitive.Title>): React$1.JSX.Element;
declare function DialogDescription({ className, ...props }: React$1.ComponentProps<typeof DialogPrimitive.Description>): React$1.JSX.Element;

type SelectItemType = {
    value: string;
    label: string;
    icon?: string | ComponentType<{
        className?: string;
    }>;
};
type DialogSize = 'sm' | 'md' | 'lg' | 'xl' | 'xxl' | 'full';
type DialogWidth = 'sm' | 'md' | 'lg' | 'xl' | 'xxl' | '3xl' | '4xl' | '5xl' | '6xl' | '7xl' | 'full' | 'auto';
type DialogHeight = 'auto' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl' | 'full';
type RenderSlot<T = any> = T | ((ctx: T) => ReactNode);

interface PageHeaderSlotProps {
    children: ReactNode;
    className?: string;
}
type NPageHeaderBreakpoint = 'sm' | 'md' | 'lg';
interface NPageHeaderProps {
    icon: ComponentType<{
        className?: string;
    }>;
    title: string;
    subtitle?: string;
    actions?: ReactNode;
    /**
     * Optional consumer-owned replacement for `actions` on smaller screens.
     * Pass an icon button, dropdown, or any other compact control. When omitted,
     * the regular actions keep rendering at every viewport size.
     */
    compactActions?: ReactNode;
    filters?: ReactNode;
    top?: ReactNode;
    /** Must match the paired NSidebar breakpoint so its hamburger has reserved space. */
    mobileBreakpoint?: NPageHeaderBreakpoint;
    /** Renders the mobile sidebar trigger inside the header's leading column. */
    onSidebarOpen?: () => void;
    sidebarTriggerLabel?: string;
    sidebarTriggerClassName?: string;
    search?: InputHTMLAttributes<HTMLInputElement> & {
        placeholder?: string;
        ref?: Ref<HTMLInputElement>;
    };
    children?: ReactNode;
    className?: string;
    headerClassName?: string;
    /** Renders the header as a card-like surface. `bordered` is kept as an alias. */
    card?: boolean;
    bordered?: boolean;
}
declare function NPageHeaderActions({ children, className }: PageHeaderSlotProps): React__default.JSX.Element;
declare namespace NPageHeaderActions {
    var displayName: string;
}
declare function NPageHeaderCompactActions({ children, className }: PageHeaderSlotProps): React__default.JSX.Element;
declare namespace NPageHeaderCompactActions {
    var displayName: string;
}
declare function NPageHeaderFilters({ children, className }: PageHeaderSlotProps): React__default.JSX.Element;
declare namespace NPageHeaderFilters {
    var displayName: string;
}
declare function NPageHeaderTop({ children, className }: PageHeaderSlotProps): React__default.JSX.Element;
declare namespace NPageHeaderTop {
    var displayName: string;
}
declare function NPageHeader({ icon: Icon, title, subtitle, actions, compactActions, filters, top, mobileBreakpoint: mobileBreakpointProp, onSidebarOpen, sidebarTriggerLabel, sidebarTriggerClassName, search, children, className, headerClassName, card, bordered, }: NPageHeaderProps): React__default.JSX.Element;

type DialogActionMode = "auto" | "dialog" | "content";
type DialogVariant = "default" | "window";
interface ButtonConfig {
    text: string;
    className?: string;
    variant?: "default" | "destructive" | "secondary" | "outline" | "tertiary" | "ghost";
    icon?: NIconSource;
    loadingText?: string;
    onClick?: (data?: any) => void | Promise<void>;
    onConfirm?: (data?: any) => void | Promise<void>;
    loading?: boolean;
    disabled?: boolean;
    form?: string;
}
interface DialogRenderContext {
    dialog: DialogConfig;
    index: number;
    zIndex: number;
    close: (result?: any) => void;
    confirm: (data?: any) => Promise<void>;
    cancel: (data?: any) => Promise<void>;
    onOpenChange: (open: boolean) => void;
}
type DialogRenderer = (context: DialogRenderContext) => ReactNode;
interface DialogConfig {
    id: string;
    title?: string;
    description?: string;
    /** Renders an NPageHeader as the dialog's header (icon, title, subtitle, actions). Replaces the plain title/description header; `title` is still used as the accessible label. */
    pageHeader?: NPageHeaderProps;
    /** Padding preset for the dialog surface. `none` is ideal for full-bleed content (custom headers, tables). Defaults to `md`. */
    padding?: DialogPadding;
    children?: ReactNode;
    primaryButton?: ButtonConfig;
    secondaryButton?: ButtonConfig;
    showButtons: boolean;
    size?: DialogSize;
    width?: DialogWidth;
    height?: DialogHeight;
    className?: string;
    /** Class applied to the rendered dialog header. */
    headerClassName?: string;
    /** Class applied to the dialog title. */
    titleClassName?: string;
    /** Class applied to the dialog description. */
    descriptionClassName?: string;
    /** Class applied to the inline close button used by window/page-header dialogs. */
    closeButtonClassName?: string;
    /** Visual treatment for the dialog chrome. `window` adds a compact title bar with an inline bordered close button. */
    variant?: DialogVariant;
    actionMode?: DialogActionMode;
    render?: DialogRenderer;
}
/** Internal store shape that adds promise handlers. */
interface PromiseDialogConfig extends DialogConfig {
    resolve?: (value: any) => void;
    reject?: (reason?: any) => void;
}
interface PushDialogOptions {
    title?: string;
    description?: string;
    /** Renders an NPageHeader as the dialog's header (icon, title, subtitle, actions). Replaces the plain title/description header; `title` is still used as the accessible label. */
    pageHeader?: NPageHeaderProps;
    /** Padding preset for the dialog surface. `none` is ideal for full-bleed content (custom headers, tables). Defaults to `md`. */
    padding?: DialogPadding;
    children?: ReactNode;
    primaryButton?: Partial<ButtonConfig>;
    secondaryButton?: Partial<ButtonConfig>;
    showButtons?: boolean;
    size?: DialogSize;
    width?: DialogWidth;
    height?: DialogHeight;
    className?: string;
    /** Class applied to the rendered dialog header. */
    headerClassName?: string;
    /** Class applied to the dialog title. */
    titleClassName?: string;
    /** Class applied to the dialog description. */
    descriptionClassName?: string;
    /** Class applied to the inline close button used by window/page-header dialogs. */
    closeButtonClassName?: string;
    /** Visual treatment for the dialog chrome. `window` adds a compact title bar with an inline bordered close button. */
    variant?: DialogVariant;
    /**
     * Controls which layer owns action buttons.
     * - auto: hide dialog buttons when content declares its own actions
     * - dialog: always use the dialog footer
     * - content: never render the dialog footer buttons
     */
    actionMode?: DialogActionMode;
    render?: DialogRenderer;
}
interface DeleteDialogOptions {
    title?: string;
    description?: string;
    itemName: string;
    itemType?: string;
    icon?: NIconSource;
    warningText?: string;
    confirmText?: string;
    cancelText?: string;
    size?: DialogSize;
    className?: string;
    loading?: boolean;
    onConfirm?: () => void | Promise<void>;
}
interface DialogApi {
    custom: (options: PushDialogOptions) => Promise<any>;
    openDialog: (options: PushDialogOptions) => Promise<any>;
    confirmDelete: (options: DeleteDialogOptions) => Promise<any>;
    closeAll: () => void;
    push: (options: PushDialogOptions) => Promise<any>;
    pop: (result?: any) => Promise<void>;
}

interface DialogStoreState {
    dialogs: PromiseDialogConfig[];
    pushDialog: (config: PushDialogOptions) => Promise<any>;
    popDialog: (result?: any) => Promise<void>;
    closeDialog: (id: string, result?: any) => void;
    closeAllDialogs: () => void;
    getCurrentDialog: () => PromiseDialogConfig | undefined;
    setPrimaryLoading: (loading: boolean) => void;
    setSecondaryLoading: (loading: boolean) => void;
    updatePrimaryButton: (config: Partial<ButtonConfig>, dialogId?: string) => void;
    updateSecondaryButton: (config: Partial<ButtonConfig>, dialogId?: string) => void;
    updateShowButtons: (show: boolean, dialogId?: string) => void;
    handlePrimaryClick: (dialogId: string, data?: any) => Promise<void>;
    handleSecondaryClick: (dialogId: string, data?: any) => Promise<void>;
    handleConfirm: (data?: any) => Promise<void>;
    handleOpenChange: (dialogId: string, open: boolean) => void;
}
declare function createDialogStore(): zustand.UseBoundStore<zustand.StoreApi<DialogStoreState>>;
type DialogStore = ReturnType<typeof createDialogStore>;
declare function useDialogStore(): DialogStore;

interface NDialogHeaderProps {
    label?: string;
    children?: string;
    className?: string;
    titleClassName?: string;
}
interface NDialogDescriptionProps {
    label?: string;
    children?: string;
    className?: string;
}
interface NDialogActionProps extends Omit<Partial<ButtonConfig>, "text"> {
    label?: string;
    children?: string;
}
/** Declarative title slot for direct NDialog usage. Rendered by NDialog, not by itself. */
declare function NDialogHeader(_props: NDialogHeaderProps): any;
/** Declarative description slot for direct NDialog usage. Rendered by NDialog, not by itself. */
declare function NDialogDescription(_props: NDialogDescriptionProps): any;
/** Declarative primary-action slot for direct NDialog usage. */
declare function NDialogPrimaryButton(_props: NDialogActionProps): any;
/** Declarative secondary-action slot for direct NDialog usage. */
declare function NDialogSecondaryButton(_props: NDialogActionProps): any;
declare const dialogVariants: (props?: {
    variant?: "default" | "window";
    size?: "sm" | "md" | "lg" | "xl" | "full" | "xxl";
    width?: "auto" | "sm" | "md" | "lg" | "xl" | "full" | "xxl" | "3xl" | "4xl" | "5xl" | "6xl" | "7xl";
    height?: "auto" | "sm" | "md" | "lg" | "xl" | "full" | "xxl";
} & class_variance_authority_types.ClassProp) => string;
interface NMultiDialogProps {
    store?: DialogStore;
}
declare function NMultiDialog({ store: storeProp }: NMultiDialogProps): React__default.JSX.Element;
interface NDialogDirectProps extends Omit<PushDialogOptions, "render"> {
    trigger?: React__default.ReactElement;
    open?: boolean;
    defaultOpen?: boolean;
    onOpenChange?: (open: boolean) => void;
    closeOnPrimary?: boolean;
    closeOnSecondary?: boolean;
}
type NDialogProps = NMultiDialogProps | NDialogDirectProps;
declare function NDialog(props: NDialogProps): React__default.JSX.Element;

interface NConfirmDialogProps {
    open: boolean;
    onOpenChange: (open: boolean) => void;
    title?: string;
    description?: string;
    confirmLabel?: string;
    cancelLabel?: string;
    onConfirm: () => void;
    variant?: "default" | "destructive";
    loading?: boolean;
    children?: React__default.ReactNode;
    icon?: NIconSource;
}
declare function NConfirmDialog({ open, onOpenChange, title, description, confirmLabel, cancelLabel, onConfirm, variant, loading, children, icon, }: NConfirmDialogProps): React__default.JSX.Element;

interface NDeleteDialogContentProps {
    title?: ReactNode;
    itemName: string;
    itemType?: string;
    icon?: NIconSource;
    warningText?: string;
    className?: string;
}
interface NDeleteDialogProps extends Omit<NDeleteDialogContentProps, "className"> {
    open?: boolean;
    title?: string;
    description?: string;
    confirmText?: string;
    cancelText?: string;
    loading?: boolean;
    zIndex?: number;
    className?: string;
    contentClassName?: string;
    onOpenChange?: (open: boolean) => void;
    onConfirm?: () => void | Promise<void>;
    onCancel?: () => void | Promise<void>;
}
declare function NDeleteDialogContent({ title, itemName, itemType, icon: Icon, warningText, className, }: NDeleteDialogContentProps): React$1.JSX.Element;
declare function NDeleteDialog({ open, title, description, itemName, itemType, icon, warningText, confirmText, cancelText, loading, zIndex, className, contentClassName, onOpenChange, onConfirm, onCancel, }: NDeleteDialogProps): React$1.JSX.Element;

declare function NPortalScopeProvider({ className, children }: {
    className?: string;
    children: ReactNode;
}): React__default.JSX.Element;
declare const useNPortalScope: () => string;
interface NSheetClassNames {
    content?: string;
    header?: string;
    body?: string;
    footer?: string;
}
interface NSheetProps {
    open: boolean;
    onOpenChange: (open: boolean) => void;
    icon: ComponentType<{
        className?: string;
    }>;
    title: ReactNode;
    description?: ReactNode;
    /** Sheet width in pixels. Default 480. */
    width?: number;
    side?: "left" | "right" | "top" | "bottom";
    /** Override portal scope class (otherwise inherits from NPortalScopeProvider). */
    portalClassName?: string;
    /** Slot-level class overrides for the sheet surface and its three sections. */
    classNames?: NSheetClassNames;
    /** @deprecated Use `classNames.body` instead. */
    bodyClassName?: string;
    /** @deprecated Use `classNames.content` instead. */
    contentClassName?: string;
    children: ReactNode;
    footer?: ReactNode;
}
/**
 * Standardized studio sheet primitive.
 * - Inline `style` width (bypasses Tailwind responsive-prefix-scoping issues in consumer apps).
 * - Inherits portal scope from `NPortalScopeProvider` so prefixed CSS (e.g. `.rs-studio`) reaches portaled content.
 * - One header + scrollable body + optional sticky footer.
 */
declare function NSheet({ open, onOpenChange, icon: Icon, title, description, width, side, portalClassName, classNames, bodyClassName, contentClassName, children, footer, }: NSheetProps): React__default.JSX.Element;

declare function useDialog(store?: DialogStore): DialogApi;

declare const alertVariants: (props?: {
    tone?: "destructive" | "default" | "success" | "warning" | "info" | "error";
    look?: "solid" | "outline" | "soft" | "dash";
    size?: "sm" | "md" | "lg";
    orientation?: "horizontal" | "vertical" | "responsive";
} & class_variance_authority_types.ClassProp) => string;
type AlertTone = NonNullable<VariantProps<typeof alertVariants>["tone"]>;
type AlertLook = NonNullable<VariantProps<typeof alertVariants>["look"]>;
type AlertSize = NonNullable<VariantProps<typeof alertVariants>["size"]>;
type AlertOrientation = NonNullable<VariantProps<typeof alertVariants>["orientation"]>;
type AlertVariant = AlertTone;
interface AlertProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "title">, VariantProps<typeof alertVariants> {
    variant?: AlertVariant;
    title?: React$1.ReactNode;
    description?: React$1.ReactNode;
    actions?: React$1.ReactNode;
    icon?: NIconSource | React$1.ReactNode | false;
}
declare function Alert({ className, variant, tone: toneProp, look, size, orientation, title, description, actions, icon, children, ...props }: AlertProps): React$1.JSX.Element;
declare const NAlert: typeof Alert;

declare function Sheet({ ...props }: React$1.ComponentProps<typeof DialogPrimitive.Root>): React$1.JSX.Element;
declare function SheetTrigger({ ...props }: React$1.ComponentProps<typeof DialogPrimitive.Trigger>): React$1.JSX.Element;
declare function SheetClose({ ...props }: React$1.ComponentProps<typeof DialogPrimitive.Close>): React$1.JSX.Element;
declare function SheetPortal({ ...props }: React$1.ComponentProps<typeof DialogPrimitive.Portal>): React$1.JSX.Element;
declare function SheetOverlay({ className, ...props }: React$1.ComponentProps<typeof DialogPrimitive.Overlay>): React$1.JSX.Element;
declare const sheetVariants: (props?: {
    side?: "left" | "right" | "bottom" | "top";
} & class_variance_authority_types.ClassProp) => string;
type SheetContentProps = React$1.ComponentProps<typeof DialogPrimitive.Content> & VariantProps<typeof sheetVariants> & {
    portalClassName?: string;
};
declare function SheetContent({ className, portalClassName, side, children, ...props }: SheetContentProps): React$1.JSX.Element;
declare function SheetHeader({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
declare function SheetFooter({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
declare function SheetTitle({ className, ...props }: React$1.ComponentProps<typeof DialogPrimitive.Title>): React$1.JSX.Element;
declare function SheetDescription({ className, ...props }: React$1.ComponentProps<typeof DialogPrimitive.Description>): React$1.JSX.Element;

declare function DropdownMenu({ ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.Root>): React$1.JSX.Element;
declare function DropdownMenuTrigger({ ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.Trigger>): React$1.JSX.Element;
declare function DropdownMenuGroup({ ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.Group>): React$1.JSX.Element;
declare function DropdownMenuPortal({ ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.Portal>): React$1.JSX.Element;
declare function DropdownMenuSub({ ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.Sub>): React$1.JSX.Element;
declare function DropdownMenuRadioGroup({ ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.RadioGroup>): React$1.JSX.Element;
declare function DropdownMenuSubTrigger({ className, inset, children, ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.SubTrigger> & {
    inset?: boolean;
}): React$1.JSX.Element;
declare function DropdownMenuSubContent({ className, children, style, ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.SubContent>): React$1.JSX.Element;
declare function DropdownMenuContent({ className, children, sideOffset, style, ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.Content>): React$1.JSX.Element;
declare function DropdownMenuItem({ className, inset, variant, ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.Item> & {
    inset?: boolean;
    variant?: "default" | "destructive";
}): React$1.JSX.Element;
declare function DropdownMenuCheckboxItem({ className, children, checked, ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.CheckboxItem>): React$1.JSX.Element;
declare function DropdownMenuRadioItem({ className, children, ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.RadioItem>): React$1.JSX.Element;
declare function DropdownMenuLabel({ className, inset, ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.Label> & {
    inset?: boolean;
}): React$1.JSX.Element;
declare function DropdownMenuSeparator({ className, ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.Separator>): React$1.JSX.Element;
declare function DropdownMenuShortcut({ className, ...props }: React$1.ComponentProps<"span">): React$1.JSX.Element;

declare function Popover({ ...props }: React$1.ComponentProps<typeof PopoverPrimitive.Root>): React$1.JSX.Element;
declare function PopoverTrigger({ ...props }: React$1.ComponentProps<typeof PopoverPrimitive.Trigger>): React$1.JSX.Element;
declare function PopoverAnchor({ ...props }: React$1.ComponentProps<typeof PopoverPrimitive.Anchor>): React$1.JSX.Element;
declare function PopoverContent({ className, align, sideOffset, ...props }: React$1.ComponentProps<typeof PopoverPrimitive.Content>): React$1.JSX.Element;

declare function Select({ ...props }: React$1.ComponentProps<typeof SelectPrimitive.Root>): React$1.JSX.Element;
declare function SelectGroup({ ...props }: React$1.ComponentProps<typeof SelectPrimitive.Group>): React$1.JSX.Element;
declare function SelectValue({ ...props }: React$1.ComponentProps<typeof SelectPrimitive.Value>): React$1.JSX.Element;
declare function SelectTrigger({ className, children, ...props }: React$1.ComponentProps<typeof SelectPrimitive.Trigger>): React$1.JSX.Element;
declare function SelectScrollUpButton({ className, ...props }: React$1.ComponentProps<typeof SelectPrimitive.ScrollUpButton>): React$1.JSX.Element;
declare function SelectScrollDownButton({ className, ...props }: React$1.ComponentProps<typeof SelectPrimitive.ScrollDownButton>): React$1.JSX.Element;
declare function SelectContent({ className, children, position, style, ...props }: React$1.ComponentProps<typeof SelectPrimitive.Content>): React$1.JSX.Element;
declare function SelectLabel({ className, ...props }: React$1.ComponentProps<typeof SelectPrimitive.Label>): React$1.JSX.Element;
declare function SelectItem({ className, children, ...props }: React$1.ComponentProps<typeof SelectPrimitive.Item>): React$1.JSX.Element;
declare function SelectSeparator({ className, ...props }: React$1.ComponentProps<typeof SelectPrimitive.Separator>): React$1.JSX.Element;

interface NativeSelectOption {
    value: string;
    label: string;
}
interface NativeSelectProps extends Omit<React$1.SelectHTMLAttributes<HTMLSelectElement>, "children"> {
    options: NativeSelectOption[];
    placeholder?: string;
}
declare const NativeSelect: React$1.ForwardRefExoticComponent<NativeSelectProps & React$1.RefAttributes<HTMLSelectElement>>;

declare function Checkbox({ className, ...props }: React$1.ComponentProps<typeof CheckboxPrimitive.Root>): React$1.JSX.Element;

declare function RadioGroup({ className, ...props }: React$1.ComponentProps<typeof RadioGroupPrimitive.Root>): React$1.JSX.Element;
declare function RadioGroupItem({ className, ...props }: React$1.ComponentProps<typeof RadioGroupPrimitive.Item>): React$1.JSX.Element;

type SwitchSize = 'xs' | 'sm' | 'default' | 'lg' | 'xl';
type SwitchColor = 'default' | 'primary' | 'secondary' | 'accent' | 'info' | 'success' | 'warning' | 'error' | 'neutral';
interface SwitchProps extends React$1.ComponentProps<typeof SwitchPrimitive.Root> {
    size?: SwitchSize;
    color?: SwitchColor;
}
declare function Switch({ className, size, color, ...props }: SwitchProps): React$1.JSX.Element;

type TabsVariant = "pills" | "underline" | "bordered" | "ghost";
type TabsOrientation = "horizontal" | "vertical";
interface TabsProps extends React$1.ComponentProps<typeof TabsPrimitive.Root> {
    variant?: TabsVariant;
    orientation?: TabsOrientation;
}
declare function Tabs({ className, variant, orientation, ...props }: TabsProps): React$1.JSX.Element;
interface TabsListProps extends React$1.ComponentProps<typeof TabsPrimitive.List> {
    variant?: TabsVariant;
    orientation?: TabsOrientation;
}
declare function TabsList({ className, variant, orientation, ...props }: TabsListProps): React$1.JSX.Element;
interface TabsTriggerProps extends React$1.ComponentProps<typeof TabsPrimitive.Trigger> {
    variant?: TabsVariant;
}
declare function TabsTrigger({ className, variant, ...props }: TabsTriggerProps): React$1.JSX.Element;
declare function TabsContent({ className, ...props }: React$1.ComponentProps<typeof TabsPrimitive.Content>): React$1.JSX.Element;

declare const TAB_COLORS: {
    readonly default: {
        readonly list: "bg-muted";
        readonly active: "bg-background";
    };
    readonly primary: {
        readonly list: "bg-primary/20";
        readonly active: "bg-primary/50";
    };
    readonly card: {
        readonly list: "bg-card";
        readonly active: "bg-muted";
    };
    readonly ghost: {
        readonly list: "bg-transparent";
        readonly active: "bg-accent";
    };
};
type NTabsColor = keyof typeof TAB_COLORS;

type NTabsItem<V extends string = string> = {
    value: V;
    label: React__default.ReactNode;
    icon?: NIconSource;
    content: React__default.ReactNode;
    disabled?: boolean;
};
type NTabsClassNames = {
    root?: string;
    list?: string;
    trigger?: string;
    content?: string;
};
type NTabsStyles = {
    root?: React__default.CSSProperties;
    list?: React__default.CSSProperties;
    trigger?: React__default.CSSProperties;
    activeTrigger?: React__default.CSSProperties;
    content?: React__default.CSSProperties;
};
interface NTabsProps<V extends string = string> {
    items: NTabsItem<V>[];
    defaultValue?: V;
    value?: V;
    onValueChange?: (value: V) => void;
    variant?: TabsVariant;
    orientation?: TabsOrientation;
    color?: NTabsColor;
    accentColor?: string;
    fullWidth?: boolean;
    className?: string;
    classNames?: NTabsClassNames;
    styles?: NTabsStyles;
}
declare function NTabs<V extends string = string>({ items, defaultValue, value, onValueChange, variant, orientation, color, accentColor, fullWidth, className, classNames, styles, }: NTabsProps<V>): React__default.JSX.Element;

type NEditorTab<V extends string = string> = {
    value: V;
    name: string;
    icon?: NIconSource;
    dirty?: boolean;
    closable?: boolean;
    disabled?: boolean;
    content?: React__default.ReactNode;
};
interface NEditorTabsProps<V extends string = string> {
    items: NEditorTab<V>[];
    value?: V;
    defaultValue?: V;
    onValueChange?: (value: V) => void;
    onClose?: (value: V) => void;
    className?: string;
    classNames?: NTabsClassNames;
    styles?: NTabsStyles;
}
/**
 * Given the tab list before a close, returns the value that should become
 * active after `closedValue` is removed: the previous tab, else the first
 * remaining one, else undefined when the list becomes empty.
 */
declare function getNextEditorTabValue<V extends string = string>(items: NEditorTab<V>[], closedValue: V): V | undefined;
declare function NEditorTabs<V extends string = string>({ items, value, defaultValue, onValueChange, onClose, className, classNames, styles, }: NEditorTabsProps<V>): React__default.JSX.Element;

declare function TooltipProvider({ delayDuration, ...props }: React$1.ComponentProps<typeof TooltipPrimitive.Provider>): React$1.JSX.Element;
declare function Tooltip({ ...props }: React$1.ComponentProps<typeof TooltipPrimitive.Root>): React$1.JSX.Element;
declare function TooltipTrigger({ ...props }: React$1.ComponentProps<typeof TooltipPrimitive.Trigger>): React$1.JSX.Element;
declare const tooltipContentVariants: (props?: {
    variant?: "filled" | "outlined";
} & class_variance_authority_types.ClassProp) => string;
type TooltipContentProps = React$1.ComponentProps<typeof TooltipPrimitive.Content> & VariantProps<typeof tooltipContentVariants>;
declare function TooltipContent({ className, sideOffset, variant, children, ...props }: TooltipContentProps): React$1.JSX.Element;

interface SimpleTooltipProps {
    content: React$1.ReactNode;
    children: React$1.ReactNode;
    side?: "top" | "right" | "bottom" | "left";
    align?: "start" | "center" | "end";
    delayDuration?: number;
    disabled?: boolean;
    variant?: "filled" | "outlined";
}
declare function SimpleTooltip({ content, children, side, align, delayDuration, disabled, variant, }: SimpleTooltipProps): React$1.JSX.Element;

type ProgressColor = "primary" | "secondary" | "accent" | "neutral" | "success" | "warning" | "error" | "info";
type ProgressSize = "xs" | "sm" | "md" | "lg" | "xl";
type ProgressLabelPosition = "inside" | "outside-top" | "outside-right";
interface ProgressProps extends Omit<React$1.ComponentProps<typeof ProgressPrimitive.Root>, "color"> {
    color?: ProgressColor;
    size?: ProgressSize;
    indeterminate?: boolean;
    label?: React$1.ReactNode;
    labelPosition?: ProgressLabelPosition;
}
declare function Progress({ className, value, color, size, indeterminate, label, labelPosition, ...props }: ProgressProps): React$1.JSX.Element;
declare const NProgress: typeof Progress;
type NProgressProps = ProgressProps;

declare function Separator({ className, orientation, decorative, ...props }: React$1.ComponentProps<typeof SeparatorPrimitive.Root>): React$1.JSX.Element;

interface ScrollAreaProps extends React$1.HTMLAttributes<HTMLDivElement> {
}
declare function ScrollArea({ className, children, ...props }: ScrollAreaProps): React$1.JSX.Element;

interface NajmScrollProps extends Omit<OverlayScrollbarsComponentProps, "options" | "ref" | "element"> {
    /** Host element tag. Defaults to "div". */
    element?: keyof React$1.JSX.IntrinsicElements;
    /** Which axes may scroll. Defaults to vertical only. */
    axis?: "both" | "x" | "y";
    /** Scrollbar auto-hide behaviour. Defaults to "never" (always visible while scrollable). */
    autoHide?: "never" | "scroll" | "leave" | "move";
    /** Receives the actual scroll viewport element (the node that scrolls), for measuring or scrollTo. */
    viewportRef?: React$1.Ref<HTMLElement>;
    options?: OverlayScrollbarsComponentProps["options"];
}
/**
 * Scroll container with a custom overlay scrollbar (OverlayScrollbars).
 *
 * The bar floats over the content and reserves **no layout space** in every
 * browser — unlike native scrollbars, which `overflow: auto` always reserves a
 * gutter for. Children are rendered inside the scroll viewport, so put layout
 * (grid/flex) classes on a child element, and sizing (`flex-1 min-h-0`,
 * `max-h-*`, etc.) on this component.
 */
declare function NajmScroll({ className, axis, autoHide, viewportRef, events, options, element, children, style, ...props }: NajmScrollProps): React$1.JSX.Element;

interface NImageProps extends Omit<ImgHTMLAttributes<HTMLImageElement>, "src"> {
    src: string;
    /** Swapped in when `src` fails to load. */
    fallback?: string;
}
/**
 * Display-only image with error recovery. Deliberately a plain `<img>`: the
 * caller's CSS box owns the size, so there is nothing for a framework image
 * component to reserve or downscale. For a Next-managed image with the same
 * fallback behavior, use `NNextImage` from `najm-kit/next`.
 *
 * `onError` is forwarded rather than swallowed, and the transition runs first:
 * a caller that logs a broken asset still sees the event, and the fallback
 * still appears.
 */
declare function NImage({ src, fallback, alt, onError, ...rest }: NImageProps): React$1.JSX.Element;

type AvatarSize = "xs" | "sm" | "md" | "lg" | "xl" | "2xl";
type AvatarShape$1 = "circle" | "rounded" | "square";
type AvatarStatusType = "online" | "offline" | "busy" | "away";
declare const avatarVariants: (props?: {
    size?: "sm" | "md" | "lg" | "xl" | "2xl" | "xs";
    shape?: "square" | "circle" | "rounded";
    ring?: boolean;
} & class_variance_authority_types.ClassProp) => string;
type AvatarRingColor = "background" | "primary" | "secondary" | "muted" | "destructive";
interface AvatarProps$1 extends Omit<React$1.ComponentProps<typeof AvatarPrimitive.Root>, "size">, VariantProps<typeof avatarVariants> {
    src?: string;
    alt?: string;
    fallback?: React$1.ReactNode;
    status?: AvatarStatusType;
    ringColor?: AvatarRingColor;
    imageClassName?: string;
    fallbackClassName?: string;
}
declare function Avatar({ className, size, shape, ring, ringColor, src, alt, fallback, status, imageClassName, fallbackClassName, children, ...props }: AvatarProps$1): React$1.JSX.Element;
declare function AvatarImage({ className, ...props }: React$1.ComponentProps<typeof AvatarPrimitive.Image>): React$1.JSX.Element;
declare function AvatarFallback({ className, ...props }: React$1.ComponentProps<typeof AvatarPrimitive.Fallback>): React$1.JSX.Element;
declare function AvatarStatus({ status, size, className, }: {
    status: AvatarStatusType;
    size?: AvatarSize;
    className?: string;
}): React$1.JSX.Element;
interface AvatarGroupProps extends React$1.HTMLAttributes<HTMLDivElement> {
    ring?: boolean;
}
declare function AvatarGroup({ ring, className, children, ...props }: AvatarGroupProps): React$1.JSX.Element;

type SwapEffect = "none" | "rotate" | "flip";
type SwapSize = "sm" | "md" | "lg" | "icon";
type SwapState = boolean | "indeterminate";
interface SwapProps extends Omit<React$1.ButtonHTMLAttributes<HTMLButtonElement>, "onChange"> {
    checked?: boolean;
    defaultChecked?: boolean;
    state?: SwapState;
    onCheckedChange?: (checked: boolean) => void;
    onStateChange?: (state: SwapState) => void;
    /** Full custom content for the on state — overrides onIcon/onText */
    on?: React$1.ReactNode;
    /** Full custom content for the off state — overrides offIcon/offText */
    off?: React$1.ReactNode;
    /** Full custom content for the indeterminate state */
    indeterminate?: React$1.ReactNode;
    /** Icon shown when state is on */
    onIcon?: NIconSource;
    /** Icon shown when state is off */
    offIcon?: NIconSource;
    /** Icon shown when state is indeterminate */
    indeterminateIcon?: NIconSource;
    /** Text shown when state is on */
    onText?: string;
    /** Text shown when state is off */
    offText?: string;
    /** Text shown when state is indeterminate */
    indeterminateText?: string;
    effect?: SwapEffect;
    size?: SwapSize;
    disabled?: boolean;
}
declare const swapVariants: (props?: {
    effect?: "none" | "flip" | "rotate";
    size?: "icon" | "sm" | "md" | "lg";
} & class_variance_authority_types.ClassProp) => string;
declare function Swap({ checked: controlledChecked, defaultChecked, state: controlledState, onCheckedChange, onStateChange, onClick, on, off, indeterminate: indeterminateContent, onIcon, offIcon, indeterminateIcon, onText, offText, indeterminateText, effect, size, disabled, className, ...props }: SwapProps): React$1.JSX.Element;

type NSwapProps = SwapProps;
declare function SwapOn({ children }: {
    children: React$1.ReactNode;
}): React$1.JSX.Element;
declare function SwapOff({ children }: {
    children: React$1.ReactNode;
}): React$1.JSX.Element;
declare function SwapIndeterminate({ children }: {
    children: React$1.ReactNode;
}): React$1.JSX.Element;

declare function Calendar(props: Record<string, any>): React$1.JSX.Element;

declare function Command({ className, ...props }: React$1.ComponentProps<typeof Command$1>): React$1.JSX.Element;
declare function CommandDialog({ children, ...props }: React$1.ComponentProps<typeof Dialog>): React$1.JSX.Element;
declare function CommandInput({ className, ...props }: React$1.ComponentProps<typeof Command$1.Input>): React$1.JSX.Element;
declare function CommandList({ className, children, ...props }: React$1.ComponentProps<typeof Command$1.List>): React$1.JSX.Element;
declare function CommandEmpty({ ...props }: React$1.ComponentProps<typeof Command$1.Empty>): React$1.JSX.Element;
declare function CommandGroup({ className, ...props }: React$1.ComponentProps<typeof Command$1.Group>): React$1.JSX.Element;
declare function CommandSeparator({ className, ...props }: React$1.ComponentProps<typeof Command$1.Separator>): React$1.JSX.Element;
declare function CommandItem({ className, ...props }: React$1.ComponentProps<typeof Command$1.Item>): React$1.JSX.Element;
declare function CommandShortcut({ className, ...props }: React$1.ComponentProps<"span">): React$1.JSX.Element;

declare function Collapsible({ ...props }: React$1.ComponentProps<typeof CollapsiblePrimitive.Root>): React$1.JSX.Element;
declare function CollapsibleTrigger({ className, ...props }: React$1.ComponentProps<typeof CollapsiblePrimitive.CollapsibleTrigger>): React$1.JSX.Element;
declare function CollapsibleContent({ ...props }: React$1.ComponentProps<typeof CollapsiblePrimitive.CollapsibleContent>): React$1.JSX.Element;

declare const toggleVariants: (props?: {
    variant?: "default" | "outline";
    size?: "default" | "sm" | "lg";
} & class_variance_authority_types.ClassProp) => string;
declare function Toggle({ className, variant, size, ...props }: React$1.ComponentProps<typeof TogglePrimitive.Root> & VariantProps<typeof toggleVariants>): React$1.JSX.Element;

type IconButtonVariant = "primary" | "secondary" | "ghost" | "destructive";
type IconButtonSize = "sm" | "md" | "lg";
interface IconButtonProps extends Omit<React$1.ButtonHTMLAttributes<HTMLButtonElement>, "aria-label"> {
    variant?: IconButtonVariant;
    size?: IconButtonSize;
    /** Required for accessibility — icon-only buttons must have a label. */
    "aria-label": string;
    active?: boolean;
}
declare const IconButton: React$1.ForwardRefExoticComponent<IconButtonProps & React$1.RefAttributes<HTMLButtonElement>>;

interface SegmentedControlOption<T extends string = string> {
    value: T;
    label?: React$1.ReactNode;
    icon?: React$1.ReactNode;
    ariaLabel?: string;
}
interface SegmentedControlProps<T extends string = string> {
    value: T;
    onChange: (value: T) => void;
    options: SegmentedControlOption<T>[];
    ariaLabel?: string;
    className?: string;
    size?: "sm" | "md";
    disabled?: boolean;
}
declare function SegmentedControl<T extends string = string>({ value, onChange, options, ariaLabel, className, size, disabled, }: SegmentedControlProps<T>): React$1.JSX.Element;

type StatusPillTone = "neutral" | "success" | "warning" | "danger" | "info" | "brand";
interface StatusPillProps extends React$1.HTMLAttributes<HTMLSpanElement> {
    tone?: StatusPillTone;
    pulse?: boolean;
    label: React$1.ReactNode;
}
declare const StatusPill: React$1.ForwardRefExoticComponent<StatusPillProps & React$1.RefAttributes<HTMLSpanElement>>;

declare function Toaster({ toastOptions, ...props }: ToasterProps): React$1.JSX.Element;

declare const Form: <TFieldValues extends FieldValues, TContext = any, TTransformedValues = TFieldValues>(props: react_hook_form.FormProviderProps<TFieldValues, TContext, TTransformedValues>) => React$1.JSX.Element;
declare const FormField: <TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ ...props }: ControllerProps<TFieldValues, TName>) => React$1.JSX.Element;
declare const useFormField: () => {
    invalid: boolean;
    isDirty: boolean;
    isTouched: boolean;
    isValidating: boolean;
    error?: react_hook_form.FieldError;
    id: string;
    name: string;
    formItemId: string;
    formDescriptionId: string;
    formMessageId: string;
};
declare function FormItem({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
declare function FormLabel({ className, ...props }: React$1.ComponentProps<typeof Label>): React$1.JSX.Element;
declare function FormControl({ ...props }: React$1.ComponentProps<typeof Slot>): React$1.JSX.Element;
declare function FormDescription({ className, ...props }: React$1.ComponentProps<"p">): React$1.JSX.Element;
declare function FormMessage({ className, children, ...props }: React$1.ComponentProps<"p">): React$1.JSX.Element;

declare function Table({ className, ...props }: React$1.ComponentProps<"table">): React$1.JSX.Element;
declare function TableHeader({ className, ...props }: React$1.ComponentProps<"thead">): React$1.JSX.Element;
declare function TableBody({ className, ...props }: React$1.ComponentProps<"tbody">): React$1.JSX.Element;
declare function TableFooter({ className, ...props }: React$1.ComponentProps<"tfoot">): React$1.JSX.Element;
declare function TableRow({ className, ...props }: React$1.ComponentProps<"tr">): React$1.JSX.Element;
declare function TableHead({ className, ...props }: React$1.ComponentProps<"th">): React$1.JSX.Element;
declare function TableCell({ className, ...props }: React$1.ComponentProps<"td">): React$1.JSX.Element;
declare function TableCaption({ className, ...props }: React$1.ComponentProps<"caption">): React$1.JSX.Element;

type SpinnerVariant = "default" | "circle" | "pinwheel" | "circle-filled" | "ellipsis" | "ring" | "bars" | "infinite";
interface NSpinnerProps extends LucideProps {
    variant?: SpinnerVariant;
    size?: number;
}
declare function NSpinner({ variant, size, className, ...props }: NSpinnerProps): React$1.JSX.Element;

interface ErrorBoundaryProps {
    children: React__default.ReactNode;
    fallbackTitle?: string;
}
interface ErrorBoundaryState {
    hasError: boolean;
    error: Error | null;
}
declare class NErrorBoundary extends React__default.Component<ErrorBoundaryProps, ErrorBoundaryState> {
    constructor(props: ErrorBoundaryProps);
    static getDerivedStateFromError(error: Error): ErrorBoundaryState;
    componentDidCatch(error: Error, errorInfo: React__default.ErrorInfo): void;
    handleReset: () => void;
    render(): string | number | bigint | boolean | Iterable<React__default.ReactNode> | Promise<string | number | bigint | boolean | React__default.ReactPortal | React__default.ReactElement<unknown, string | React__default.JSXElementConstructor<any>> | Iterable<React__default.ReactNode>> | React__default.JSX.Element;
}

interface SkeletonProps extends React__default.ComponentProps<"div"> {
}
declare function NSkeleton({ className, ...props }: SkeletonProps): React__default.JSX.Element;

declare function NStatCardSkeleton(): React__default.JSX.Element;
declare function NTableRowSkeleton({ columns }: {
    columns?: number;
}): React__default.JSX.Element;
declare function NTableSkeleton({ rows, columns }: {
    rows?: number;
    columns?: number;
}): React__default.JSX.Element;
declare function NSkeletonChart(): React__default.JSX.Element;
declare function NSkeletonDonut(): React__default.JSX.Element;
declare function NSkeletonCalendar(): React__default.JSX.Element;
declare function NSkeletonEventList({ count }: {
    count?: number;
}): React__default.JSX.Element;
declare function NSkeletonWidget(): React__default.JSX.Element;
declare function NSkeletonWidgets({ count }: {
    count?: number;
}): React__default.JSX.Element;

/**
 * Normalizes a consumer-supplied icon to a renderable element.
 *
 * `NEmptyState`, `NErrorState`, `NForbiddenState`, and `NNotFoundState` all
 * accept either a Lucide component or any React element. The Lucide path
 * needs sizing; the React-element path must keep whatever `className`,
 * `aria-label`, and handlers the consumer attached — so we never clone an
 * element we did not build.
 *
 * `size` is one of a small fixed set: dynamic Tailwind classes disappear in
 * consumer builds unless explicitly safelisted, so the helper does not
 * accept arbitrary sizes. Use the size that matches the surface: `sm` for
 * `inline`, `lg` for `panel`, `xl` for `page`.
 */
type NFeedbackIconSize = "sm" | "md" | "lg" | "xl";

type AvatarShape = "circle" | "rounded" | "square";
interface AvatarClassNames {
    root?: string;
    avatar?: string;
    image?: string;
    fallback?: string;
    title?: string;
    subtitle?: string;
    meta?: string;
}
/**
 * Native image attributes forwarded to the avatar's `<img>`.
 *
 * `src`, `alt`, and `className` are excluded because this component resolves
 * them: the source comes from the primary/fallback chain, the alt text from
 * `alt`/`title`, and the class from `classNames.image`.
 *
 * Typed off the native element rather than a framework image component on
 * purpose — see the note on `NAvatar` about why the avatar loads its image
 * directly through the browser.
 */
type NAvatarImageProps = Omit<React__default.ImgHTMLAttributes<HTMLImageElement>, "src" | "alt" | "className">;
interface AvatarProps {
    src?: string | null;
    title?: string;
    fallback?: string;
    fallbackSrc?: string;
    alt?: string;
    version?: string | number | null;
    srcVersion?: string | number | null;
    size?: "sm" | "md" | "lg" | "xl";
    shape?: AvatarShape;
    subtitle?: string;
    meta?: React__default.ReactNode;
    className?: string;
    classNames?: AvatarClassNames;
    /**
     * Escape hatch onto the underlying `<img>`: `loading`, `sizes`,
     * `crossOrigin`, `referrerPolicy`, `decoding`, and the load/error handlers.
     *
     * `onLoad` and `onError` are composed with this component's own state rather
     * than replacing it, so supplying them does not break the fallback chain.
     */
    imageProps?: NAvatarImageProps;
}
/**
 * Person or record avatar: an image with a fallback image behind it, initials
 * behind that, and an optional title/subtitle/meta column beside it.
 *
 * The image is a native `<img>`, not a framework image component and not
 * Radix's `AvatarImage`. Two reasons, both load-bearing:
 *
 * - Radix preloads through `new window.Image()` and mounts the element only
 *   once the bytes have arrived, which discards the element's own load and
 *   error events and makes `loading="lazy"` inert. This component has to expose
 *   both.
 * - Loading directly through the browser is what lets a same-origin protected
 *   route work at all: the request carries the session the page already has,
 *   and no optimizer sits between the two. The package therefore never needs to
 *   know which routes an application protects.
 */
declare function NAvatar({ src, title, fallback, fallbackSrc, alt, version, srcVersion, size, shape, subtitle, meta, className, classNames, imageProps, }: AvatarProps): React__default.JSX.Element;

type NAvatarProps = AvatarProps;
type NAvatarClassNames = AvatarClassNames;

declare function NCardAction({ children }: {
    children: React__default.ReactNode;
}): React__default.JSX.Element;
declare namespace NCardAction {
    var displayName: string;
}
declare function NCardFooter({ children }: {
    children: React__default.ReactNode;
    className?: string;
}): React__default.JSX.Element;
declare namespace NCardFooter {
    var displayName: string;
}
type NCardMediaVariant = "image" | "avatar" | "hero";
type NCardMediaPlacement = "auto" | "side" | "header" | "top";
type NCardMediaSize = "sm" | "md" | "lg" | "xl" | number;
type NCardMediaAspect = "square" | "4/3" | "3/2" | "16/9";
interface NCardMediaProps extends React__default.HTMLAttributes<HTMLDivElement> {
    variant?: NCardMediaVariant;
    /** `auto` uses side-to-top for images, side-to-header for avatars, and top for heroes. */
    placement?: NCardMediaPlacement;
    /** Side-media size. Presets are 72, 96, 112, and 128 pixels. */
    size?: NCardMediaSize;
    /** Hero aspect ratio. */
    aspect?: NCardMediaAspect;
}
declare function NCardMedia({ children }: NCardMediaProps): React__default.JSX.Element;
declare namespace NCardMedia {
    var displayName: string;
}
interface CardClassNames {
    root?: string;
    media?: string;
    header?: string;
    icon?: string;
    title?: string;
    description?: string;
    content?: string;
    footer?: string;
}
interface CardProps {
    children?: React__default.ReactNode;
    onClick?: () => void;
    title?: React__default.ReactNode;
    description?: React__default.ReactNode;
    icon?: NIconSource;
    iconColor?: string;
    loading?: boolean;
    error?: any;
    empty?: boolean;
    noData?: boolean;
    loadingText?: string;
    errorText?: string;
    emptyText?: string;
    noDataText?: string;
    skeleton?: React__default.ReactNode;
    onRetry?: () => void;
    noPadding?: boolean;
    separator?: boolean;
    bordered?: boolean;
    /** Remove the visual surface when NDataCardShell or another parent already owns it. */
    embedded?: boolean;
    className?: string;
    classNames?: CardClassNames;
}
declare function NCard({ children, title, description, icon, iconColor, loading, error, empty, noData, loadingText, errorText, emptyText, noDataText, skeleton, onRetry, noPadding, separator, bordered, embedded, className, classNames, onClick, }: CardProps): React__default.JSX.Element;

declare function truncateByCharacters(text: string, maxCharacters: number, suffix?: string): string;
type NCardDensity = "default" | "compact" | "responsive";
type NCardSectionSurface = "soft" | "plain" | "responsive";
interface NCardInfoProps extends Omit<React__default.HTMLAttributes<HTMLDivElement>, "children"> {
    icon?: LucideIcon;
    label?: React__default.ReactNode;
    value: React__default.ReactNode;
    density?: NCardDensity;
    maxChars?: number;
    iconClassName?: string;
    labelClassName?: string;
    valueClassName?: string;
}
declare function NCardInfo({ icon: Icon, label, value, density, maxChars, iconClassName, labelClassName, valueClassName, className, ...props }: NCardInfoProps): React__default.JSX.Element;
interface NCardSectionProps extends Omit<React__default.HTMLAttributes<HTMLDivElement>, "title"> {
    icon?: LucideIcon;
    title?: React__default.ReactNode;
    density?: NCardDensity;
    surface?: NCardSectionSurface;
    iconClassName?: string;
    titleClassName?: string;
}
declare function NCardSection({ icon: Icon, title, density, surface, iconClassName, titleClassName, children, className, ...props }: NCardSectionProps): React__default.JSX.Element;
interface NSectionInfoProps {
    icon?: LucideIcon;
    label: string;
    value: string | React__default.ReactNode;
    valueColor?: string;
    iconColor?: string;
    className?: string;
    maxChars?: number;
}
declare function NSectionInfo({ icon: Icon, label, value, valueColor, iconColor, className, maxChars, }: NSectionInfoProps): React__default.JSX.Element;
interface NSectionProps {
    icon: LucideIcon;
    title: string;
    children: React__default.ReactNode;
    className?: string;
    iconColor?: string;
    background?: string;
}
declare function NSection({ icon: Icon, title, children, className, iconColor, background, }: NSectionProps): React__default.JSX.Element;
interface NSectionWithInfoItem {
    icon?: LucideIcon;
    label: string;
    value: string | React__default.ReactNode;
    valueColor?: string;
    iconColor?: string;
}
interface NSectionWithInfoProps extends Omit<NSectionProps, "children"> {
    items: NSectionWithInfoItem[];
}
declare function NSectionWithInfo({ icon, title, items, className, iconColor, background, }: NSectionWithInfoProps): React__default.JSX.Element;
interface NSectionHeaderProps {
    children: React__default.ReactNode;
    image?: string;
    showImage?: boolean;
    imageSize?: "sm" | "md" | "lg" | "xl";
    icon?: LucideIcon;
    iconColor?: string;
    className?: string;
    background?: string;
    layout?: "horizontal" | "vertical";
}
interface NSectionHeaderTitleProps {
    children: React__default.ReactNode;
    className?: string;
}
interface NSectionHeaderSubtitleProps {
    children: React__default.ReactNode;
    className?: string;
}
interface NSectionHeaderContentProps {
    children: React__default.ReactNode;
    className?: string;
}
interface NSectionHeaderActionsProps {
    children: React__default.ReactNode;
    className?: string;
}
declare function NSectionHeaderRoot({ children, image, showImage, imageSize, icon: Icon, iconColor, className, background, layout, }: NSectionHeaderProps): React__default.JSX.Element;
declare function NSectionHeaderTitle({ children, className }: NSectionHeaderTitleProps): React__default.JSX.Element;
declare function NSectionHeaderSubtitle({ children, className }: NSectionHeaderSubtitleProps): React__default.JSX.Element;
declare function NSectionHeaderContent({ children, className }: NSectionHeaderContentProps): React__default.JSX.Element;
declare function NSectionHeaderActions({ children, className }: NSectionHeaderActionsProps): React__default.JSX.Element;
declare const NSectionHeader: typeof NSectionHeaderRoot & {
    Title: typeof NSectionHeaderTitle;
    Subtitle: typeof NSectionHeaderSubtitle;
    Content: typeof NSectionHeaderContent;
    Actions: typeof NSectionHeaderActions;
};

type NStatCardVariant = "default" | "usage" | "compact";
interface NStatCardClassNames {
    root?: string;
    icon?: string;
    label?: string;
    value?: string;
    description?: string;
}
interface BaseProps {
    icon: NIconSource;
    label?: string;
    onClick?: () => void;
    bordered?: boolean;
    className?: string;
    classNames?: NStatCardClassNames;
    loading?: boolean;
    loadingLabel?: string;
}
interface DefaultProps extends BaseProps {
    variant?: "default";
    value: string | number;
    subtext?: string;
    change?: {
        value: string;
        positive: boolean;
    };
    iconColor?: never;
    iconBgColor?: never;
    accentColor?: never;
    count?: never;
    countLabel?: never;
    used?: never;
    total?: never;
}
interface CompactProps extends BaseProps {
    variant: "compact";
    value: string | number;
    unit?: string;
    iconColor?: string;
    iconBgColor?: never;
    accentColor?: never;
    count?: never;
    countLabel?: never;
    used?: never;
    total?: never;
    subtext?: never;
    change?: never;
}
interface UsageProps extends BaseProps {
    variant: "usage";
    count: number;
    used: number;
    total: number;
    iconColor?: string;
    iconBgColor?: string;
    accentColor?: string;
    countLabel?: string;
    value?: never;
    subtext?: never;
    change?: never;
}
type NStatCardProps = DefaultProps | UsageProps | CompactProps;
declare function NStatCard(props: NStatCardProps): React__default.JSX.Element;

type NChartSize = "sm" | "md" | "lg" | number;
interface NChartSeries {
    id: string;
    label: React__default.ReactNode;
    color?: string;
}
interface NChartDatum {
    id: string;
    label: React__default.ReactNode;
    values: Readonly<Record<string, number>>;
}
interface NChartItem {
    id: string;
    label: React__default.ReactNode;
    value: number;
    color?: string;
    className?: string;
}
interface NChartCardProps {
    title: React__default.ReactNode;
    ariaLabel?: string;
    icon?: NIconSource;
    iconColor?: string;
    className?: string;
    emptyLabel?: React__default.ReactNode;
    loading?: boolean;
    loadingLabel?: string;
    valueFormatter?: (value: number) => React__default.ReactNode;
}
interface NCartesianChartProps extends NChartCardProps {
    data: readonly NChartDatum[];
    series: readonly NChartSeries[];
    height?: number;
    showLegend?: boolean;
}
type NBarChartProps = NCartesianChartProps;
type NLineChartProps = NCartesianChartProps;
interface NPieChartProps extends NChartCardProps {
    items: readonly NChartItem[];
    size?: NChartSize;
    showLegend?: boolean;
    percentageFormatter?: (ratio: number) => React__default.ReactNode;
}
interface NStatusBreakdownProps extends NChartCardProps {
    items: readonly NChartItem[];
    minimumVisiblePercent?: number;
}
type NChartSkeletonVariant = "bar" | "line" | "pie" | "status";
interface NChartSkeletonProps {
    variant?: NChartSkeletonVariant;
    points?: number;
    rows?: number;
    className?: string;
}

type NDonutCardVariant = "compact" | "default";
type NDonutCardLayout = "auto" | "vertical" | "horizontal";
type NDonutCardLegendMarker = "dot" | "icon" | "none";
type NDonutCardCenterOrientation = "column" | "row";
interface NDonutCardItem {
    id: string;
    label: React__default.ReactNode;
    value: number;
    color?: string;
    icon?: NIconSource;
}
interface NDonutCardClassNames {
    root?: string;
    content?: string;
    ring?: string;
    center?: string;
    legend?: string;
    legendItem?: string;
    legendMarker?: string;
    legendLabel?: string;
    legendValue?: string;
    empty?: string;
    footer?: string;
}
interface NDonutCardProps {
    title: React__default.ReactNode;
    ariaLabel?: string;
    icon?: NIconSource;
    iconColor?: string;
    items: readonly NDonutCardItem[];
    valueFormatter: (value: number) => React__default.ReactNode;
    centerValueFormatter?: (value: number) => React__default.ReactNode;
    centerUnit?: React__default.ReactNode;
    totalLabel?: React__default.ReactNode;
    centerIcon?: NIconSource;
    emptyLabel?: React__default.ReactNode;
    footer?: React__default.ReactNode;
    variant?: NDonutCardVariant;
    /** Ring diameter preset or an exact pixel diameter. Custom values are clamped to 64-480px. */
    size?: NChartSize;
    /** `"auto"` is horizontal on mobile and switches to vertical from the `md` breakpoint. */
    layout?: NDonutCardLayout;
    legendMarker?: NDonutCardLegendMarker;
    centerOrientation?: NDonutCardCenterOrientation;
    percentageFormatter?: (ratio: number) => React__default.ReactNode;
    className?: string;
    classNames?: NDonutCardClassNames;
    loading?: boolean;
    loadingLabel?: string;
}
declare function NDonutCard({ title, ariaLabel, icon, iconColor, items, valueFormatter, centerValueFormatter, centerUnit, totalLabel, centerIcon, emptyLabel, footer, variant, size, layout, legendMarker, centerOrientation, percentageFormatter, className, classNames, loading, loadingLabel, }: NDonutCardProps): React__default.JSX.Element;

declare function getNChartColor(index: number, override?: string): string;
declare function NChartSkeleton({ className, points, rows, variant, }: NChartSkeletonProps): React__default.JSX.Element;
declare function NBarChart({ ariaLabel, className, data, emptyLabel, height, icon, iconColor, loading, loadingLabel, series, showLegend, title, valueFormatter, }: NBarChartProps): React__default.JSX.Element;
declare function NLineChart(props: NLineChartProps): React__default.JSX.Element;
declare function NPieChart({ ariaLabel, className, emptyLabel, icon, iconColor, items, loading, loadingLabel, percentageFormatter, showLegend, size, title, valueFormatter, }: NPieChartProps): React__default.JSX.Element;
declare function NStatusBreakdown({ ariaLabel, className, emptyLabel, icon, iconColor, items, loading, loadingLabel, minimumVisiblePercent, title, valueFormatter, }: NStatusBreakdownProps): React__default.JSX.Element;

interface NDetailCardClassNames {
    root?: string;
    header?: string;
    title?: string;
    content?: string;
}
interface NDetailCardProps {
    title?: string;
    description?: string;
    icon?: NIconSource;
    action?: React__default.ReactNode;
    children: React__default.ReactNode;
    className?: string;
    classNames?: NDetailCardClassNames;
}
declare function NDetailCard({ title, description, icon, action, children, className, classNames, }: NDetailCardProps): React__default.JSX.Element;
interface NDetailItemProps {
    icon?: NIconSource;
    label: string;
    value: string | React__default.ReactNode;
    valueClassName?: string;
    iconClassName?: string;
    className?: string;
    maxChars?: number;
}
declare function NDetailItem({ icon, label, value, valueClassName, iconClassName, className, maxChars, }: NDetailItemProps): React__default.JSX.Element;
interface NDetailListItem {
    icon?: NIconSource;
    label: string;
    value: string | React__default.ReactNode;
    valueClassName?: string;
    iconClassName?: string;
}
interface NDetailListProps {
    items: NDetailListItem[];
    className?: string;
    itemClassName?: string;
}
declare function NDetailList({ items, className, itemClassName }: NDetailListProps): React__default.JSX.Element;

interface NViewToggleProps {
    mode: 'table' | 'json';
    onChange: (mode: 'table' | 'json') => void;
    className?: string;
}
declare function NViewToggle({ mode, onChange, className }: NViewToggleProps): React$1.JSX.Element;

interface NFilterBarProps {
    children: ReactNode;
    className?: string;
}
declare function NFilterBar({ children, className }: NFilterBarProps): React__default.JSX.Element;

interface NRowActionsProps {
    children: ReactNode;
}
declare function NRowActions({ children }: NRowActionsProps): React__default.JSX.Element;

interface NViewBodyProps {
    children: ReactNode;
    className?: string;
    variant?: 'table' | 'empty' | 'stack';
}
declare function NViewBody({ children, className, variant }: NViewBodyProps): React__default.JSX.Element;

interface NContextMenuItem {
    id: string;
    label: string;
    icon?: LucideIcon;
    danger?: boolean;
    disabled?: boolean;
    separatorBefore?: boolean;
    submenu?: NContextMenuItem[];
}
interface NContextMenuProps {
    x: number;
    y: number;
    items: NContextMenuItem[];
    onAction: (id: string) => void;
    onClose: () => void;
    className?: string;
}
/**
 * Right-click style context menu rendered at viewport coordinates `(x, y)`.
 * Closes on outside click, Escape, or after an action fires.
 * Supports a single level of submenus (hover the parent item).
 */
declare function NContextMenu({ x, y, items, onAction, onClose, className }: NContextMenuProps): React__default.JSX.Element;

/**
 * A single context menu entry. Each item carries its own `onSelect` callback,
 * so menus are co-located with their handlers — no central dispatcher needed.
 */
interface ContextMenuItem {
    label: string;
    icon?: LucideIcon;
    danger?: boolean;
    disabled?: boolean;
    separatorBefore?: boolean;
    /** Single level of submenu items. */
    submenu?: ContextMenuItem[];
    /** Called when the user clicks this item. Ignored when `submenu` is set. */
    onSelect?: () => void;
}
interface UseContextMenuResult {
    /**
     * Open the menu at the event's coordinates with the given items.
     * Pass the React/DOM event (or any `{ clientX, clientY }`); calling
     * `preventDefault` on it is optional but recommended for `onContextMenu`.
     */
    open: (e: {
        clientX: number;
        clientY: number;
        preventDefault?: () => void;
    }, items: ContextMenuItem[]) => void;
    close: () => void;
    /** Render this once at the root of your view. */
    menu: React__default.ReactNode;
    /** True while the menu is visible. */
    isOpen: boolean;
}
/**
 * Generic right-click context menu hook. View-agnostic: works for table rows,
 * cards, sidebar nodes, charts, whitespace, anywhere. Each item declares its
 * own `onSelect` so menus stay co-located with the data they act on.
 *
 * @example
 * const ctx = useContextMenu();
 *
 * <Card onContextMenu={(e) => ctx.open(e, [
 *   { label: 'Edit',    icon: Pencil, onSelect: () => editCard(card.id) },
 *   { label: 'Delete',  icon: Trash2, danger: true, onSelect: () => del(card.id) },
 * ])} />
 *
 * {ctx.menu}
 */
declare function useContextMenu(): UseContextMenuResult;

/** A single item the menu acts on (file, folder, group, lang, etc.). */
interface StorageTarget<T = unknown> {
    key: string;
    isFolder?: boolean;
    data?: T;
}
interface StorageSortOption {
    id: string;
    label: string;
    /** Optional direction suffix shown in the label, e.g. ' ↑'. */
    suffix?: string;
}
interface UseStorageContextMenuOptions<T = unknown> {
    canOpen?: boolean;
    canDownload?: boolean;
    canRename?: boolean;
    canCut?: boolean;
    canCopy?: boolean;
    canPaste?: boolean;
    canMove?: boolean;
    canShare?: boolean;
    canDelete?: boolean;
    canNewFolder?: boolean;
    canNewFile?: boolean;
    canSelectAll?: boolean;
    /** When provided, a "Reorganize" submenu is shown in the background menu. */
    sortOptions?: StorageSortOption[];
    /** Disables Paste when no clipboard contents are available. */
    hasClipboard?: boolean;
    onOpen?: (target: StorageTarget<T>) => void;
    onDownload?: (target: StorageTarget<T>) => void;
    onRename?: (target: StorageTarget<T>) => void;
    onCut?: (target: StorageTarget<T>) => void;
    onCopy?: (target: StorageTarget<T>) => void;
    onPaste?: () => void;
    onMove?: (target: StorageTarget<T>) => void;
    onShare?: (target: StorageTarget<T>) => void;
    onDelete?: (target: StorageTarget<T>) => void;
    onNewFolder?: () => void;
    onNewFile?: () => void;
    onSelectAll?: () => void;
    onSort?: (id: string) => void;
    itemExtras?: (target: StorageTarget<T>) => NContextMenuItem[];
    backgroundExtras?: () => NContextMenuItem[];
    /** Called for any item-context action id not matched by the standard handlers. */
    onItemExtraAction?: (action: string, target: StorageTarget<T>) => void;
    /** Called for any background-context action id not matched by the standard handlers. */
    onBackgroundExtraAction?: (action: string) => void;
    /** Override or extend the icon used per standard action id. */
    iconOverrides?: Partial<Record<StorageMenuAction, LucideIcon>>;
}
type StorageMenuAction = 'open' | 'download' | 'rename' | 'cut' | 'copy' | 'paste' | 'move' | 'share' | 'delete' | 'new-folder' | 'new-file' | 'select-all';
interface UseStorageContextMenuResult<T = unknown> {
    /** Attach to an item's `onContextMenu`. */
    openItem: (e: React__default.MouseEvent, target: StorageTarget<T>) => void;
    /** Attach to the empty area's `onContextMenu`. */
    openBackground: (e: {
        preventDefault: () => void;
        clientX: number;
        clientY: number;
    }) => void;
    close: () => void;
    /** Render this once at the root of your panel. */
    menu: React__default.ReactNode;
}
/**
 * Reusable right-click menu for storage-like views (files, folders, DB-backed
 * records). The hook owns the menu's open/close + position state and produces a
 * standard set of items based on capability flags. Domain-specific actions can
 * be appended via `itemExtras` / `backgroundExtras`.
 */
declare function useStorageContextMenu<T = unknown>(opts: UseStorageContextMenuOptions<T>): UseStorageContextMenuResult<T>;

interface NBulkActionButton {
    type?: 'button';
    id: string;
    label: string;
    icon?: LucideIcon;
    danger?: boolean;
    disabled?: boolean;
}
interface NBulkActionSelect {
    type: 'select';
    id: string;
    label: string;
    icon?: LucideIcon;
    placeholder?: string;
    options: Array<{
        value: string;
        label: string;
    }>;
    buttonLabel?: string;
    disabled?: boolean;
}
type NBulkAction = NBulkActionButton | NBulkActionSelect;
interface NBulkActionsBarProps {
    count: number;
    actions: NBulkAction[];
    /** Invoked for `button` actions, and for `select` actions with the chosen option value. */
    onAction: (actionId: string, value?: string) => Promise<void> | void;
    onClear: () => void;
    busy?: boolean;
    variant?: 'docked' | 'floating';
    className?: string;
}
/**
 * Sticky bottom toolbar that appears when ≥1 item is selected.
 * Renders a mix of plain button actions (Delete, Copy, Move, …) and
 * select-then-confirm actions (Move to lang, Move to folder, …).
 */
declare function NBulkActionsBar({ count, actions, onAction, onClear, busy, variant, className }: NBulkActionsBarProps): React__default.JSX.Element;

interface NCredentialField {
    label: string;
    value: string;
    icon?: NIconSource;
    mono?: boolean;
    breakAll?: boolean;
}
interface NCredentialsCardClassNames {
    root?: string;
    header?: string;
    list?: string;
    field?: string;
    actions?: string;
}
interface NCredentialsCardProps {
    fields: NCredentialField[];
    title?: string;
    description?: string;
    icon?: NIconSource;
    copyLabel?: string;
    copiedLabel?: string;
    copyErrorLabel?: string;
    copyText?: (fields: NCredentialField[]) => string;
    hideCopyAction?: boolean;
    onCopy?: () => void;
    onCopyError?: (error: unknown) => void;
    actions?: React$1.ReactNode;
    className?: string;
    classNames?: NCredentialsCardClassNames;
}
declare function NCredentialsCard({ fields, title, description, icon, copyLabel, copiedLabel, copyErrorLabel, copyText, hideCopyAction, onCopy, onCopyError, actions, className, classNames, }: NCredentialsCardProps): React$1.JSX.Element;
declare namespace NCredentialsCard {
    var displayName: string;
}

type IconSize = "sm" | "md" | "lg" | "xl";
interface NFileTypeIconProps {
    mimeType?: string;
    fileName?: string;
    url?: string;
    showThumbnail?: boolean;
    size?: IconSize;
    className?: string;
    imageClassName?: string;
}
declare function NFileTypeIcon({ mimeType, fileName, url, showThumbnail, size, className, imageClassName, }: NFileTypeIconProps): React__default.JSX.Element;
interface NFolderIconProps {
    size?: IconSize;
    className?: string;
}
declare function NFolderIcon({ size, className }: NFolderIconProps): React__default.JSX.Element;

interface BaseInputProps extends React__default.HTMLAttributes<HTMLDivElement> {
    children: React__default.ReactNode;
    variant?: "default" | "rounded" | "ghost";
    status?: "default" | "error";
    bordered?: boolean;
    borderColor?: TailwindColor;
    hasIcon?: boolean;
    disabled?: boolean;
    onHover?: () => void;
}
declare const BaseInput: React__default.ForwardRefExoticComponent<BaseInputProps & React__default.RefAttributes<HTMLDivElement>>;

declare const TextInput: React__default.ForwardRefExoticComponent<TextInputProps & React__default.RefAttributes<HTMLInputElement>>;

declare const NumberInput: React__default.ForwardRefExoticComponent<NumberInputProps & React__default.RefAttributes<HTMLInputElement>>;

declare const PasswordInput: React__default.ForwardRefExoticComponent<PasswordInputProps & React__default.RefAttributes<HTMLInputElement>>;

/** Accessible, controlled one-time-code input with keyboard and paste support. */
declare const OtpInput: React__default.ForwardRefExoticComponent<OtpInputProps & React__default.RefAttributes<HTMLInputElement>>;

declare const TextAreaInput: React__default.ForwardRefExoticComponent<TextAreaInputProps & React__default.RefAttributes<HTMLTextAreaElement>>;

declare const SelectInput: React__default.FC<SelectInputProps>;

declare const ComboboxInput: React__default.FC<ComboboxInputProps>;

declare const MultiSelectInput: React__default.FC<MultiSelectInputProps>;

declare const RadioGroupInput: React__default.FC<RadioGroupInputProps>;

declare const CheckboxInput: React__default.FC<CheckboxInputProps>;

declare function CheckboxGroupInput({ value, onChange, items, layout, className, variant, status, bordered, borderColor, disabled, }: CheckboxGroupInputProps & {
    disabled?: boolean;
}): React__default.JSX.Element;

declare const SwitchInput: React__default.FC<SwitchInputProps>;

declare const DateInput: React__default.FC<DateInputProps>;

declare const FileInput: React__default.FC<FileInputProps>;

type NUploaderItemStatus = "uploading" | "done" | "error";
interface NUploaderItem {
    id: string;
    name: string;
    size?: number;
    mimeType?: string;
    progress?: number;
    status?: NUploaderItemStatus;
    error?: string;
}
interface NUploaderProps {
    title?: string;
    subtitle?: string;
    accept?: string;
    multiple?: boolean;
    disabled?: boolean;
    items?: NUploaderItem[];
    emptyListLabel?: string;
    listTitle?: string;
    className?: string;
    dropzoneClassName?: string;
    onFilesSelected?: (files: File[]) => void;
    onCancel?: (id: string) => void;
    onRemove?: (id: string) => void;
}
declare function NUploader({ title, subtitle, accept, multiple, disabled, items, listTitle, className, dropzoneClassName, onFilesSelected, onCancel, onRemove, }: NUploaderProps): React__default.JSX.Element;

declare function ImageInput({ value, onChange, containerClassName, previewClassName, previewStyle, contentClassName, imageClassName, showPreview, previewPosition, allowClear, accept, defaultImage, fallbackImage, previewAlt, fallbackAlt, unavailableContent, onPreviewError, replaceAriaLabel, clearAriaLabel, imageSize, imageVersion, disabled, uploadIcon, title, subtitle, titleClassName, subtitleClassName, replaceTitle, replaceSubtitle, trigger, buttonLabel, }: ImageInputProps): React__default.JSX.Element;

/** A circular image picker preset for profile photos and user avatars. */
declare function AvatarInput({ imageSize, size, fill, radius, containerClassName, previewClassName, previewStyle, contentClassName, uploadIcon, title, subtitleClassName, trigger, ...props }: AvatarInputProps): React__default.JSX.Element;

declare const StarRatingInput: React__default.FC<StarRatingInputProps>;

declare const ColorArrayInput: React__default.FC<ColorArrayInputProps>;

declare function ColorPickerInput(props: ColorPickerInputProps): React__default.JSX.Element;

declare function EmojiInput({ value, onChange, options, className, variant, status, bordered, borderColor, disabled, }: EmojiInputProps & {
    disabled?: boolean;
}): React__default.JSX.Element;

declare function LangInput({ value, onChange, items, disabled, className, }: LangInputProps): React__default.JSX.Element;

declare function PhoneInput({ value, onChange, defaultCountry, placeholder, disabled, ariaLabel, className, variant, status, bordered, borderColor, }: PhoneInputProps & {
    variant?: "default" | "rounded" | "ghost";
    status?: "default" | "error";
    borderColor?: TailwindColor;
    bordered?: boolean;
}): React__default.JSX.Element;

declare const TimeInput: React__default.ForwardRefExoticComponent<TimeInputProps & React__default.RefAttributes<HTMLInputElement>>;

declare const TimeZoneInput: React__default.FC<TimeZoneInputProps>;

declare function getIconColorProps(iconColor?: string, baseClassName?: string): {
    className: string;
    style: {
        color?: undefined;
    };
} | {
    className: string;
    style: {
        color: string;
    };
};

interface SearchFieldProps {
    value: string;
    onChange: (value: string) => void;
    placeholder?: string;
    className?: string;
}
declare function SearchField({ value, onChange, placeholder, className }: SearchFieldProps): React__default.JSX.Element;

interface FileImportButtonProps {
    onFile?: (file: File) => void;
    onFiles?: (files: File[]) => void;
    accept?: string;
    multiple?: boolean;
    children?: React__default.ReactNode;
    loading?: boolean;
}
declare function FileImportButton({ onFile, onFiles, accept, multiple, children, loading, }: FileImportButtonProps): React__default.JSX.Element;

interface ComboboxOption {
    value: string;
    label: string;
}
interface ComboboxProps {
    options: ComboboxOption[];
    value: string;
    onChange: (value: string) => void;
    placeholder?: string;
    emptyText?: string;
    className?: string;
    allowFreeText?: boolean;
    disabled?: boolean;
}
declare function Combobox({ options, value, onChange, placeholder, emptyText, className, allowFreeText, disabled, }: ComboboxProps): React$1.JSX.Element;

declare const NForm: <T extends ZodTypeAny>(props: FormProps<T>) => React__default.ReactElement;

interface NFormSectionHeaderProps {
    icon?: LucideIcon | React__default.ComponentType<{
        className?: string;
    }>;
    title: string;
    className?: string;
    color?: string;
}
declare function NFormSectionHeader({ icon: Icon, title, className, color, }: NFormSectionHeaderProps): React__default.JSX.Element;

declare const FormInput: React__default.FC<FormInputProps>;

type AvatarFormInputProps = Omit<Extract<FormInputProps, {
    type: "avatar";
}>, "type">;
/** Form-bound avatar picker convenience wrapper. */
declare function AvatarFormInput(props: AvatarFormInputProps): React__default.JSX.Element;

interface DynamicArrayProps {
    name: string;
    children: React__default.ReactNode;
    title?: string | ((data: any, index: number) => string);
    onAdd?: (append: (value: any) => void, replace: (value: any[]) => void) => void;
    className?: string;
    collapsible?: boolean;
    defaultCollapsed?: boolean;
    addLabel?: string;
    emptyLabel?: string;
}
type RepeatingFieldsProps = DynamicArrayProps;
declare const DynamicArray: ({ name, children, title, onAdd, className, collapsible, defaultCollapsed, addLabel, emptyLabel }: DynamicArrayProps) => React__default.JSX.Element;
declare const RepeatingFields: ({ name, children, title, onAdd, className, collapsible, defaultCollapsed, addLabel, emptyLabel }: DynamicArrayProps) => React__default.JSX.Element;

declare const PrefixProvider: React__default.FC<{
    prefix?: string | number;
    children: React__default.ReactNode;
}>;
declare const usePrefix: () => string | number | undefined;

interface UseNFormOptions<T extends ZodTypeAny> extends Omit<UseFormProps<TypeOf<T>>, "resolver"> {
    schema?: T;
}
declare function useNForm<T extends ZodTypeAny>(options: UseNFormOptions<T>): UseFormReturn<TypeOf<T>>;

declare function FormDevToolsProvider({ children, value, }: {
    children: React__default.ReactNode;
    value?: boolean | FormDevToolsOptions;
}): React__default.JSX.Element;

interface StepConfig {
    id: string;
    title: string;
    description?: string;
    fields?: string[];
    schema?: any;
    render: (ctx: {
        form: UseFormReturn<any>;
        stepIndex: number;
    }) => ReactNode;
}
interface WizardClassNames {
    root?: string;
    header?: string;
    step?: string;
    footer?: string;
    indicator?: string;
    progressBar?: string;
}
type WizardFooterDivider = boolean | "none" | "solid" | "dashed" | "dotted";
interface WizardFormProps {
    steps: StepConfig[];
    schema: any;
    defaultValues?: Record<string, any>;
    onSubmit: (data: any) => void | Promise<void>;
    currentStep?: number;
    onCurrentStepChange?: (step: number) => void;
    onStepComplete?: (stepIndex: number, data: Record<string, any>) => void;
    showHeader?: boolean;
    showFooter?: boolean;
    nextLabel?: string;
    previousLabel?: string;
    submitLabel?: string;
    variant?: FormVariant;
    bordered?: boolean;
    className?: string;
    classNames?: WizardClassNames;
    footerSlot?: ReactNode;
    footerDivider?: WizardFooterDivider;
    footerDividerClassName?: string;
    devTools?: FormDevTools;
    children?: ReactNode;
}
interface StepMeta {
    id: string;
    number: number;
    title: string;
}

declare function WizardForm({ steps, schema, defaultValues, onSubmit, currentStep: controlledStep, onCurrentStepChange, onStepComplete, showHeader, showFooter, nextLabel, previousLabel, submitLabel, variant, bordered, className, classNames, footerSlot, footerDivider, footerDividerClassName, devTools, }: WizardFormProps): React__default.JSX.Element;

interface StepIndicatorProps {
    stepNumber: number;
    title: string;
    currentStep: number;
    completedSteps?: Set<number>;
    onClick?: (step: number) => void;
    className?: string;
}
declare function StepIndicator({ stepNumber, title, currentStep, completedSteps, onClick, className, }: StepIndicatorProps): React__default.JSX.Element;

interface StepsHeaderProps {
    steps: StepMeta[];
    currentStep: number;
    completedSteps?: Set<number>;
    onStepClick?: (step: number) => void;
    className?: string;
    classNames?: WizardClassNames;
}
declare function StepsHeader({ steps, currentStep, completedSteps, onStepClick, className, classNames, }: StepsHeaderProps): React__default.JSX.Element;

interface StepsProgressProps {
    steps: StepMeta[];
    currentStep: number;
    className?: string;
}
declare function StepsProgress({ steps, currentStep, className }: StepsProgressProps): React__default.JSX.Element;

interface UseStepNavigationOptions {
    steps: StepConfig[];
    currentStep?: number;
    onCurrentStepChange?: (step: number) => void;
}
interface StepNavState {
    currentStep: number;
    totalSteps: number;
    isFirstStep: boolean;
    isLastStep: boolean;
    currentStepConfig: StepConfig;
    steps: StepMeta[];
    completedSteps: Set<number>;
    handleNext: () => void;
    handlePrevious: () => void;
    goToStep: (step: number) => void;
    markStepCompleted: (stepIndex: number) => void;
    reset: () => void;
}
declare function useStepNavigation({ steps, currentStep: controlledStep, onCurrentStepChange, }: UseStepNavigationOptions): StepNavState;

interface UseFormSubmissionOptions {
    steps: StepConfig[];
    schema: any;
    defaultValues?: Record<string, any>;
    onSubmit: (data: any) => void | Promise<void>;
    currentStep: number;
    isLastStep: boolean;
    handleNext: () => void;
    markStepCompleted: (stepIndex: number) => void;
    reset: () => void;
}
interface FormSubmissionState {
    formDataRef: React.MutableRefObject<Record<string, any>>;
    handleStepSubmit: (stepData: any) => Promise<StepSubmitResult>;
    getStepDefaultValues: (stepId: string) => Record<string, any>;
}
type StepSubmitResult = {
    ok: true;
} | {
    ok: false;
    error: any;
    data: Record<string, any>;
};
declare function useFormSubmission({ steps, schema, defaultValues, onSubmit, currentStep, isLastStep, handleNext, markStepCompleted, reset, }: UseFormSubmissionOptions): FormSubmissionState;

interface NTableClassNames {
    root?: string;
    header?: string;
    tableHeader?: string;
    content?: string;
    pagination?: string;
    cards?: string;
    row?: string;
}
type ViewMode = "table" | "cards" | "json" | "files";
type CustomModeRenderers = Partial<Record<string, () => ReactNode>>;
interface TableState {
    table: any;
    data: any[];
    columns: any[];
    filters: any[];
    isLoading: boolean;
    error: any;
    viewMode: ViewMode;
    showSorting: boolean;
    showPagination: boolean;
    showColumnVisibility: boolean;
    showAddButton: boolean;
    showViewToggle: boolean;
    toolbarLabels: NTableToolbarLabels;
    showContent: boolean;
    isTableView: boolean;
    isCardView: boolean;
    isJsonView: boolean;
    isFilesView: boolean;
    isCustomMode: boolean;
    hasActions: boolean;
    hasData: boolean;
    hasControls: boolean;
    hasNoData: boolean;
    /** Loading while rows are already on screen: a refresh, not a first load. */
    isRefreshing: boolean;
    dynamicHeight: boolean;
    CardComponent: ComponentType<any> | null;
    /** Placeholder shaped like `CardComponent`; see `renderCardSkeleton`. */
    CardSkeletonComponent: ComponentType<any> | null;
    className: string;
    classNames: NTableClassNames;
    bordered?: boolean;
    headerClassName: string;
    headerColor: string | undefined;
    headerTextColor: string | undefined;
    borderColor: string | undefined;
    showCheckbox: boolean;
    selectedRowId: string | null;
    headerSlot: ReactNode | null;
    onAddClick: any;
    onView: any;
    onEdit: any;
    onDelete: any;
    onRowClick: any;
    onRowContextMenu: any;
    onBackgroundContextMenu: ((e: MouseEvent) => void) | null;
    openRowMenu: ((e: MouseEvent, row: any) => void) | null;
    getRowClassName: ((row: any) => string | undefined | null | false) | null;
    menuButton: boolean;
    onCellClick: any;
    onBulkDelete: any;
    onRetry: any;
    onCellEdit: any;
    onStateChange: ((state: any) => void) | null;
    getRowId: ((row: any) => string) | null;
    renderToolbar: ((state: any) => ReactNode) | null;
    noResultsText: string;
    filterPlaceholder: string;
    loadingText: string;
    noDataText: string;
    addButtonText: string;
    pageSizeOptions: number[];
    calculatedPageSize: number;
    /** Whole card rows that fit the measured body, multiplied by the column count. */
    calculatedCardPageSize: number;
    /** True once a real layout measurement has replaced the seeded defaults. */
    hasMeasuredLayout: boolean;
    skeletonRowCount: number;
    maxHeight: number | null;
    bodyWidth: number;
    bodyHeight: number;
    tableHeaderHeight: number;
    cardColumnCount: number;
    cardRowHeight: number;
    cardGap: number;
    syncWithProps: (updates: Partial<TableState>) => void;
    jsonValue: unknown;
    jsonColors: any;
    renderJson: (() => ReactNode) | null;
    renderCustomMode: CustomModeRenderers | null;
    isModeControlled: boolean;
    onModeChange: ((mode: ViewMode) => void) | null;
    availableModes: readonly ViewMode[];
    setViewMode: (mode: ViewMode) => void;
    hasSyncedFromProps: boolean;
    paginationVariant: NTablePaginationVariant;
    paginationLabels: NTablePaginationLabels;
    manualPagination: boolean;
    pageCount: number | undefined;
    rowCount: number | undefined;
    /** Another server page exists, for a result whose total is unknown. */
    hasNextPage: boolean | undefined;
    pagination: {
        pageIndex: number;
        pageSize: number;
    };
    isPaginationControlled: boolean;
    onPaginationChange: ((pagination: {
        pageIndex: number;
        pageSize: number;
    }) => void) | null;
    /** True after the reader explicitly chooses a Rows/page value. */
    isPageSizeUserSelected: boolean;
    setPagination: (pagination: {
        pageIndex: number;
        pageSize: number;
    }) => void;
    setPageSizeFromUser: (pageSize: number) => void;
    hasSyncedPaginationFromProps: boolean;
    rowSelection: Record<string, boolean>;
    isRowSelectionControlled: boolean;
    onRowSelectionChange: ((state: Record<string, boolean>) => void) | null;
    setRowSelection: (state: Record<string, boolean>) => void;
    hasSyncedRowSelectionFromProps: boolean;
    sorting: SortingState;
    isSortingControlled: boolean;
    onSortingChange: ((state: SortingState) => void) | null;
    setSorting: (state: SortingState) => void;
    hasSyncedSortingFromProps: boolean;
    responsiveCards: boolean;
    isMobile: boolean;
    effectiveViewMode: ViewMode;
    cardPagination: NTableCardPagination;
    isEmpty: boolean | undefined;
    isFilteredEmpty: boolean;
    renderFilteredEmpty: (() => React.ReactNode) | null;
    expanded: ExpandedState;
    isExpandedControlled: boolean;
    onExpandedChange: ((state: ExpandedState) => void) | null;
    getRowCanExpand: ((row: any) => boolean) | null;
    renderSubRow: ((row: any) => React.ReactNode) | null;
    setExpanded: (state: ExpandedState) => void;
    hasSyncedExpandedFromProps: boolean;
}
type TableStore = ReturnType<typeof createTableStore>;
/**
 * `seed` becomes part of the store's *initial* state rather than a `set()` call
 * made after creation. Zustand serves `getInitialState()` as the snapshot for
 * server rendering and for the hydration render, so anything applied after
 * creation is invisible on the first paint: `isLoading` would read false while
 * the caller passed true (rendering the empty state instead of the skeleton),
 * and `manualPagination` would read false long enough for layout effects to
 * push a default page size back to a consumer that owns pagination.
 */
declare const createTableStore: (seed?: Partial<TableState>) => {
    (): TableState;
    <U>(selector: (state: TableState) => U): U;
} & StoreApi<TableState> & {
    use: {
        table: () => any;
        data: () => any[];
        columns: () => any[];
        filters: () => any[];
        isLoading: () => boolean;
        error: () => any;
        viewMode: () => ViewMode;
        showSorting: () => boolean;
        showPagination: () => boolean;
        showColumnVisibility: () => boolean;
        showAddButton: () => boolean;
        showViewToggle: () => boolean;
        toolbarLabels: () => NTableToolbarLabels;
        showContent: () => boolean;
        isTableView: () => boolean;
        isCardView: () => boolean;
        isJsonView: () => boolean;
        isFilesView: () => boolean;
        isCustomMode: () => boolean;
        hasActions: () => boolean;
        hasData: () => boolean;
        hasControls: () => boolean;
        hasNoData: () => boolean;
        isRefreshing: () => boolean;
        dynamicHeight: () => boolean;
        CardComponent: () => ComponentType<any>;
        CardSkeletonComponent: () => ComponentType<any>;
        className: () => string;
        classNames: () => NTableClassNames;
        bordered?: () => boolean;
        headerClassName: () => string;
        headerColor: () => string;
        headerTextColor: () => string;
        borderColor: () => string;
        showCheckbox: () => boolean;
        selectedRowId: () => string;
        headerSlot: () => ReactNode;
        onAddClick: () => any;
        onView: () => any;
        onEdit: () => any;
        onDelete: () => any;
        onRowClick: () => any;
        onRowContextMenu: () => any;
        onBackgroundContextMenu: () => (e: MouseEvent) => void;
        openRowMenu: () => (e: MouseEvent, row: any) => void;
        getRowClassName: () => (row: any) => string | undefined | null | false;
        menuButton: () => boolean;
        onCellClick: () => any;
        onBulkDelete: () => any;
        onRetry: () => any;
        onCellEdit: () => any;
        onStateChange: () => (state: any) => void;
        getRowId: () => (row: any) => string;
        renderToolbar: () => (state: any) => ReactNode;
        noResultsText: () => string;
        filterPlaceholder: () => string;
        loadingText: () => string;
        noDataText: () => string;
        addButtonText: () => string;
        pageSizeOptions: () => number[];
        calculatedPageSize: () => number;
        calculatedCardPageSize: () => number;
        hasMeasuredLayout: () => boolean;
        skeletonRowCount: () => number;
        maxHeight: () => number;
        bodyWidth: () => number;
        bodyHeight: () => number;
        tableHeaderHeight: () => number;
        cardColumnCount: () => number;
        cardRowHeight: () => number;
        cardGap: () => number;
        syncWithProps: () => (updates: Partial<TableState>) => void;
        jsonValue: () => unknown;
        jsonColors: () => any;
        renderJson: () => () => ReactNode;
        renderCustomMode: () => Partial<Record<string, () => ReactNode>>;
        isModeControlled: () => boolean;
        onModeChange: () => (mode: ViewMode) => void;
        availableModes: () => readonly ViewMode[];
        setViewMode: () => (mode: ViewMode) => void;
        hasSyncedFromProps: () => boolean;
        paginationVariant: () => NTablePaginationVariant;
        paginationLabels: () => NTablePaginationLabels;
        manualPagination: () => boolean;
        pageCount: () => number;
        rowCount: () => number;
        hasNextPage: () => boolean;
        pagination: () => {
            pageIndex: number;
            pageSize: number;
        };
        isPaginationControlled: () => boolean;
        onPaginationChange: () => (pagination: {
            pageIndex: number;
            pageSize: number;
        }) => void;
        isPageSizeUserSelected: () => boolean;
        setPagination: () => (pagination: {
            pageIndex: number;
            pageSize: number;
        }) => void;
        setPageSizeFromUser: () => (pageSize: number) => void;
        hasSyncedPaginationFromProps: () => boolean;
        rowSelection: () => Record<string, boolean>;
        isRowSelectionControlled: () => boolean;
        onRowSelectionChange: () => (state: Record<string, boolean>) => void;
        setRowSelection: () => (state: Record<string, boolean>) => void;
        hasSyncedRowSelectionFromProps: () => boolean;
        sorting: () => SortingState;
        isSortingControlled: () => boolean;
        onSortingChange: () => (state: SortingState) => void;
        setSorting: () => (state: SortingState) => void;
        hasSyncedSortingFromProps: () => boolean;
        responsiveCards: () => boolean;
        isMobile: () => boolean;
        effectiveViewMode: () => ViewMode;
        cardPagination: () => NTableCardPagination;
        isEmpty: () => boolean;
        isFilteredEmpty: () => boolean;
        renderFilteredEmpty: () => () => React.ReactNode;
        expanded: () => ExpandedState;
        isExpandedControlled: () => boolean;
        onExpandedChange: () => (state: ExpandedState) => void;
        getRowCanExpand: () => (row: any) => boolean;
        renderSubRow: () => (row: any) => React.ReactNode;
        setExpanded: () => (state: ExpandedState) => void;
        hasSyncedExpandedFromProps: () => boolean;
    };
};

type NTableColumnBreakpoint = Exclude<NajmResponsiveBreakpoint, "base">;
type NTableEditorType = "text" | "number" | "select" | "checkbox" | "textarea";
interface NTableEditorOption<TValue = any> {
    value: TValue;
    label: string;
}
type NTableEditorResolver<TData, TValue> = TValue | ((row: TData) => TValue);
interface NTableColumnMeta<TData = any, TValue = any> {
    /**
     * Whether this column is eligible to exist in NTable.
     * Defaults to true. Set from the application's role/capability decision.
     */
    visible?: boolean;
    /**
     * Hide this table column below the selected Tailwind breakpoint.
     * The column remains visible at that breakpoint and above.
     * Applies to table view only.
     */
    hiddenBelow?: NTableColumnBreakpoint;
    /** Whether this cell can be edited. A function can decide per row. */
    editable?: boolean | ((row: TData) => boolean);
    /** Input presented while the cell is being edited. Defaults to `text`. */
    editor?: NTableEditorType;
    /** Choices for a select editor. A function can derive them from the row. */
    options?: NTableEditorResolver<TData, ReadonlyArray<NTableEditorOption<TValue>>>;
    /** Return an error message to keep the editor open and reject the value. */
    validate?: (value: TValue, row: TData) => string | null | undefined;
    /** Numeric editor minimum. A function can derive it from the row. */
    min?: NTableEditorResolver<TData, number | undefined>;
    /** Numeric editor maximum. A function can derive it from the row. */
    max?: NTableEditorResolver<TData, number | undefined>;
    /** Numeric editor step. Defaults to `any`. */
    step?: number | string;
}
/** TanStack `ColumnDef` plus Najm's responsive and inline-editing metadata. */
type NTableColumnDef<TData, TValue = any> = ColumnDef<TData, TValue> & {
    meta?: ColumnDef<TData, TValue>["meta"] & NTableColumnMeta<TData, TValue>;
};
declare function resolveHiddenBelowClass(hiddenBelow: NTableColumnBreakpoint | undefined): string | undefined;
declare const hiddenBelowClasses: Readonly<Record<NTableColumnBreakpoint, string>>;
/**
 * Returns the effective columns for TanStack + the loading skeleton + the
 * column visibility menu. Capability-gated columns (`meta.visible === false`)
 * are removed without mutating the input. Grouped columns are filtered
 * recursively; groups with no eligible children are removed.
 *
 * The helper is pure: it never mutates the caller's column definitions.
 */
declare function filterResponsiveColumns<TData, TValue>(columns: ReadonlyArray<ColumnDef<TData, TValue>>): ColumnDef<TData, TValue>[];

declare const TABLE_HEADER_COLOR_PRESETS: {
    readonly primary: "var(--primary)";
    readonly violet: "#7c3aed";
    readonly blue: "#2563eb";
    readonly emerald: "#059669";
    readonly amber: "#f59e0b";
    readonly rose: "#e11d48";
    readonly slate: "#475569";
};
type TableHeaderColor = keyof typeof TABLE_HEADER_COLOR_PRESETS;

interface NTableState {
    sorting: SortingState;
    columnFilters: ColumnFiltersState;
    columnVisibility: VisibilityState;
    rowSelection: RowSelectionState;
    globalFilter: string;
}
/**
 * Unified menu definition for NTable. The same items power the row right-click
 * menu AND the built-in ⋮ button; `background` powers right-click on whitespace.
 */
interface NTableMenu<T = any> {
    /** Items for right-clicking a row/card and for the built-in ⋮ button. */
    row?: (row: T) => ContextMenuItem[];
    /** Items for right-clicking empty space (whitespace / between cards). */
    background?: () => ContextMenuItem[];
}
/** Object form, or a bare function treated as `{ row }`. */
type NTableMenuProp<T = any> = NTableMenu<T> | ((row: T) => ContextMenuItem[]);
interface NTableProps<T = any, M extends ViewMode = ViewMode> {
    data: T[];
    columns: ReadonlyArray<NTableColumnDef<T, any>>;
    loading?: boolean;
    error?: any;
    getRowId?: (row: T) => string;
    onCreate?: () => void;
    onEdit?: (row: T) => void;
    onView?: (row: T) => void;
    onDelete?: (row: T) => void;
    renderCard?: ComponentType<{
        data: T;
        row: Row<T>;
        onClick?: () => void;
        onContextMenu?: (e: React__default.MouseEvent) => void;
        isExpanded?: boolean;
        onToggleExpanded?: () => void;
        canExpand?: boolean;
        renderSubRow?: (row: T) => React__default.ReactNode;
        'data-row'?: string;
        'data-row-id'?: string;
    }>;
    /**
     * A placeholder shaped like `renderCard`.
     *
     * The card page size is measured from whatever is on screen, and during a
     * first load that is the skeleton. The built-in placeholder is an avatar row,
     * so a consumer whose cards are a different height — a media card, say — gets
     * a page size measured against a card it does not use, and the grid re-lays
     * out once real cards arrive. Supplying a placeholder with the real card's
     * geometry makes the first measurement the correct one.
     */
    renderCardSkeleton?: ComponentType<Record<string, never>>;
    /**
     * Emit both skeleton shapes and let a media query choose between them.
     *
     * A view mode derived from the viewport is unknowable on the server, so the
     * server renders the card shape and the client corrects it after hydration —
     * on a desktop table page that is a visible card skeleton followed by a table
     * skeleton. No client-side detection can fix it, because the first paint is
     * whatever the server sent. Rendering both and hiding one in CSS puts the
     * right shape in that first paint. The skeleton is `aria-hidden` decoration,
     * so the duplicate costs nothing to assistive technology.
     *
     * The breakpoint is `lg` (1024px), matching the point at which a table
     * becomes usable.
     */
    responsiveSkeleton?: boolean;
    renderToolbar?: (state: NTableState) => React__default.ReactNode;
    renderEmpty?: () => React__default.ReactNode;
    renderError?: (error: any) => React__default.ReactNode;
    renderLoading?: () => React__default.ReactNode;
    className?: string;
    classNames?: NTableClassNames;
    /** Use a border instead of a shadow for the table container and cards. */
    bordered?: boolean;
    density?: "compact" | "comfortable" | "spacious";
    availableModes?: readonly M[];
    mode?: M;
    defaultMode?: M;
    onModeChange?: (mode: M) => void;
    jsonValue?: unknown;
    jsonColors?: any;
    renderJson?: () => React__default.ReactNode;
    renderCustomMode?: CustomModeRenderers;
    manualPagination?: boolean;
    pageCount?: number;
    rowCount?: number;
    /**
     * Whether another server page exists, for a list whose endpoint reports no
     * result total. Supply it *instead of* `pageCount`, never a `pageCount`
     * synthesized from it: the numbered bar then covers the pages known to exist
     * and carries a trailing `…` for the rest, and the last-page jump is dropped
     * because there is no known last page. Ignored when `pageCount` is given —
     * a real total already says everything this does.
     */
    hasNextPage?: boolean;
    pagination?: {
        pageIndex: number;
        pageSize: number;
    };
    defaultPagination?: {
        pageIndex: number;
        pageSize: number;
    };
    onPaginationChange?: (pagination: {
        pageIndex: number;
        pageSize: number;
    }) => void;
    /** Pagination presentation used whenever NTable is actually rendering cards. */
    cardPagination?: NTableCardPagination;
    /**
     * How the page controls present position. Defaults to `"numbered"`, which
     * falls back to `"compact"` on its own when the page count is not
     * trustworthy. Pass `"compact"` for the `Page X of Y` text everywhere.
     */
    paginationVariant?: NTablePaginationVariant;
    /** Accessible names and visible copy for the page controls. */
    paginationLabels?: NTablePaginationLabels;
    rowSelection?: RowSelectionState;
    defaultRowSelection?: RowSelectionState;
    onRowSelectionChange?: (state: RowSelectionState) => void;
    sorting?: SortingState;
    defaultSorting?: SortingState;
    onSortingChange?: (state: SortingState) => void;
    responsiveCards?: boolean;
    isEmpty?: boolean;
    isFilteredEmpty?: boolean;
    renderFilteredEmpty?: () => React__default.ReactNode;
    expanded?: ExpandedState;
    defaultExpanded?: ExpandedState;
    onExpandedChange?: (state: ExpandedState) => void;
    getRowCanExpand?: (row: T) => boolean;
    renderSubRow?: (row: T) => React__default.ReactNode;
    filters?: any[];
    showPagination?: boolean;
    showSorting?: boolean;
    showColumnVisibility?: boolean;
    showAddButton?: boolean;
    showViewToggle?: boolean;
    /** Accessible names and visible copy for the toolbar and settings menu. */
    toolbarLabels?: NTableToolbarLabels;
    dynamicHeight?: boolean;
    headerClassName?: string;
    /** CSS color or Najm token name for the table header background. Defaults to primary. */
    headerColor?: string;
    /** CSS color or Najm token name for table header text. Defaults to primary foreground. */
    headerTextColor?: string;
    /** CSS color or Najm token name for table borders. Defaults to border. */
    borderColor?: string;
    showCheckbox?: boolean;
    onRowClick?: (row: T) => void;
    /**
     * Called when a data cell is clicked in table view. Cell clicks do not
     * propagate to `onRowClick`.
     */
    onCellClick?: (row: T, columnId: string, event: React__default.MouseEvent<HTMLTableCellElement>) => void;
    onRowContextMenu?: (e: React__default.MouseEvent, row: T) => void;
    getRowClassName?: (row: T) => string | undefined | null | false;
    menu?: NTableMenuProp<T>;
    menuButton?: boolean;
    onCellEdit?: (row: T, columnId: string, value: any) => Promise<any> | any;
    onBulkDelete?: (ids: string[]) => void;
    pageSizeOptions?: number[];
    noResultsText?: string;
    noDataText?: string;
    loadingText?: string;
    addButtonText?: string;
    headerSlot?: React__default.ReactNode;
    selectedRowId?: string | null;
    onStateChange?: (state: NTableState) => void;
}
type NTableColumnDefCompatibilityProps<T, M extends ViewMode> = Omit<NTableProps<NoInfer<T>, M>, "data" | "columns"> & {
    data: T[];
    columns: ReadonlyArray<ColumnDef<T, any>>;
};
/**
 * Backward-compatible overload for callers whose reusable column arrays are
 * declared with TanStack's plain `ColumnDef<T>[]`.
 */
declare function NTable<T = any, M extends ViewMode = ViewMode>(props: NTableColumnDefCompatibilityProps<T, M>): React__default.ReactElement;
/**
 * Najm-specific overload providing typed `meta.visible` and
 * `meta.hiddenBelow` metadata.
 */
declare function NTable<T = any, M extends ViewMode = ViewMode>(props: NTableProps<T, M>): React__default.ReactElement;

/** A rendered slot in the numbered page list. */
type NTablePageItem = {
    type: "page";
    pageIndex: number;
} | {
    type: "gap";
    key: "start" | "end";
};
/**
 * The page numbers to render for a given position in the result.
 *
 * Always yields the first and last page, the current page, and `siblingCount`
 * pages either side of it, collapsing the rest into at most two gaps. Near
 * either end, where one gap is not needed, the freed slots extend the run of
 * pages instead of being dropped — so the slot count stays constant at
 * `2 * siblingCount + 5` for any result longer than that. A bar that changes
 * width on every click is worse than the text it replaced.
 *
 * `unbounded` says the result continues past `pageCount`, which is then every
 * page *known* to exist rather than the whole result — all an endpoint that
 * reports no total can prove. The window is built over the known pages and a
 * trailing gap is appended, so the bar reads "and more after this" from the
 * first page rather than silently growing a number each time one is
 * discovered. It goes back to false at the end of the result, where the pages
 * read are the result and the count is exact.
 */
declare function buildPageItems(pageIndex: number, pageCount: number, siblingCount?: number, unbounded?: boolean): NTablePageItem[];

declare function NTableContent({ effectiveMode }: {
    effectiveMode?: string;
}): React__default.JSX.Element;

declare function NTableCards({ effectiveMode }: {
    effectiveMode?: string;
}): React__default.JSX.Element;

declare function NTablePagination(): React__default.JSX.Element;

declare function NTableHeader(): React__default.JSX.Element;

declare function NTableLoadingSkeleton({ rows }: {
    rows?: number;
}): React__default.JSX.Element;

interface NDataCardShellActions {
    onView?: (row: unknown) => void;
    onEdit?: (row: unknown) => void;
    onDelete?: (row: unknown) => void;
}
interface NDataCardShellProps {
    row: Row<unknown>;
    onClick?: () => void;
    onContextMenu?: (e: React__default.MouseEvent) => void;
    actions?: NDataCardShellActions;
    children?: React__default.ReactNode;
    className?: string;
    showCheckbox?: boolean;
    selectedRowId?: string | null;
    openRowMenu?: ((e: React__default.MouseEvent, row: any) => void) | null;
    menuButton?: boolean;
    bordered?: boolean;
    borderColor?: string;
}
declare function NDataCardShell({ row, onClick, onContextMenu, actions, children, className, showCheckbox, selectedRowId, openRowMenu, menuButton, bordered, borderColor }: NDataCardShellProps): React__default.JSX.Element;

interface NTableCardRootProps extends Omit<React__default.HTMLAttributes<HTMLDivElement>, "onClick" | "onContextMenu"> {
    card: {
        onClick?: () => void;
        onContextMenu?: (e: React__default.MouseEvent) => void;
    };
    children: React__default.ReactNode;
    className?: string;
}
declare function NTableCardRoot({ card, children, className, ...rest }: NTableCardRootProps): React__default.JSX.Element;

interface FileNode {
    key: string;
    name: string;
    isFolder: boolean;
    mimeType?: string;
    size?: number;
    updatedAt?: string;
    meta?: Record<string, unknown>;
}
type FileBrowserMode = "table" | "cards";
interface NFileBrowserRenderThumbProps {
    node: FileNode;
    size: "sm" | "xl";
}
interface NFileBrowserCardProps {
    data: FileNode;
    row: Row<FileNode>;
    onClick?: () => void;
    onContextMenu?: (e: React__default.MouseEvent) => void;
}
interface NFileBrowserProps {
    nodes: FileNode[];
    mode?: FileBrowserMode;
    defaultMode?: FileBrowserMode;
    onModeChange?: (mode: FileBrowserMode) => void;
    availableModes?: readonly FileBrowserMode[];
    onOpen?: (node: FileNode) => void;
    onContextMenu?: (e: React__default.MouseEvent, node: FileNode) => void;
    onBackgroundContextMenu?: (e: React__default.MouseEvent) => void;
    selected?: Set<string> | string[];
    onSelectionChange?: (keys: string[]) => void;
    renderThumb?: (props: NFileBrowserRenderThumbProps) => React__default.ReactNode;
    renderCard?: (props: NFileBrowserCardProps) => React__default.ReactNode;
    columns?: ColumnDef<FileNode>[];
    extraColumns?: ColumnDef<FileNode>[];
    showSize?: boolean;
    showType?: boolean;
    showModified?: boolean;
    loading?: boolean;
    sorting?: SortingState;
    onSortingChange?: (state: SortingState) => void;
    showCheckbox?: boolean;
    showPagination?: boolean;
    showViewToggle?: boolean;
    responsiveCards?: boolean;
    noDataText?: string;
    loadingText?: string;
    renderEmpty?: () => React__default.ReactNode;
    renderToolbar?: () => React__default.ReactNode;
    className?: string;
}
declare function formatFileBytes(bytes: number): string;
declare function formatFileRelative(iso: string): string;
interface BuildDefaultFileColumnsOptions {
    renderThumb?: (props: NFileBrowserRenderThumbProps) => React__default.ReactNode;
    showType?: boolean;
    showSize?: boolean;
    showModified?: boolean;
}
declare function buildDefaultFileColumns(options?: BuildDefaultFileColumnsOptions): ColumnDef<FileNode>[];
declare function NFileBrowser({ nodes, mode, defaultMode, onModeChange, availableModes, onOpen, onContextMenu, onBackgroundContextMenu, selected, onSelectionChange, renderThumb, renderCard, columns, extraColumns, showSize, showType, showModified, loading, sorting, onSortingChange, showCheckbox, showPagination, showViewToggle, responsiveCards, noDataText, loadingText, renderEmpty, renderToolbar, className, }: NFileBrowserProps): React__default.JSX.Element;

declare const TableStoreContext: React$1.Context<{
    (): TableState;
    <U>(selector: (state: TableState) => U): U;
} & zustand.StoreApi<TableState> & {
    use: {
        table: () => any;
        data: () => any[];
        columns: () => any[];
        filters: () => any[];
        isLoading: () => boolean;
        error: () => any;
        viewMode: () => ViewMode;
        showSorting: () => boolean;
        showPagination: () => boolean;
        showColumnVisibility: () => boolean;
        showAddButton: () => boolean;
        showViewToggle: () => boolean;
        toolbarLabels: () => NTableToolbarLabels;
        showContent: () => boolean;
        isTableView: () => boolean;
        isCardView: () => boolean;
        isJsonView: () => boolean;
        isFilesView: () => boolean;
        isCustomMode: () => boolean;
        hasActions: () => boolean;
        hasData: () => boolean;
        hasControls: () => boolean;
        hasNoData: () => boolean;
        isRefreshing: () => boolean;
        dynamicHeight: () => boolean;
        CardComponent: () => React$1.ComponentType<any>;
        CardSkeletonComponent: () => React$1.ComponentType<any>;
        className: () => string;
        classNames: () => NTableClassNames;
        bordered?: () => boolean;
        headerClassName: () => string;
        headerColor: () => string;
        headerTextColor: () => string;
        borderColor: () => string;
        showCheckbox: () => boolean;
        selectedRowId: () => string;
        headerSlot: () => React$1.ReactNode;
        onAddClick: () => any;
        onView: () => any;
        onEdit: () => any;
        onDelete: () => any;
        onRowClick: () => any;
        onRowContextMenu: () => any;
        onBackgroundContextMenu: () => (e: React$1.MouseEvent) => void;
        openRowMenu: () => (e: React$1.MouseEvent, row: any) => void;
        getRowClassName: () => (row: any) => string | undefined | null | false;
        menuButton: () => boolean;
        onCellClick: () => any;
        onBulkDelete: () => any;
        onRetry: () => any;
        onCellEdit: () => any;
        onStateChange: () => (state: any) => void;
        getRowId: () => (row: any) => string;
        renderToolbar: () => (state: any) => React$1.ReactNode;
        noResultsText: () => string;
        filterPlaceholder: () => string;
        loadingText: () => string;
        noDataText: () => string;
        addButtonText: () => string;
        pageSizeOptions: () => number[];
        calculatedPageSize: () => number;
        calculatedCardPageSize: () => number;
        hasMeasuredLayout: () => boolean;
        skeletonRowCount: () => number;
        maxHeight: () => number;
        bodyWidth: () => number;
        bodyHeight: () => number;
        tableHeaderHeight: () => number;
        cardColumnCount: () => number;
        cardRowHeight: () => number;
        cardGap: () => number;
        syncWithProps: () => (updates: Partial<TableState>) => void;
        jsonValue: () => unknown;
        jsonColors: () => any;
        renderJson: () => () => React$1.ReactNode;
        renderCustomMode: () => Partial<Record<string, () => React$1.ReactNode>>;
        isModeControlled: () => boolean;
        onModeChange: () => (mode: ViewMode) => void;
        availableModes: () => readonly ViewMode[];
        setViewMode: () => (mode: ViewMode) => void;
        hasSyncedFromProps: () => boolean;
        paginationVariant: () => NTablePaginationVariant;
        paginationLabels: () => NTablePaginationLabels;
        manualPagination: () => boolean;
        pageCount: () => number;
        rowCount: () => number;
        hasNextPage: () => boolean;
        pagination: () => {
            pageIndex: number;
            pageSize: number;
        };
        isPaginationControlled: () => boolean;
        onPaginationChange: () => (pagination: {
            pageIndex: number;
            pageSize: number;
        }) => void;
        isPageSizeUserSelected: () => boolean;
        setPagination: () => (pagination: {
            pageIndex: number;
            pageSize: number;
        }) => void;
        setPageSizeFromUser: () => (pageSize: number) => void;
        hasSyncedPaginationFromProps: () => boolean;
        rowSelection: () => Record<string, boolean>;
        isRowSelectionControlled: () => boolean;
        onRowSelectionChange: () => (state: Record<string, boolean>) => void;
        setRowSelection: () => (state: Record<string, boolean>) => void;
        hasSyncedRowSelectionFromProps: () => boolean;
        sorting: () => _tanstack_table_core.SortingState;
        isSortingControlled: () => boolean;
        onSortingChange: () => (state: _tanstack_table_core.SortingState) => void;
        setSorting: () => (state: _tanstack_table_core.SortingState) => void;
        hasSyncedSortingFromProps: () => boolean;
        responsiveCards: () => boolean;
        isMobile: () => boolean;
        effectiveViewMode: () => ViewMode;
        cardPagination: () => NTableCardPagination;
        isEmpty: () => boolean;
        isFilteredEmpty: () => boolean;
        renderFilteredEmpty: () => () => React.ReactNode;
        expanded: () => _tanstack_table_core.ExpandedState;
        isExpandedControlled: () => boolean;
        onExpandedChange: () => (state: _tanstack_table_core.ExpandedState) => void;
        getRowCanExpand: () => (row: any) => boolean;
        renderSubRow: () => (row: any) => React.ReactNode;
        setExpanded: () => (state: _tanstack_table_core.ExpandedState) => void;
        hasSyncedExpandedFromProps: () => boolean;
    };
}>;
declare const useTableStore: {
    use: any;
};

declare function useStoreSync(props: any): {
    (): TableState;
    <U>(selector: (state: TableState) => U): U;
} & zustand.StoreApi<TableState> & {
    use: {
        table: () => any;
        data: () => any[];
        columns: () => any[];
        filters: () => any[];
        isLoading: () => boolean;
        error: () => any;
        viewMode: () => ViewMode;
        showSorting: () => boolean;
        showPagination: () => boolean;
        showColumnVisibility: () => boolean;
        showAddButton: () => boolean;
        showViewToggle: () => boolean;
        toolbarLabels: () => NTableToolbarLabels;
        showContent: () => boolean;
        isTableView: () => boolean;
        isCardView: () => boolean;
        isJsonView: () => boolean;
        isFilesView: () => boolean;
        isCustomMode: () => boolean;
        hasActions: () => boolean;
        hasData: () => boolean;
        hasControls: () => boolean;
        hasNoData: () => boolean;
        isRefreshing: () => boolean;
        dynamicHeight: () => boolean;
        CardComponent: () => React__default.ComponentType<any>;
        CardSkeletonComponent: () => React__default.ComponentType<any>;
        className: () => string;
        classNames: () => NTableClassNames;
        bordered?: () => boolean;
        headerClassName: () => string;
        headerColor: () => string;
        headerTextColor: () => string;
        borderColor: () => string;
        showCheckbox: () => boolean;
        selectedRowId: () => string;
        headerSlot: () => React__default.ReactNode;
        onAddClick: () => any;
        onView: () => any;
        onEdit: () => any;
        onDelete: () => any;
        onRowClick: () => any;
        onRowContextMenu: () => any;
        onBackgroundContextMenu: () => (e: React__default.MouseEvent) => void;
        openRowMenu: () => (e: React__default.MouseEvent, row: any) => void;
        getRowClassName: () => (row: any) => string | undefined | null | false;
        menuButton: () => boolean;
        onCellClick: () => any;
        onBulkDelete: () => any;
        onRetry: () => any;
        onCellEdit: () => any;
        onStateChange: () => (state: any) => void;
        getRowId: () => (row: any) => string;
        renderToolbar: () => (state: any) => React__default.ReactNode;
        noResultsText: () => string;
        filterPlaceholder: () => string;
        loadingText: () => string;
        noDataText: () => string;
        addButtonText: () => string;
        pageSizeOptions: () => number[];
        calculatedPageSize: () => number;
        calculatedCardPageSize: () => number;
        hasMeasuredLayout: () => boolean;
        skeletonRowCount: () => number;
        maxHeight: () => number;
        bodyWidth: () => number;
        bodyHeight: () => number;
        tableHeaderHeight: () => number;
        cardColumnCount: () => number;
        cardRowHeight: () => number;
        cardGap: () => number;
        syncWithProps: () => (updates: Partial<TableState>) => void;
        jsonValue: () => unknown;
        jsonColors: () => any;
        renderJson: () => () => React__default.ReactNode;
        renderCustomMode: () => Partial<Record<string, () => React__default.ReactNode>>;
        isModeControlled: () => boolean;
        onModeChange: () => (mode: ViewMode) => void;
        availableModes: () => readonly ViewMode[];
        setViewMode: () => (mode: ViewMode) => void;
        hasSyncedFromProps: () => boolean;
        paginationVariant: () => NTablePaginationVariant;
        paginationLabels: () => NTablePaginationLabels;
        manualPagination: () => boolean;
        pageCount: () => number;
        rowCount: () => number;
        hasNextPage: () => boolean;
        pagination: () => {
            pageIndex: number;
            pageSize: number;
        };
        isPaginationControlled: () => boolean;
        onPaginationChange: () => (pagination: {
            pageIndex: number;
            pageSize: number;
        }) => void;
        isPageSizeUserSelected: () => boolean;
        setPagination: () => (pagination: {
            pageIndex: number;
            pageSize: number;
        }) => void;
        setPageSizeFromUser: () => (pageSize: number) => void;
        hasSyncedPaginationFromProps: () => boolean;
        rowSelection: () => Record<string, boolean>;
        isRowSelectionControlled: () => boolean;
        onRowSelectionChange: () => (state: Record<string, boolean>) => void;
        setRowSelection: () => (state: Record<string, boolean>) => void;
        hasSyncedRowSelectionFromProps: () => boolean;
        sorting: () => SortingState;
        isSortingControlled: () => boolean;
        onSortingChange: () => (state: SortingState) => void;
        setSorting: () => (state: SortingState) => void;
        hasSyncedSortingFromProps: () => boolean;
        responsiveCards: () => boolean;
        isMobile: () => boolean;
        effectiveViewMode: () => ViewMode;
        cardPagination: () => NTableCardPagination;
        isEmpty: () => boolean;
        isFilteredEmpty: () => boolean;
        renderFilteredEmpty: () => () => React__default.ReactNode;
        expanded: () => ExpandedState;
        isExpandedControlled: () => boolean;
        onExpandedChange: () => (state: ExpandedState) => void;
        getRowCanExpand: () => (row: any) => boolean;
        renderSubRow: () => (row: any) => React__default.ReactNode;
        setExpanded: () => (state: ExpandedState) => void;
        hasSyncedExpandedFromProps: () => boolean;
    };
};
declare function useDynamicPageSize(containerRef: React__default.RefObject<HTMLDivElement | null>, effectiveViewMode?: TableState["viewMode"]): void;
declare function useTable(effectiveViewModeOverride?: TableState["viewMode"]): {
    table: _tanstack_table_core.Table<unknown>;
    finalColumns: _tanstack_table_core.ColumnDef<unknown, unknown>[];
    sorting: SortingState;
    setSorting: React__default.Dispatch<React__default.SetStateAction<SortingState>>;
    columnFilters: ColumnFiltersState;
    setColumnFilters: React__default.Dispatch<React__default.SetStateAction<ColumnFiltersState>>;
    columnVisibility: VisibilityState;
    setColumnVisibility: React__default.Dispatch<React__default.SetStateAction<VisibilityState>>;
    globalFilter: string;
    setGlobalFilter: React__default.Dispatch<React__default.SetStateAction<string>>;
};
interface UseTableKeyboardOptions {
    /**
     * When provided, only fire shortcuts while the keydown target is inside
     * this element. Without it, shortcuts are global and would conflict between
     * multiple NTable instances on the same page.
     */
    scopeRef?: RefObject<HTMLElement | null>;
    /** Close the NTable right-click context menu (if any). */
    contextMenuClose?: () => void;
    /** True while the NTable context menu is open. */
    contextMenuOpen?: boolean;
}
declare function useTableKeyboard(options?: UseTableKeyboardOptions): void;

declare function cn(...inputs: ClassValue[]): string;

declare function resolveSlot<T>(slot: T | ((ctx: any) => ReactNode), ctx?: any): ReactNode;

/** True when `src` is absent, blank, or the seeded placeholder. */
declare function isPlaceholderAvatar(src: string | null | undefined): boolean;
/**
 * The image to render, or `fallback` when there is no real one.
 *
 * ```ts
 * resolveAvatarSrc(child.image, childPlaceholder(child.gender))
 * ```
 *
 * The fallback is a parameter rather than a package default because which stock
 * image belongs to a record is the application's to decide — a child, a family
 * and a sponsor do not share one. What is shared is the question of whether the
 * stored value counts as an image at all, which is all this answers.
 */
declare function resolveAvatarSrc<Fallback extends string | null | undefined>(src: string | null | undefined, fallback: Fallback): string | Fallback;

interface NajmFormatContextValue extends Required<Pick<NajmFormatConfig, "locale" | "timeZone" | "placeholder">> {
    currency?: string;
    /** Formats an integer count of minor units as `currency`. */
    money: (minorUnits: number | null | undefined) => string;
    number: (value: number | null | undefined, options?: Intl.NumberFormatOptions) => string;
    percent: (value: number | null | undefined, fractionDigits?: number) => string;
    date: (value: Date | number | string | null | undefined, options?: Intl.DateTimeFormatOptions) => string;
    dateTime: (value: Date | number | string | null | undefined) => string;
    time: (value: Date | number | string | null | undefined) => string;
    relativeTime: (value: Date | number | string | null | undefined) => string;
    humanize: (value: string) => string;
    /** The resolved inputs, for handing to the pure functions directly. */
    config: NajmFormatConfig;
}
interface NajmFormatProviderProps {
    children: React$1.ReactNode;
    /**
     * BCP 47 tag. `NajmAppProvider` derives this from the active `najm-i18n`
     * language, so applications using it rarely pass this by hand.
     */
    locale: string;
    /**
     * ISO 4217 code for `money`. Omitted means the application does not format
     * currency; calling `money` without it throws rather than guessing a symbol.
     */
    currency?: string;
    /**
     * Overrides the time zone from `NajmPreferencesProvider`.
     *
     * Reading preferences is the point — it is where the user's choice already
     * lives, and formatting dates against anything else is how a table ends up
     * disagreeing with the picker that set it.
     */
    timeZone?: string;
    /** Rendered for absent values. Defaults to an em dash. */
    placeholder?: string;
}
/**
 * Binds the formatters to the live locale and time zone.
 *
 * The time zone comes from `NajmPreferencesProvider` when one is mounted, which
 * is what makes this worth a provider rather than a helper import: the
 * preference and the rendering of every date derived from it stay in one place,
 * and a zone change re-renders the consumers instead of leaving stale text.
 */
declare function NajmFormatProvider({ children, locale, currency, timeZone, placeholder, }: NajmFormatProviderProps): React$1.JSX.Element;
/** Returns the context when one is mounted, or `null`. */
declare function useNajmFormatContext(): NajmFormatContextValue | null;
/**
 * The bound formatters.
 *
 * ```tsx
 * const fmt = useNajmFormat();
 * fmt.money(order.totalMinor); // "1 250,00 MAD"
 * fmt.date(order.createdAt);   // "8 août 2026"
 * ```
 */
declare function useNajmFormat(): NajmFormatContextValue;

interface JsonViewColors {
    background: string;
    phrase: string;
    bracket: string;
}
interface SmartPastePreview {
    mergedJson: string;
    newCount: number;
    dupeCount: number;
    label: string;
}
interface NSmartPasteDialogProps {
    open: boolean;
    currentJson: string;
    colors: JsonViewColors;
    title?: string;
    /** Short text shown in the header under the title. */
    subtitle?: string;
    /** Long-form helper text shown above the textarea. */
    description?: string;
    placeholder?: string;
    emptyMessage?: string;
    itemLabel: string;
    onMerge: (mergedJson: string) => void;
    onCancel: () => void;
    parseAndPreview: (pasteJson: unknown, currentJson: string) => SmartPastePreview | null;
}
declare function NSmartPasteDialog({ open, currentJson, colors, title, subtitle, description, placeholder, emptyMessage, itemLabel, onMerge, onCancel, parseAndPreview, }: NSmartPasteDialogProps): React$1.JSX.Element;

type LinkComponentType = ComponentType<{
    href: string;
    className?: string;
    children: ReactNode;
    onClick?: MouseEventHandler;
}>;
interface NavItem {
    id: string;
    label: string;
    href?: string;
    icon?: ComponentType<{
        className?: string;
    }>;
    badge?: ReactNode;
    disabled?: boolean;
    children?: NavItem[];
    sectionLabel?: string;
    sectionIcon?: ComponentType<{
        className?: string;
    }>;
}
interface NavItemGroup {
    sectionLabel?: string;
    sectionIcon?: ComponentType<{
        className?: string;
    }>;
    items: NavItem[];
}
interface NAppShellClassNames {
    root?: string;
    sidebar?: string;
    sidebarItem?: string;
    sidebarHeader?: string;
    sidebarLogo?: string;
    sidebarFooter?: string;
    navbar?: string;
    content?: string;
    overlay?: string;
}
type SidebarWidth = NajmResponsiveValue<number | string>;
interface SidebarWidths {
    expanded?: SidebarWidth;
    collapsed?: SidebarWidth;
    mobile?: SidebarWidth;
}
/**
 * Render-prop form of `logo`. Receives the state the sidebar actually resolved,
 * including `autoCollapseAt`, so consumers stop approximating it with their own
 * responsive classes.
 */
interface SidebarResolvedState {
    collapsed: boolean;
    isMobile: boolean;
}
type SidebarLogoRender = (state: SidebarResolvedState) => ReactNode;
/**
 * Render-prop form of `footer`. Receives the same resolved state as `logo`,
 * including automatic desktop collapse and the expanded mobile drawer.
 */
type SidebarFooterRender = (state: SidebarResolvedState) => ReactNode;
/**
 * Declarative form of `logo`. The sidebar owns the box, the fit and the
 * collapsed/expanded switch so every app renders the mark identically; the
 * consumer only says which asset. A `string` slot renders through `NImage`,
 * a `ReactNode` slot is placed in the same box untouched.
 */
interface SidebarLogo {
    /**
     * `mark` (default) frames logo artwork in a fixed box. `chip` is the icon
     * treatment: a square, tinted pill sized for a lucide-style glyph.
     */
    variant?: "mark" | "chip";
    expanded?: ReactNode | string;
    /** Falls back to `expanded`, rendered in the collapsed box. */
    collapsed?: ReactNode | string;
    /** Swapped in when a `string` slot fails to load. */
    fallback?: string;
    /** Defaults to the app name from `NBrandingProvider`. */
    alt?: string;
    href?: string;
    onClick?: () => void;
    title?: string;
    subtitle?: string;
}
interface SidebarProps {
    logo?: ReactNode | SidebarLogoRender | SidebarLogo;
    navItems?: NavItem[];
    activePath?: string;
    isActive?: (item: NavItem, activePath: string) => boolean;
    onNavigate?: (href: string) => void;
    linkComponent?: LinkComponentType;
    collapsed?: boolean;
    defaultCollapsed?: boolean;
    onCollapsedChange?: (collapsed: boolean) => void;
    showCollapseButton?: boolean;
    /**
     * Where the collapse toggle lives:
     * - `'footer'` — a full-width button in the footer.
     * - `'edge'` — a small floating circle on the sidebar's edge.
     * - `'rail'` — (default) an interactive strip along the right border. Hovering it
     *   shows a resize cursor + accent line; clicking or dragging the edge collapses/expands.
     */
    collapseButtonPosition?: 'footer' | 'edge' | 'rail';
    widths?: SidebarWidths;
    showSectionLabels?: boolean;
    showSectionIcons?: boolean;
    showSectionSeparators?: boolean;
    /** Use a border instead of the default flat sidebar edge. */
    bordered?: boolean;
    footer?: ReactNode | SidebarFooterRender;
    className?: string;
    classNames?: NAppShellClassNames;
    mobileBreakpoint?: 'sm' | 'md' | 'lg';
    /**
     * Automatically use the collapsed desktop rail within one Tailwind
     * breakpoint band. For example, `lg` collapses from 1024px through 1279px.
     */
    autoCollapseAt?: 'sm' | 'md' | 'lg' | 'xl';
    mobileOpen?: boolean;
    defaultMobileOpen?: boolean;
    onMobileOpenChange?: (open: boolean) => void;
    closeOnNavigate?: boolean;
    hamburgerLabel?: string;
    closeLabel?: string;
    collapseLabel?: string;
    expandLabel?: string;
    hamburgerClassName?: string;
    /**
     * Opts into the legacy fixed standalone trigger. Prefer controlling
     * `mobileOpen` from an NPageHeader via its `onSidebarOpen` prop.
     */
    showHamburgerButton?: boolean;
    onSettings?: () => void;
    settingsLabel?: string;
    onLogout?: () => void;
    logoutLabel?: string;
}
interface SidebarItemProps {
    item: NavItem;
    activePath?: string;
    isActive?: (item: NavItem, activePath: string) => boolean;
    onNavigate?: (href: string) => void;
    linkComponent?: LinkComponentType;
    collapsed?: boolean;
    depth?: number;
    classNames?: NAppShellClassNames;
}
interface NSidebarHeaderProps {
    children?: ReactNode;
    collapsed?: boolean;
    className?: string;
    classNames?: NAppShellClassNames;
}
interface NSidebarBrandProps {
    logo: SidebarLogo;
    collapsed: boolean;
    linkComponent?: LinkComponentType;
    className?: string;
}
interface NSidebarContentProps {
    groups: NavItemGroup[];
    activePath: string;
    isActive?: (item: NavItem, activePath: string) => boolean;
    onNavigate: (href: string) => void;
    linkComponent?: LinkComponentType;
    collapsed: boolean;
    showSectionLabels: boolean;
    showSectionIcons: boolean;
    showSectionSeparators: boolean;
    contentStyle?: CSSProperties;
    classNames?: NAppShellClassNames;
}
interface NSidebarSectionProps {
    group: NavItemGroup;
    activePath: string;
    isActive?: (item: NavItem, activePath: string) => boolean;
    onNavigate: (href: string) => void;
    linkComponent?: LinkComponentType;
    collapsed: boolean;
    showSectionLabels: boolean;
    showSectionIcons: boolean;
    showSectionSeparators: boolean;
    isFirst: boolean;
    classNames?: NAppShellClassNames;
}
interface NSidebarFooterProps {
    children?: ReactNode;
    onSettings?: () => void;
    settingsLabel?: string;
    onLogout?: () => void;
    logoutLabel?: string;
    showCollapseButton?: boolean;
    collapsed?: boolean;
    onToggleCollapsed?: () => void;
    collapseLabel?: string;
    expandLabel?: string;
    isMobile?: boolean;
    className?: string;
    classNames?: NAppShellClassNames;
}
interface NSidebarMobileProps {
    open: boolean;
    onOpen: () => void;
    onClose: () => void;
    mobileBreakpoint: 'sm' | 'md' | 'lg';
    width?: number | string;
    hamburgerLabel?: string;
    closeLabel?: string;
    hamburgerClassName?: string;
    showHamburgerButton?: boolean;
    children?: ReactNode;
    bordered?: boolean;
}

declare function NSidebarHeader({ children, collapsed, className, classNames }: NSidebarHeaderProps): React$1.JSX.Element;

declare function NSidebarBrand({ logo, collapsed, linkComponent: Link, className }: NSidebarBrandProps): React$1.JSX.Element;

declare function NSidebarContent({ groups, activePath, isActive, onNavigate, linkComponent, collapsed, showSectionLabels, showSectionIcons, showSectionSeparators, contentStyle, classNames, }: NSidebarContentProps): React$1.JSX.Element;

declare function NSidebarSection({ group, activePath, isActive, onNavigate, linkComponent, collapsed, showSectionLabels, showSectionIcons, showSectionSeparators, isFirst, classNames, }: NSidebarSectionProps): React$1.JSX.Element;

declare function NSidebarFooter({ children, onSettings, settingsLabel, onLogout, logoutLabel, showCollapseButton, collapsed, onToggleCollapsed, collapseLabel, expandLabel, isMobile, className, classNames, }: NSidebarFooterProps): React$1.JSX.Element;

declare function NSidebarMobile({ open, onOpen, onClose, mobileBreakpoint, width, hamburgerLabel, closeLabel, hamburgerClassName, showHamburgerButton, children, bordered, }: NSidebarMobileProps): React$1.JSX.Element;

interface NSidebarContextValue {
    collapsed: boolean;
    mobileOpen: boolean;
    openMobile: () => void;
    closeMobile: () => void;
    setMobileOpen: (open: boolean) => void;
    setCollapsed: (collapsed: boolean) => void;
    toggleCollapsed: () => void;
    mobileBreakpoint: "sm" | "md" | "lg";
}
/**
 * Returns `null` outside a provider, which is what lets `NSidebar` keep its own
 * state when it is used standalone. Consumers that need the sidebar from a
 * distance — `NPageHeader`'s mobile trigger, most of all — read it from here.
 */
declare function useNSidebar(): NSidebarContextValue | null;
/**
 * Owns the sidebar's open/collapsed state so that content rendered *beside* the
 * sidebar can reach it. `NSidebar` is a sibling of the page content, so this has
 * to wrap both — it cannot live inside `NSidebar` itself.
 *
 * The provider owns the state rather than forwarding a caller-built value: a
 * pass-through provider has to memoize on the value's fields, which silently
 * drops changed callback identities and serves stale closures.
 */
declare function NSidebarProvider({ children, defaultCollapsed, mobileBreakpoint, }: Readonly<{
    children: ReactNode;
    defaultCollapsed?: boolean;
    mobileBreakpoint?: "sm" | "md" | "lg";
}>): React$1.JSX.Element;

declare function NSidebar({ logo, navItems, activePath, isActive, onNavigate, linkComponent, collapsed: collapsedProp, defaultCollapsed, onCollapsedChange, showCollapseButton, collapseButtonPosition, showSectionLabels, showSectionIcons, showSectionSeparators, bordered, footer, className, classNames, mobileBreakpoint: mobileBreakpointProp, autoCollapseAt, mobileOpen: mobileOpenProp, defaultMobileOpen, onMobileOpenChange, closeOnNavigate, hamburgerLabel, closeLabel, collapseLabel, expandLabel, hamburgerClassName, showHamburgerButton, onSettings, settingsLabel, onLogout, logoutLabel, widths, }: SidebarProps): React$1.JSX.Element;

declare function NSidebarItem({ item, activePath, isActive, onNavigate, linkComponent: LinkComponent, collapsed, depth, classNames, }: SidebarItemProps): React__default.JSX.Element;

interface UserMenuAction {
    id: string;
    label: string;
    icon?: ComponentType<{
        className?: string;
    }>;
    onClick?: () => void;
    separator?: boolean;
}
interface NAppShellUser {
    name: string;
    email?: string;
    avatarUrl?: string;
    fallback?: string;
}
interface NAppShellAction {
    id: string;
    label: string;
    icon?: ComponentType<{
        className?: string;
    }>;
    onClick?: () => void;
    badge?: ReactNode;
    hideOnMobile?: boolean;
}
interface NAppShellProps extends Pick<SidebarProps, "widths"> {
    children: ReactNode;
    logo?: ReactNode;
    title?: string;
    navItems?: NavItem[];
    activePath?: string;
    onNavigate?: (href: string) => void;
    isActive?: (item: NavItem, activePath: string) => boolean;
    linkComponent?: LinkComponentType;
    user?: NAppShellUser;
    actions?: NAppShellAction[];
    userMenuActions?: UserMenuAction[];
    onLogout?: () => void;
    collapsed?: boolean;
    defaultCollapsed?: boolean;
    onCollapsedChange?: (collapsed: boolean) => void;
    /** Where the collapse toggle lives: a full-width button in the footer, or a small floating circle on the sidebar's edge. */
    collapseButtonPosition?: 'footer' | 'edge';
    sidebarFooter?: SidebarProps["footer"];
    navbarLeft?: ReactNode;
    navbarRight?: ReactNode;
    classNames?: NAppShellClassNames;
}
interface NAppCommandItem {
    id: string;
    label: string;
    description?: string;
    icon?: ComponentType<{
        className?: string;
    }>;
    shortcut?: string;
    onSelect: () => void;
    group?: string;
}
interface NCommandPaletteProps {
    commands: NAppCommandItem[];
    open?: boolean;
    onOpenChange?: (open: boolean) => void;
    placeholder?: string;
    emptyMessage?: string;
    className?: string;
}

declare function NAppShell({ children, logo, title, navItems, activePath, onNavigate, isActive, linkComponent, user, actions, userMenuActions, onLogout, collapsed: controlledCollapsed, defaultCollapsed, onCollapsedChange, collapseButtonPosition, widths, sidebarFooter, navbarLeft, navbarRight, classNames, }: NAppShellProps): React__default.JSX.Element;

interface NavbarProps {
    title?: string;
    logo?: ReactNode;
    user?: NAppShellUser;
    actions?: NAppShellAction[];
    userMenuActions?: UserMenuAction[];
    onLogout?: () => void;
    onToggleSidebar?: () => void;
    onToggleMobile?: () => void;
    leftSlot?: ReactNode;
    rightSlot?: ReactNode;
    className?: string;
    classNames?: NAppShellClassNames;
}
declare function NNavbar({ title, logo, user, actions, userMenuActions, onLogout, onToggleSidebar, onToggleMobile, leftSlot, rightSlot, className, classNames, }: NavbarProps): React__default.JSX.Element;

declare function NCommandPalette({ commands, open, onOpenChange, placeholder, emptyMessage, className, }: NCommandPaletteProps): React__default.JSX.Element;

interface NPageLayoutProps extends React$1.HTMLAttributes<HTMLElement> {
    as?: "main" | "div" | "section";
}
declare function NPageLayout({ as: Comp, className, style, ...props }: NPageLayoutProps): React$1.JSX.Element;

interface InspectorSheetProps {
    open: boolean;
    onClose: () => void;
    title: string;
    children: React__default.ReactNode;
}
declare function NInspectorSheet({ open, onClose, title, children }: InspectorSheetProps): React__default.JSX.Element;

type NGridCols = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
type NGridSpan = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
interface NGridProps extends Omit<React$1.AllHTMLAttributes<HTMLElement>, "gap" | "cols"> {
    children: React$1.ReactNode;
    /** Columns at the base (mobile) size. Defaults to 1. */
    cols?: NGridCols;
    /** Columns at the `sm` breakpoint and above (≥640px). */
    smCols?: NGridCols;
    /** Columns at the `md` breakpoint and above (≥768px). */
    mdCols?: NGridCols;
    /** Columns at the `lg` breakpoint and above (≥1024px). */
    lgCols?: NGridCols;
    /** Columns at the `xl` breakpoint and above (≥1280px). */
    xlCols?: NGridCols;
    /** Gap between cells. Defaults to the theme's `sectionGap` token (`--section-gap`). */
    gap?: string;
    /** Render the grid as a different element (defaults to `div`). */
    as?: "div" | "section" | "ul";
    className?: string;
}
interface NGridItemProps extends Omit<React$1.AllHTMLAttributes<HTMLDivElement>, "span"> {
    children: React$1.ReactNode;
    /** Columns spanned at the base (mobile) size. Defaults to 1. */
    span?: NGridSpan;
    /** Columns spanned at the `sm` breakpoint and above (≥640px). */
    smSpan?: NGridSpan;
    /** Columns spanned at the `md` breakpoint and above (≥768px). */
    mdSpan?: NGridSpan;
    /** Columns spanned at the `lg` breakpoint and above (≥1024px). */
    lgSpan?: NGridSpan;
    /** Columns spanned at the `xl` breakpoint and above (≥1280px). */
    xlSpan?: NGridSpan;
    className?: string;
}
declare function NGrid({ as: Comp, children, cols, smCols, mdCols, lgCols, xlCols, gap, className, style, ...props }: NGridProps): React$1.JSX.Element;
declare function NGridItem({ children, span, smSpan, mdSpan, lgSpan, xlSpan, className, ...props }: NGridItemProps): React$1.JSX.Element;

interface NNotifyRootProps {
    children: React$1.ReactNode;
    /** Controlled open state. When passed, no competing internal state is kept. */
    open?: boolean;
    defaultOpen?: boolean;
    onOpenChange?: (open: boolean) => void;
    modal?: boolean;
}
declare function NNotifyRoot({ children, open, defaultOpen, onOpenChange, modal, }: NNotifyRootProps): React$1.JSX.Element;
declare namespace NNotifyRoot {
    var displayName: string;
}

/** Hidden at zero, localized 1-99, `99+` above 99. */
declare function formatNotifyCount(count: number, locale?: string): string;
interface NNotifyTriggerProps extends Omit<NButtonProps, "children" | "type" | "asChild"> {
    unreadCount?: number;
    /** Accessible name of the button. */
    label: string;
    /** Politely announced whenever the count changes. */
    unreadLabel?: (count: number) => string;
    /** Overrides the default count formatting. An empty string hides the badge. */
    formatCount?: (count: number) => string;
    /** Number locale for the badge. Defaults to the document language. */
    locale?: string;
    icon?: React$1.ReactNode;
    indicatorColor?: BadgeColor;
}
/** The bell that opens the menu. */
declare const NNotifyTrigger: React$1.ForwardRefExoticComponent<NNotifyTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;

interface NNotifyContentProps extends Omit<React$1.ComponentProps<typeof PopoverContent>, "children"> {
    children: React$1.ReactNode;
}
/**
 * The popover surface: end-aligned, safe at 320px, and a scrolling boundary
 * for the list.
 *
 * Children are not rendered while the menu is closed. A connected child may
 * therefore mount its own query on open and refetch on every entry, which is
 * the whole reason the compound form exists.
 */
declare function NNotifyContent({ children, className, align, sideOffset, ...contentProps }: NNotifyContentProps): React$1.JSX.Element;
declare namespace NNotifyContent {
    var displayName: string;
}

/**
 * Presentation-only notification row.
 *
 * The package never sees a topic, a raw payload, an aggregate, a recipient or
 * an API response shape: applications map their own records to this before
 * rendering. `href` is data — Najm Kit never imports or calls a router, it
 * hands the item back through `onOpenItem` and the application navigates.
 */
interface NNotifyItemData {
    id: string;
    title: string;
    body?: string;
    href?: string;
    read: boolean;
    createdAt?: string | Date;
    icon?: ComponentType<{
        className?: string;
    }> | ReactNode;
    tone?: NNotifyTone;
}
type NNotifyTone = "default" | "success" | "warning" | "destructive";
/** Every user-visible string. Applications own their translation catalogs. */
interface NNotifyLabels {
    open: string;
    unread: (count: number) => string;
    title: string;
    loading: string;
    emptyTitle: string;
    emptyDescription?: string;
    errorTitle: string;
    retry: string;
    markRead: string;
    markingRead?: string;
    markAllRead: string;
    markingAll?: string;
    view: string;
    viewAll: string;
    unreadState?: string;
    justNow?: string;
}
type NNotifyAction = "markRead" | "markAll" | "open" | "viewAll";
/**
 * What a command callback may return.
 *
 * Deliberately not `Promise<void>`: React Query's `mutateAsync` resolves with
 * the mutation's result, and a `Promise<T>` is not assignable to a
 * `Promise<void>`. Narrowing it would make every application wrap every
 * command in an async arrow that throws the value away. The package only ever
 * awaits these.
 */
type NNotifyCommandResult = void | Promise<unknown>;
type NNotifyErrorHandler = (error: unknown, action: NNotifyAction) => void;

interface NNotifyHeaderProps {
    title: string;
    markAllLabel?: string;
    markingAllLabel?: string;
    /** Application-owned pending state; the component also tracks its own. */
    markAllPending?: boolean;
    onMarkAllRead?: () => NNotifyCommandResult;
    onError?: NNotifyErrorHandler;
    children?: React$1.ReactNode;
    className?: string;
}
/**
 * Title plus the mark-all action. A rejected command reports through
 * `onError` and leaves the menu open — the package emits no product copy of
 * its own for the failure.
 */
declare function NNotifyHeader({ title, markAllLabel, markingAllLabel, markAllPending, onMarkAllRead, onError, children, className, }: NNotifyHeaderProps): React$1.JSX.Element;
declare namespace NNotifyHeader {
    var displayName: string;
}

/** Absolute time, or the just-now label under a minute and for junk input. */
declare function formatNotifyTime(value: string | Date | undefined, justNow: string | undefined, locale?: string): string;
interface NNotifyItemProps {
    item: NNotifyItemData;
    labels: Pick<NNotifyLabels, "view" | "markRead"> & Partial<Pick<NNotifyLabels, "markingRead" | "unreadState" | "justNow">>;
    /** Application-owned pending state for this row. */
    pending?: boolean;
    onMarkRead?: (id: string) => NNotifyCommandResult;
    onOpenItem?: (item: NNotifyItemData) => NNotifyCommandResult;
    /** Runs after a successful standalone mark-read. */
    onMarkedRead?: (item: NNotifyItemData) => void;
    onError?: NNotifyErrorHandler;
    /** Mark an unread item read before opening it. Default `true`. */
    markReadOnOpen?: boolean;
    /** Close the menu after a successful open. Default `true`. */
    closeOnOpen?: boolean;
    locale?: string;
    className?: string;
}
/**
 * One notification row.
 *
 * Opening awaits the read command first: a rejected read never navigates,
 * never closes the menu, and never reports success. Buttons stay flat — no
 * interactive element is nested inside another.
 */
declare function NNotifyItem({ item, labels, pending, onMarkRead, onOpenItem, onMarkedRead, onError, markReadOnOpen, closeOnOpen, locale, className, }: NNotifyItemProps): React$1.JSX.Element;
declare namespace NNotifyItem {
    var displayName: string;
}

interface NNotifyRenderItemHelpers {
    pending: boolean;
    onMarkRead?: (id: string) => NNotifyCommandResult;
    onOpenItem?: (item: NNotifyItemData) => NNotifyCommandResult;
    onError?: NNotifyErrorHandler;
}
interface NNotifyListProps {
    items: readonly NNotifyItemData[];
    labels: NNotifyLabels;
    loading?: boolean;
    /** `true` uses `labels.errorTitle`; a string replaces it. */
    error?: string | boolean;
    onRetry?: () => NNotifyCommandResult;
    markReadPendingId?: string | null;
    onMarkRead?: (id: string) => NNotifyCommandResult;
    onOpenItem?: (item: NNotifyItemData) => NNotifyCommandResult;
    onError?: NNotifyErrorHandler;
    /** Escape hatch. The default row covers the common workflow already. */
    renderItem?: (item: NNotifyItemData, helpers: NNotifyRenderItemHelpers) => React$1.ReactNode;
    itemProps?: Partial<Omit<NNotifyItemProps, "item" | "labels">>;
    emptyIcon?: React$1.ReactNode;
    locale?: string;
    className?: string;
}
/** Loading, error, empty and populated states inside one bounded scroll area. */
declare function NNotifyList({ items, labels, loading, error, onRetry, markReadPendingId, onMarkRead, onOpenItem, onError, renderItem, itemProps, emptyIcon, locale, className, }: NNotifyListProps): React$1.JSX.Element;
declare namespace NNotifyList {
    var displayName: string;
}

interface NNotifyFooterProps {
    label?: string;
    onViewAll?: () => NNotifyCommandResult;
    /** Render an application link instead of a button. */
    asChild?: boolean;
    children?: React$1.ReactNode;
    onError?: NNotifyErrorHandler;
    className?: string;
}
/**
 * The view-all action. The menu closes only once the supplied action is
 * accepted; what "view all" means — a route, a dialog, a tab — is the
 * application's decision.
 */
declare function NNotifyFooter({ label, onViewAll, asChild, children, onError, className, }: NNotifyFooterProps): React$1.JSX.Element;
declare namespace NNotifyFooter {
    var displayName: string;
}

interface NNotifyMenuProps {
    items: readonly NNotifyItemData[];
    unreadCount: number;
    labels: NNotifyLabels;
    loading?: boolean;
    error?: string | boolean;
    markAllPending?: boolean;
    markReadPendingId?: string | null;
    open?: boolean;
    defaultOpen?: boolean;
    onOpenChange?: (open: boolean) => void;
    onRetry?: () => NNotifyCommandResult;
    onMarkRead?: (id: string) => NNotifyCommandResult;
    onMarkAllRead?: () => NNotifyCommandResult;
    onOpenItem?: (item: NNotifyItemData) => NNotifyCommandResult;
    onViewAll?: () => NNotifyCommandResult;
    onError?: NNotifyErrorHandler;
    /** An application link rendered as the view-all action. */
    viewAllLink?: React$1.ReactNode;
    triggerProps?: Omit<NNotifyTriggerProps, "unreadCount" | "label" | "unreadLabel">;
    contentProps?: Omit<NNotifyContentProps, "children">;
    locale?: string;
    className?: string;
}
/**
 * The whole list-with-read-button workflow from normalized data, labels and
 * callbacks. Applications whose preview data must only load while the menu is
 * open compose the flat parts instead and put a connected child inside
 * `NNotifyContent`.
 */
declare function NNotifyMenu({ items, unreadCount, labels, loading, error, markAllPending, markReadPendingId, open, defaultOpen, onOpenChange, onRetry, onMarkRead, onMarkAllRead, onOpenItem, onViewAll, onError, viewAllLink, triggerProps, contentProps, locale, className, }: NNotifyMenuProps): React$1.JSX.Element;
declare namespace NNotifyMenu {
    var displayName: string;
}

interface NGlobalActionsProps {
    children: React$1.ReactNode;
    className?: string;
}
/**
 * The action group for a page header or navbar slot: spacing, alignment and
 * shrink behavior, nothing else. It fetches, translates, authorizes and
 * persists nothing.
 */
declare function NGlobalActions({ children, className }: NGlobalActionsProps): React$1.JSX.Element;
declare namespace NGlobalActions {
    var displayName: string;
}

interface NLanguageOption<T extends string = string> {
    value: T;
    label: string;
    /** Optional injected node — a flag element, an emoji, nothing at all. */
    icon?: React$1.ReactNode;
    iconLabel?: string;
}
interface NLanguageMenuProps<T extends string = string> {
    value: T;
    options: readonly NLanguageOption<T>[];
    /** Accessible name of the trigger. */
    label: string;
    pendingLabel?: string;
    pending?: boolean;
    /** Awaited; may resolve with anything (a mutation result, typically). */
    onChange: (value: T) => void | Promise<unknown>;
    onError?: (error: unknown) => void;
    align?: "start" | "center" | "end";
    className?: string;
    contentClassName?: string;
}
/**
 * Language presentation only. The catalog, the endpoint, the persistence and
 * every secondary effect of switching language stay in the application's own
 * change command, which this awaits.
 */
declare function NLanguageMenu<T extends string = string>({ value, options, label, pendingLabel, pending, onChange, onError, align, className, contentClassName, }: NLanguageMenuProps<T>): React$1.JSX.Element;
declare namespace NLanguageMenu {
    var displayName: string;
}

interface NThemeToggleProps {
    label: string;
    pendingLabel?: string;
    pending?: boolean;
    onError?: (error: unknown) => void;
    className?: string;
}
/**
 * Light/dark toggle over the existing `useNajmTheme` contract. Persistence
 * failure is reported through `onError` — the package emits no copy of its
 * own — and the pending state is always released.
 */
declare function NThemeToggle({ label, pendingLabel, pending, onError, className, }: NThemeToggleProps): React$1.JSX.Element;
declare namespace NThemeToggle {
    var displayName: string;
}

interface NFullscreenToggleProps {
    label: string;
    exitLabel?: string;
    /** Hidden below this breakpoint. `null` keeps it visible everywhere. */
    hiddenBelow?: "sm" | "md" | "lg" | null;
    onError?: (error: unknown) => void;
    className?: string;
}
/**
 * Fullscreen toggle.
 *
 * `screenfull` reports `isEnabled: false` rather than throwing where the API
 * is missing, and touches no browser global at import time, so this is safe to
 * render during SSR and hydration. An unsupported environment renders a
 * disabled control instead of a button that does nothing.
 */
declare function NFullscreenToggle({ label, exitLabel, hiddenBelow, onError, className, }: NFullscreenToggleProps): React$1.JSX.Element;
declare namespace NFullscreenToggle {
    var displayName: string;
}

export { Alert, type AlertLook, type AlertOrientation, type AlertProps, type AlertSize, type AlertTone, type AlertVariant, NCard as AsyncCard, Avatar, AvatarFallback, AvatarFormInput, type AvatarFormInputProps, AvatarGroup, type AvatarGroupProps, AvatarImage, AvatarInput, AvatarInputProps, type AvatarProps$1 as AvatarProps, type AvatarShape$1 as AvatarShape, type AvatarSize, AvatarStatus, type AvatarStatusType, BadgeColor, BadgeShape, BaseInput, type BuildDefaultFileColumnsOptions, Button, type ButtonConfig, type ButtonIcon, type ButtonLoaderPosition, type ButtonProps, type ButtonRounded, type ButtonSize, type ButtonVariant, Calendar, Card, CardAction, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, Checkbox, CheckboxGroupInput, CheckboxGroupInputProps, CheckboxInput, CheckboxInputProps, Collapsible, CollapsibleContent, CollapsibleTrigger, ColorArrayInput, ColorArrayInputProps, ColorPickerInput, ColorPickerInputProps, Combobox, ComboboxInput, ComboboxInputProps, type ComboboxOption, type ComboboxProps, Command, CommandDialog, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList, CommandSeparator, CommandShortcut, type ContextMenuItem, DEFAULT_CARD_BREAKPOINT, DEFAULT_THEME_FILE_NAME, DEFAULT_TOOLBAR_KEY_PREFIX, DateInput, DateInputProps, type DeleteDialogOptions, Dialog, type DialogActionMode, type DialogApi, DialogClose, type DialogConfig, DialogContent, type DialogContentProps, DialogDescription, DialogFooter, DialogHeader, type DialogHeight, DialogOverlay, type DialogPadding, DialogPortal, type DialogRenderContext, type DialogRenderer, type DialogSize, type DialogStore, DialogTitle, DialogTrigger, type DialogVariant, type DialogWidth, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, DynamicArray, type DynamicArrayProps, EMPTY_DESIGN, EmojiInput, EmojiInputProps, type FileBrowserMode, FileImportButton, FileInput, FileInputProps, type FileNode, Form, FormControl, FormDescription, FormDevTools, FormDevToolsOptions, FormDevToolsProvider, FormField, FormInput, FormInputProps, FormItem, FormLabel, FormMessage, FormProps, FormVariant, IconButton, type IconButtonProps, type IconButtonSize, type IconButtonVariant, ImageInput, ImageInputProps, Indicator, type IndicatorHorizontal, type IndicatorOverlay, type IndicatorPosition, type IndicatorProps, type IndicatorResponsivePosition, type IndicatorSize, type IndicatorVertical, Input, Label, LangInput, LangInputProps, type LinkComponentType, MultiSelectInput, MultiSelectInputProps, NAJM_COLOR_TEXT_CLASSES, NAJM_SAVED_THEME_VALUE, NAJM_STATUS_COLORS, NAlert, type NAppCommandItem, NAppShell, type NAppShellAction, type NAppShellClassNames, type NAppShellProps, type NAppShellUser, NCard as NAsyncCard, type CardClassNames as NAsyncCardClassNames, type CardProps as NAsyncCardProps, NAvatar, type NAvatarClassNames, type NAvatarImageProps, type NAvatarProps, type AvatarShape as NAvatarShape, NBarChart, type NBarChartProps, type NBulkAction, type NBulkActionButton, type NBulkActionSelect, NBulkActionsBar, type NBulkActionsBarProps, NButton, type NButtonProps, NCard, NCardAction, type CardClassNames as NCardClassNames, type NCardDensity, NCardFooter, NCardInfo, type NCardInfoProps, NCardMedia, type NCardMediaAspect, type NCardMediaPlacement, type NCardMediaProps, type NCardMediaSize, type NCardMediaVariant, type CardProps as NCardProps, NCardSection, type NCardSectionProps, type NCardSectionSurface, type NCartesianChartProps, type NChartCardProps, type NChartDatum, type NChartItem, type NChartSeries, type NChartSize, NChartSkeleton, type NChartSkeletonProps, type NChartSkeletonVariant, NCommandPalette, type NCommandPaletteProps, NConfirmDialog, type NConfirmDialogProps, NContextMenu, type NContextMenuItem, type NContextMenuProps, type NCredentialField, NCredentialsCard, type NCredentialsCardClassNames, type NCredentialsCardProps, NDataCardShell, type NDataCardShellActions, type NDataCardShellProps, NDeleteDialog, NDeleteDialogContent, type NDeleteDialogContentProps, type NDeleteDialogProps, NDetailCard, type NDetailCardClassNames, type NDetailCardProps, NDetailItem, type NDetailItemProps, NDetailList, type NDetailListItem, type NDetailListProps, NDialog, type NDialogActionProps, NDialogDescription, type NDialogDescriptionProps, type NDialogDirectProps, NDialogHeader, type NDialogHeaderProps, NDialogPrimaryButton, type NDialogProps, NDialogSecondaryButton, NDonutCard, type NDonutCardClassNames, type NDonutCardItem, type NDonutCardLayout, type NDonutCardLegendMarker, type NDonutCardProps, type NDonutCardVariant, type NEditorTab, NEditorTabs, type NEditorTabsProps, NErrorBoundary, type NFeedbackIconSize, NFileBrowser, type NFileBrowserCardProps, type NFileBrowserProps, type NFileBrowserRenderThumbProps, NFileTypeIcon, type NFileTypeIconProps, NFilterBar, NFolderIcon, type NFolderIconProps, NForm, NFormSectionHeader, type NFormSectionHeaderProps, NFullscreenToggle, type NFullscreenToggleProps, NGlobalActions, type NGlobalActionsProps, NGrid, type NGridCols, NGridItem, type NGridItemProps, type NGridProps, type NGridSpan, NIconSource, NImage, type NImageProps, NIndicator, NInspectorSheet, NLanguageMenu, type NLanguageMenuProps, type NLanguageOption, NLineChart, type NLineChartProps, NMultiDialog, type NMultiDialogProps, NNavbar, type NNotifyAction, type NNotifyCommandResult, NNotifyContent, type NNotifyContentProps, type NNotifyErrorHandler, NNotifyFooter, type NNotifyFooterProps, NNotifyHeader, type NNotifyHeaderProps, NNotifyItem, type NNotifyItemData, type NNotifyItemProps, type NNotifyLabels, NNotifyList, type NNotifyListProps, NNotifyMenu, type NNotifyMenuProps, type NNotifyRenderItemHelpers, NNotifyRoot, type NNotifyRootProps, type NNotifyTone, NNotifyTrigger, type NNotifyTriggerProps, NPageHeader, NPageHeaderActions, type NPageHeaderBreakpoint, NPageHeaderCompactActions, NPageHeaderFilters, type NPageHeaderProps, NPageHeaderTop, NPageLayout, type NPageLayoutProps, NPieChart, type NPieChartProps, NPortalScopeProvider, NProgress, type NProgressProps, NRowActions, NSection, NSectionHeader, type NSectionHeaderActionsProps, type NSectionHeaderContentProps, type NSectionHeaderProps, type NSectionHeaderSubtitleProps, type NSectionHeaderTitleProps, NSectionInfo, type NSectionInfoProps, type NSectionProps, NSectionWithInfo, type NSectionWithInfoItem, type NSectionWithInfoProps, NSheet, type NSheetClassNames, type NSheetProps, NSidebar, NSidebarBrand, type NSidebarBrandProps, NSidebarContent, type NSidebarContentProps, type NSidebarContextValue, NSidebarFooter, type NSidebarFooterProps, NSidebarHeader, type NSidebarHeaderProps, NSidebarItem, NSidebarMobile, type NSidebarMobileProps, NSidebarProvider, NSidebarSection, type NSidebarSectionProps, NSkeleton, NSkeletonCalendar, NSkeletonChart, NSkeletonDonut, NSkeletonEventList, NSkeletonWidget, NSkeletonWidgets, NSmartPasteDialog, type NSmartPasteDialogProps, NSpinner, type NSpinnerProps, NStatCard, type NStatCardClassNames, type NStatCardProps, NStatCardSkeleton, type NStatCardVariant, NStatusBreakdown, type NStatusBreakdownProps, Swap as NSwap, type NSwapProps, NTable, NTableCardPagination, NTableCardRoot, type NTableCardRootProps, NTableCards, type NTableClassNames, type NTableColumnBreakpoint, type NTableColumnDef, type NTableColumnMeta, NTableContent, type NTableEditorOption, type NTableEditorType, NTableHeader, NTableLoadingSkeleton, type NTableMenu, type NTableMenuProp, type NTablePageItem, NTablePagination, NTablePaginationLabels, NTablePaginationVariant, type NTableProps, NTableRowSkeleton, NTableSkeleton, type NTableState, NTableToolbarLabels, NTabs, type NTabsClassNames, type NTabsColor, type NTabsItem, type NTabsProps, type NTabsStyles, NThemeCustomizer, type NThemeCustomizerFontOption, type NThemeCustomizerLabels, type NThemeCustomizerProps, type NThemeCustomizerTab, type NThemePreset, NThemePresets, type NThemePresetsLabels, type NThemePresetsProps, type NThemePresetsStatus, NThemeToggle, type NThemeToggleProps, NUploader, type NUploaderItem, type NUploaderItemStatus, type NUploaderProps, NViewBody, NViewToggle, NajmAccent, NajmAppearance, type NajmBorderSide, NajmComponentName, NajmComponentStyleConfig, NajmComponentThemeConfig, NajmDesignConfig, NajmDesignEditorProvider, type NajmDesignEditorProviderProps, type NajmDesignEditorValue, NajmDesignProvider, type NajmDesignProviderProps, NajmFormatConfig, type NajmFormatContextValue, NajmFormatProvider, type NajmFormatProviderProps, NajmLayoutConfig, NajmMode, NajmPreset, NajmResponsiveBreakpoint, NajmResponsiveValue, NajmScroll, type NajmScrollProps, NajmThemeConfig, NajmThemeProvider, NajmThemeProviderProps, NajmThemeTokens, NajmTranslate, NajmTypographyConfig, NativeSelect, type NativeSelectOption, type NativeSelectProps, type NavItem, type NavItemGroup, NumberInput, NumberInputProps, OtpInput, OtpInputProps, PasswordInput, PasswordInputProps, PhoneInput, PhoneInputProps, Popover, PopoverAnchor, PopoverContent, PopoverTrigger, PrefixProvider, Progress, type ProgressColor, type ProgressLabelPosition, type ProgressProps, type ProgressSize, type PushDialogOptions, RadioGroup, RadioGroupInput, RadioGroupInputProps, RadioGroupItem, type RenderSlot, RepeatingFields, type RepeatingFieldsProps, ScrollArea, type ScrollAreaProps, SearchField, SearchField as SearchInput, SegmentedControl, type SegmentedControlOption, type SegmentedControlProps, Select, SelectContent, SelectGroup, SelectInput, SelectInputProps, SelectItem, type SelectItemType as SelectItemDataType, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue, Separator, Sheet, SheetClose, SheetContent, SheetDescription, SheetFooter, SheetHeader, SheetOverlay, SheetPortal, SheetTitle, SheetTrigger, type SidebarFooterRender, type SidebarItemProps, type SidebarLogo, type SidebarLogoRender, type SidebarProps, type SidebarResolvedState, type SidebarWidth, type SidebarWidths, SimpleTooltip, type SimpleTooltipProps, NSkeleton as Skeleton, type SmartPastePreview, type SpinnerVariant, StarRatingInput, StarRatingInputProps, StatusPill, type StatusPillProps, type StatusPillTone, type StepConfig, StepIndicator, type StepMeta, StepsHeader, StepsProgress, type StorageMenuAction, type StorageSortOption, type StorageTarget, Swap, type SwapEffect, SwapIndeterminate, SwapOff, SwapOn, type SwapProps, type SwapSize, type SwapState, Switch, type SwitchColor, SwitchInput, SwitchInputProps, type SwitchSize, TAB_COLORS, Table, TableBody, TableCaption, TableCell, TableFooter, TableHead, TableHeader, type TableHeaderColor, TableRow, type TableState, type TableStore, TableStoreContext, Tabs, TabsContent, TabsList, type TabsListProps, type TabsOrientation, type TabsProps, TabsTrigger, type TabsTriggerProps, type TabsVariant, TextAreaInput, TextAreaInputProps, TextInput, TextInputProps, Textarea, TimeInput, TimeInputProps, TimeZoneInput, TimeZoneInputProps, Toaster, Toggle, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger, type UseContextMenuResult, type UseNFormOptions, type UseStorageContextMenuOptions, type UseStorageContextMenuResult, type UserMenuAction, type WizardClassNames, WizardForm, type WizardFormProps, alertVariants, avatarVariants, buildDefaultFileColumns, buildPageItems, buildToolbarLabels, buttonVariants, cn, colorTextClass, composePreset, createDialogStore, createTableStore, defineNajmThemeConfig, dialogVariants, filterResponsiveColumns, findStatusColor, focusRingClasses, focusRingWithinClasses, formatFileBytes, formatFileRelative, formatNotifyCount, formatNotifyTime, getIconColorProps, getNChartColor, getNextEditorTabValue, hiddenBelowClasses, indicatorVariants, inputBorderClasses, isPlaceholderAvatar, normalizeStatusToken, normalizeThemeFileName, parseNajmThemeConfig, parseThemeFile, resolveAvatarSrc, resolveHiddenBelowClass, resolvePreset, resolveSlot, resolveStatusColor, sidebarBorderClasses, statusTextClass, stringifyNajmThemeConfig, stringifyThemeFile, surfaceBorderClasses, swapVariants, toggleVariants, tooltipContentVariants, truncateByCharacters, useCardViewport, useClickOutside, useContextMenu, useDebouncedValue, useDelayedLoading, useDesktopTableMode, useDialog, useDialogStore, useDynamicPageSize, useFormField, useFormSubmission, useInfiniteScroll, useKeyboard, useLocalStorageState, useMediaQuery, useNForm, useNPortalScope, useNSidebar, useNajmAppearance, useNajmComponentStyle, useNajmDesign, useNajmDesignEditor, useNajmFormat, useNajmFormatContext, useNajmThemeMode, usePrefix, useSelection, useStepNavigation, useStorageContextMenu, useStoreSync, useTable, useTableKeyboard, useTableStore };