@salilvnair/dui 1.0.0

package/dist/lib/components/input/DiffEditorView.fallback.d.ts

@@ -0,0 +1,2 @@
+import { DiffEditorViewProps } from './DiffEditorView';
+export declare function DiffEditorViewFallback({ original, modified, height, fontSize, wordWrap, }: DiffEditorViewProps): import("react").JSX.Element;

package/dist/lib/components/input/DiffEditorView.monaco.d.ts

@@ -0,0 +1,2 @@
+import { DiffEditorViewProps } from './DiffEditorView';
+export declare function DiffEditorViewMonacoImpl({ original, modified, language, height, readOnly, renderSideBySide, wordWrap, fontSize, theme, onMount, }: DiffEditorViewProps): import("react").JSX.Element;

package/dist/lib/components/input/DurationInputView.d.ts

@@ -0,0 +1,15 @@
+import { DuiSize } from '../../core/DuiTypes';
+export type DurationUnit = 'ms' | 's' | 'm' | 'hr';
+export interface DurationInputViewProps {
+    /** Current value in milliseconds */
+    value: number;
+    /** Called with new value in milliseconds */
+    onChange: (ms: number) => void;
+    placeholder?: string;
+    accentColor?: string;
+    /** Falls back to DuiProvider size when omitted. */
+    size?: DuiSize;
+    width?: number;
+    className?: string;
+}
+export declare function DurationInputView({ value, onChange, placeholder, size, width, className, }: DurationInputViewProps): import("react").JSX.Element;

package/dist/lib/components/input/EditorView.d.ts

@@ -0,0 +1,222 @@
+import { DuiSize } from '../../core/DuiTypes';
+import { ContextMenuItem } from '../modal/ContextMenuView';
+/**
+ * 'native' — Monaco's built-in context menu (default).
+ * 'dui'    — suppress Monaco's menu, show DUI's ContextMenuView instead.
+ * 'none'   — suppress the context menu entirely (e.g. a REPL input where
+ *            right-click doesn't make sense).
+ */
+export type EditorContextMenuMode = 'native' | 'dui' | 'none';
+export declare const EditorLineNumbers: {
+    readonly ON: "on";
+    readonly OFF: "off";
+    readonly RELATIVE: "relative";
+    readonly INTERVAL: "interval";
+};
+export type EditorLineNumbers = typeof EditorLineNumbers[keyof typeof EditorLineNumbers];
+export declare const EditorWordWrap: {
+    readonly OFF: "off";
+    readonly ON: "on";
+    readonly WORD_WRAP_COLUMN: "wordWrapColumn";
+    readonly BOUNDED: "bounded";
+};
+export type EditorWordWrap = typeof EditorWordWrap[keyof typeof EditorWordWrap];
+export declare const EditorCursorStyle: {
+    readonly LINE: "line";
+    readonly BLOCK: "block";
+    readonly UNDERLINE: "underline";
+    readonly LINE_THIN: "line-thin";
+    readonly BLOCK_OUTLINE: "block-outline";
+    readonly UNDERLINE_THIN: "underline-thin";
+};
+export type EditorCursorStyle = typeof EditorCursorStyle[keyof typeof EditorCursorStyle];
+export declare const EditorCursorBlinking: {
+    readonly BLINK: "blink";
+    readonly SMOOTH: "smooth";
+    readonly PHASE: "phase";
+    readonly EXPAND: "expand";
+    readonly SOLID: "solid";
+};
+export type EditorCursorBlinking = typeof EditorCursorBlinking[keyof typeof EditorCursorBlinking];
+export declare const EditorRenderWhitespace: {
+    readonly NONE: "none";
+    readonly BOUNDARY: "boundary";
+    readonly SELECTION: "selection";
+    readonly TRAILING: "trailing";
+    readonly ALL: "all";
+};
+export type EditorRenderWhitespace = typeof EditorRenderWhitespace[keyof typeof EditorRenderWhitespace];
+export declare const EditorFoldingControls: {
+    readonly ALWAYS: "always";
+    readonly NEVER: "never";
+    readonly MOUSEOVER: "mouseover";
+};
+export type EditorFoldingControls = typeof EditorFoldingControls[keyof typeof EditorFoldingControls];
+export declare const EditorMatchBrackets: {
+    readonly NEVER: "never";
+    readonly NEAR: "near";
+    readonly ALWAYS: "always";
+};
+export type EditorMatchBrackets = typeof EditorMatchBrackets[keyof typeof EditorMatchBrackets];
+export declare const EditorAutoIndent: {
+    readonly NONE: "none";
+    readonly KEEP: "keep";
+    readonly BRACKETS: "brackets";
+    readonly ADVANCED: "advanced";
+    readonly FULL: "full";
+};
+export type EditorAutoIndent = typeof EditorAutoIndent[keyof typeof EditorAutoIndent];
+export declare const EditorAcceptSuggestion: {
+    readonly ON: "on";
+    readonly OFF: "off";
+    readonly SMART: "smart";
+};
+export type EditorAcceptSuggestion = typeof EditorAcceptSuggestion[keyof typeof EditorAcceptSuggestion];
+/**
+ * Consumer-facing Monaco editor options. Use the DUI enum constants for
+ * value-based fields (e.g. EditorCursorStyle.BLOCK, EditorLineNumbers.RELATIVE).
+ * Ignored entirely while running in fallback mode (see EditorView.fallback.tsx).
+ *
+ * DUI always retains control of: contextmenu, automaticLayout, glyphMargin,
+ * fixedOverflowWidgets (structural internals — not overridable).
+ */
+export interface EditorOptions {
+    lineNumbers?: EditorLineNumbers;
+    /** Width reserved for line-number decorations, in px. Set 0 to remove the gutter entirely. */
+    lineDecorationsWidth?: number;
+    /** Minimum character width reserved for line numbers. */
+    lineNumbersMinChars?: number;
+    lineHeight?: number;
+    letterSpacing?: number;
+    rulers?: number[];
+    renderWhitespace?: EditorRenderWhitespace;
+    /**
+     * Current-line highlight style. Defaults to 'line' when glyphMargin is
+     * active (debugSupported with a breakpoint handler) and 'none' otherwise —
+     * pass explicitly to override either way.
+     */
+    renderLineHighlight?: 'none' | 'gutter' | 'line' | 'all';
+    /** Override the monospace font stack (defaults to Menlo/Monaco/Courier New). */
+    fontFamily?: string;
+    minimap?: boolean;
+    scrollBeyondLastLine?: boolean;
+    smoothScrolling?: boolean;
+    mouseWheelZoom?: boolean;
+    /** Scrollbar visibility + thickness. Defaults to 6px, always visible. */
+    scrollbar?: {
+        vertical?: 'auto' | 'visible' | 'hidden';
+        horizontal?: 'auto' | 'visible' | 'hidden';
+        verticalScrollbarSize?: number;
+        horizontalScrollbarSize?: number;
+    };
+    cursorStyle?: EditorCursorStyle;
+    cursorBlinking?: EditorCursorBlinking;
+    tabSize?: number;
+    wordWrap?: EditorWordWrap;
+    formatOnPaste?: boolean;
+    formatOnType?: boolean;
+    autoIndent?: EditorAutoIndent;
+    folding?: boolean;
+    showFoldingControls?: EditorFoldingControls;
+    matchBrackets?: EditorMatchBrackets;
+    bracketPairColorization?: boolean;
+    quickSuggestions?: boolean;
+    suggestOnTriggerCharacters?: boolean;
+    acceptSuggestionOnEnter?: EditorAcceptSuggestion;
+    parameterHints?: boolean;
+    hover?: boolean;
+    codeLens?: boolean;
+    inlayHints?: boolean;
+    /** Which suggestion-list sections to show. Merged over DUI's defaults (all true). */
+    suggest?: {
+        showKeywords?: boolean;
+        showSnippets?: boolean;
+        showValues?: boolean;
+        showProperties?: boolean;
+        showIcons?: boolean;
+    };
+    colorDecorators?: boolean;
+    linkedEditing?: boolean;
+    copyWithSyntaxHighlighting?: boolean;
+    padding?: {
+        top?: number;
+        bottom?: number;
+    };
+}
+export type EditorLanguage = 'javascript' | 'typescript' | 'json' | 'xml' | 'html' | 'css' | 'graphql' | 'python' | 'yaml' | 'sql' | 'plaintext' | 'markdown' | 'java';
+export interface EditorViewProps {
+    value: string;
+    onChange?: (value: string) => void;
+    language?: EditorLanguage;
+    height?: string | number;
+    minHeight?: number;
+    readOnly?: boolean;
+    /** Placeholder shown when value is empty */
+    placeholder?: string;
+    wordWrap?: boolean;
+    /**
+     * DUI size token — sets editor font size via EDITOR_FONT_SIZE scale (md=12, lg=13, xl=14…).
+     * Ignored when `fontSize` is provided explicitly.
+     */
+    size?: DuiSize;
+    /** Explicit font size in px — takes precedence over `size`. Defaults to 12 (md). */
+    fontSize?: number;
+    className?: string;
+    /** Adds a rounded border matching CodeEditor appearance */
+    bordered?: boolean;
+    /**
+     * Opt-in to full debug feature set: breakpoint gutter, variable hover,
+     * navigate-to-line from RunAndDebugPanel, dk/console completions.
+     * When false (default) none of these hooks or store subscriptions are active.
+     * No effect in fallback mode — breakpoints are a Monaco glyph-margin concept.
+     */
+    debugSupported?: boolean;
+    breakpoints?: number[];
+    disabledBreakpoints?: number[];
+    conditionalBreakpointLines?: number[];
+    /** Currently paused line — shows yellow highlight */
+    pausedLine?: number | null;
+    onToggleBreakpoint?: (line: number) => void;
+    onGlyphContextMenu?: (line: number, pos: {
+        x: number;
+        y: number;
+    }) => void;
+    /** Receives editor + monaco instances after mount (e.g. for AI autocomplete). Not called in fallback mode. */
+    onEditorMount?: (editor: any, monaco: any) => void;
+    /**
+     * Accent color for the Monaco scrollbar thumb. Accepts any CSS color value
+     * including CSS variables (e.g. `var(--color-protocol-soap)`). When omitted
+     * the global `--color-accent` is used automatically via CSS fallback.
+     */
+    accentColor?: string;
+    /**
+     * 'native' — use Monaco's built-in context menu (default).
+     * 'dui'    — suppress Monaco's menu and show DUI ContextMenuView instead.
+     *            Requires contextMenuItems to be provided.
+     */
+    contextMenuMode?: EditorContextMenuMode;
+    /**
+     * Items for the DUI ContextMenuView. Only used when contextMenuMode='dui'.
+     * Supports icons, colors, danger styling, separators, and infinite submenus.
+     */
+    contextMenuItems?: ContextMenuItem[];
+    /**
+     * Fine-grained Monaco editor options. Consumer values are merged over DUI
+     * defaults. Use the exported enum constants for value fields:
+     *   cursorStyle={EditorCursorStyle.BLOCK}
+     *   lineNumbers={EditorLineNumbers.RELATIVE}
+     * DUI always retains: contextmenu, automaticLayout, glyphMargin, fixedOverflowWidgets.
+     */
+    editorOptions?: EditorOptions;
+}
+export type { ContextMenuItem as EditorContextMenuItem } from '../modal/ContextMenuView';
+/**
+ * DUI's code editor. Renders the real Monaco-backed editor once the consumer
+ * has installed '@monaco-editor/react' + 'monaco-editor' and imported
+ * '@salilvnair/dui/monaco-setup' once at app bootstrap (self-hosted — no CDN;
+ * that subpath registers the Monaco implementation into monaco-runtime.ts).
+ * Until then, renders a lightweight plain-text fallback so '@salilvnair/dui'
+ * never requires Monaco as a hard dependency — this file has no reference to
+ * '@monaco-editor/react' or 'monaco-editor' anywhere in its module graph.
+ */
+export declare function EditorView(props: EditorViewProps): import("react").JSX.Element;

package/dist/lib/components/input/EditorView.fallback.d.ts

@@ -0,0 +1,10 @@
+import { EditorViewProps } from './EditorView';
+/**
+ * Plain-textarea stand-in for EditorView, used whenever Monaco isn't
+ * available (not installed, or '@salilvnair/dui/monaco-setup' was never
+ * imported). Deliberately minimal — no IntelliSense, no breakpoints, no
+ * folding, no format-on-save. Those are Monaco-specific concepts; anything
+ * that needs them should treat the fallback as a degraded, read/write-only
+ * text box rather than try to emulate Monaco's feature set.
+ */
+export declare function EditorViewFallback({ value, onChange, language, height, minHeight, readOnly, placeholder, wordWrap, size, fontSize, className, bordered, accentColor, }: EditorViewProps): import("react").JSX.Element;

package/dist/lib/components/input/EditorView.monaco.d.ts

@@ -0,0 +1,2 @@
+import { EditorViewProps } from './EditorView';
+export declare function EditorViewMonacoImpl({ debugSupported, className, ...rest }: EditorViewProps): import("react").JSX.Element;

package/dist/lib/components/input/EditorView.shell.d.ts

@@ -0,0 +1,13 @@
+import { ContextMenuItem } from '../modal/ContextMenuView';
+/**
+ * Shared render shell for both the Monaco-backed and fallback editor
+ * implementations — pure DUI chrome, no editor-engine dependency either way.
+ */
+export declare function EditorShell({ bordered, containerHeight, children, contextMenuMode, contextMenuItems, accentColor, }: {
+    bordered: boolean;
+    containerHeight: string;
+    children: React.ReactNode;
+    contextMenuMode?: 'native' | 'dui' | 'none';
+    contextMenuItems?: ContextMenuItem[];
+    accentColor?: string;
+}): import("react").JSX.Element;

package/dist/lib/components/input/FormDataTableView.d.ts

@@ -0,0 +1,22 @@
+export interface FormDataRow {
+    id: string;
+    key: string;
+    value: string;
+    type: 'text' | 'file';
+    enabled: boolean;
+    fileNames?: string[];
+    fileData?: string[];
+    fileMimeTypes?: string[];
+}
+export interface FormDataTableViewProps {
+    rows: FormDataRow[];
+    onChange: (rows: FormDataRow[]) => void;
+    /** Called when a file row's picker resolves. Pass undefined to handle file reads externally. */
+    onFileSelect?: (rowId: string, files: File[]) => void;
+    accentColor?: string;
+    label?: string;
+    hideToolbar?: boolean;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export declare function FormDataTableView({ rows, onChange, onFileSelect, accentColor, label, hideToolbar, className, style, }: FormDataTableViewProps): import("react").JSX.Element;

package/dist/lib/components/input/HiddenKeyValueItemView.d.ts

@@ -0,0 +1,22 @@
+export interface HiddenKeyValueItemViewProps {
+    keyValue: string;
+    value: string;
+    /** Small colored pill badge on the key — e.g. "auth", "cookie" */
+    badge?: string;
+    badgeColor?: string;
+    /** Override the left lock icon */
+    icon?: React.ReactNode;
+    /** Mask the value with dots; shows eye toggle to reveal */
+    masked?: boolean;
+    onDelete?: () => void;
+    deleteTitle?: string;
+    /** Show description column placeholder (for grid alignment with KeyValueItemView) */
+    showDescription?: boolean;
+    className?: string;
+}
+/**
+ * Read-only hidden/system-managed key-value row.
+ * Ditto the lock-icon + dashed-border pattern from ComputedHeaderList —
+ * "Hidden" is Postman's terminology; Daakia's visual style is kept.
+ */
+export declare function HiddenKeyValueItemView({ keyValue, value, badge, badgeColor, icon, masked, onDelete, deleteTitle, showDescription, className, }: HiddenKeyValueItemViewProps): import("react").JSX.Element;

package/dist/lib/components/input/HighlightedInputView.d.ts

@@ -0,0 +1,26 @@
+import { DuiSize } from '../../core/DuiTypes';
+export interface MockServerSuggestion {
+    url: string;
+    name: string;
+}
+export interface HighlightedInputViewProps {
+    value: string;
+    onChange: (value: string) => void;
+    onKeyDown?: (e: React.KeyboardEvent) => void;
+    onBlur?: () => void;
+    placeholder?: string;
+    suggestions?: string[];
+    /** Running mock server URLs — shown at the top with a server icon */
+    mockServers?: MockServerSuggestion[];
+    disabled?: boolean;
+    accentColor?: string;
+    /** Falls back to DuiProvider size when omitted. */
+    size?: DuiSize;
+    /** Raw height override in px — prefer `size` for token-aligned sizing. */
+    height?: number;
+    /** Border radius of the input in px (default 0 — matches URL bar; set 6 for standalone rounded usage) */
+    borderRadius?: number;
+    style?: React.CSSProperties;
+    className?: string;
+}
+export declare function HighlightedInputView({ value, onChange, onKeyDown, onBlur, placeholder, suggestions, mockServers, disabled, accentColor, size, height, borderRadius, style, className, }: HighlightedInputViewProps): import("react").JSX.Element;

package/dist/lib/components/input/KeyValueTableRowView.d.ts

@@ -0,0 +1,31 @@
+import { DuiSize } from '../../core/DuiTypes';
+export interface KeyValueTableRowViewProps {
+    rowKey: string;
+    value: string;
+    description?: string;
+    /** Enabled state. Pass undefined to hide the toggle (use with readOnly for pinned rows). */
+    enabled?: boolean;
+    /** Read-only pinned mode: lock icon, dashed border, no editing */
+    readOnly?: boolean;
+    /** Explicitly mask the value with an eye toggle */
+    masked?: boolean;
+    /** Auto-mask when rowKey matches SENSITIVE_HEADERS */
+    maskSensitive?: boolean;
+    /** Show trash icon on hover */
+    deletable?: boolean;
+    showDescription?: boolean;
+    placeholder?: {
+        key?: string;
+        value?: string;
+    };
+    /** HTTP header key/value autocomplete — editable mode only */
+    autocompleteKeys?: boolean;
+    size?: DuiSize;
+    accentColor?: string;
+    onKeyChange?: (val: string) => void;
+    onValueChange?: (val: string) => void;
+    onDescriptionChange?: (val: string) => void;
+    onEnabledChange?: (enabled: boolean) => void;
+    onRemove?: () => void;
+}
+export declare function KeyValueTableRowView({ rowKey, value, description, enabled, readOnly, masked, maskSensitive, deletable, showDescription, placeholder, autocompleteKeys, size, onKeyChange, onValueChange, onDescriptionChange, onEnabledChange, onRemove, }: KeyValueTableRowViewProps): import("react").JSX.Element;

package/dist/lib/components/input/KeyValueTableView.d.ts

@@ -0,0 +1,59 @@
+import { DuiSize } from '../../core/DuiTypes';
+export interface KeyValueTableRow {
+    id: string;
+    key: string;
+    value: string;
+    description?: string;
+    enabled: boolean;
+    type?: 'text' | 'file';
+    files?: string[];
+    filePaths?: string[];
+    fileData?: string[];
+    fileMimeTypes?: string[];
+    fileExists?: boolean[];
+}
+/** A computed/auto-generated row shown above editable rows — read-only, lock icon on left */
+export interface PinnedKeyValueRow {
+    id: string;
+    key: string;
+    value: string;
+    description?: string;
+    /** If true, a trash icon appears on hover and the row can be removed via onPinnedRemove */
+    deletable?: boolean;
+    /** If true (or auto-detected via SENSITIVE_HEADERS), value is masked with eye-toggle */
+    masked?: boolean;
+}
+export interface KeyValueTableViewProps {
+    rows: KeyValueTableRow[];
+    onChange: (rows: KeyValueTableRow[]) => void;
+    showDescription?: boolean;
+    placeholder?: {
+        key?: string;
+        value?: string;
+    };
+    className?: string;
+    /** Show HTTP header key autocomplete + value suggestions */
+    autocompleteKeys?: boolean;
+    /** Mask values for known sensitive keys (Authorization, token, etc.) */
+    maskSensitive?: boolean;
+    /** Hide the toolbar row entirely */
+    hideToolbar?: boolean;
+    /** Left-side label text */
+    label?: string;
+    /** Accent color for InsertRowDivider and toolbar highlights */
+    accentColor?: string;
+    /** Extra nodes rendered in toolbar right side (before trash icon) */
+    toolbarExtra?: React.ReactNode;
+    /** DUI size token — controls input height and font size. Falls back to DuiProvider or 'md'. */
+    size?: DuiSize;
+    /** Wrap in a rounded border panel */
+    bordered?: boolean;
+    /**
+     * Computed/auto-generated rows — shown as the first N rows with lock icon + dotted border.
+     * Hidden by default; revealed via the eye icon next to the label.
+     */
+    pinnedTopRows?: PinnedKeyValueRow[];
+    /** Called when a deletable pinned row is removed */
+    onPinnedRemove?: (id: string) => void;
+}
+export declare function KeyValueTableView({ rows, onChange, showDescription, placeholder, className, autocompleteKeys, maskSensitive, hideToolbar, label, accentColor, toolbarExtra, size, bordered, pinnedTopRows, onPinnedRemove, }: KeyValueTableViewProps): import("react").JSX.Element;

package/dist/lib/components/input/MergedInputView.d.ts

@@ -0,0 +1,43 @@
+import { DuiSize } from '../../core/DuiTypes';
+/** @deprecated Use `DuiSize` ('sm' | 'md' | 'lg' | 'xl') directly. */
+export type MergedInputSize = DuiSize;
+export interface MergedSelectOption {
+    value: string;
+    label: string;
+    color?: string;
+}
+export type MergedInputSegment = {
+    type: 'select';
+    value: string;
+    options: MergedSelectOption[];
+    onChange: (value: string) => void;
+    width?: number;
+} | {
+    type: 'text';
+    value: string;
+    onChange: (value: string) => void;
+    placeholder?: string;
+    flex?: number;
+} | {
+    type: 'button';
+    label: string;
+    onClick: () => void;
+    icon?: React.ReactNode;
+    accentColor?: string;
+} | {
+    type: 'divider';
+} | {
+    type: 'custom';
+    content: React.ReactNode;
+    width?: number;
+};
+export interface MergedInputViewProps {
+    segments: MergedInputSegment[];
+    /** Falls back to DuiProvider size when omitted. */
+    size?: DuiSize;
+    accentColor?: string;
+    disabled?: boolean;
+    className?: string;
+}
+export declare function MergeDivider(): import("react").JSX.Element;
+export declare function MergedInputView({ segments, size, accentColor, disabled, className, }: MergedInputViewProps): import("react").JSX.Element;

package/dist/lib/components/input/MultilineInputView.d.ts

@@ -0,0 +1,15 @@
+import { TextareaHTMLAttributes } from 'react';
+import { DuiSize, DuiRadius, DuiWidth } from '../../core/DuiTypes';
+export interface MultilineInputViewProps extends TextareaHTMLAttributes<HTMLTextAreaElement> {
+    size?: 'default' | DuiSize;
+    rounded?: boolean;
+    accentColor?: string;
+    error?: boolean;
+    /** Number of visible rows (default: 4) */
+    rows?: number;
+    /** Allow manual resize: 'none' | 'vertical' | 'both' (default: 'none') */
+    resize?: 'none' | 'vertical' | 'both';
+    width?: DuiWidth;
+    borderRadius?: DuiRadius | number;
+}
+export declare const MultilineInputView: import('react').ForwardRefExoticComponent<MultilineInputViewProps & import('react').RefAttributes<HTMLTextAreaElement>>;

package/dist/lib/components/input/SearchInputView.d.ts

@@ -0,0 +1,17 @@
+import { ReactNode, InputHTMLAttributes, CSSProperties } from 'react';
+import { DuiSize } from '../../core/DuiTypes';
+export interface SearchInputViewProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'onChange' | 'prefix' | 'size'> {
+    value: string;
+    onChange: (value: string) => void;
+    /** Node shown left inside the bar (e.g. SearchIcon) */
+    prefix?: ReactNode;
+    /** Node shown right inside the bar (e.g. clear button) */
+    suffix?: ReactNode;
+    /** Falls back to DuiProvider size when omitted. */
+    size?: DuiSize;
+    /** Raw height override in px — prefer `size` for token-aligned sizing. */
+    height?: number;
+    style?: CSSProperties;
+    className?: string;
+}
+export declare function SearchInputView({ value, onChange, prefix, suffix, placeholder, size, height, style, className, ...rest }: SearchInputViewProps): import("react").JSX.Element;

package/dist/lib/components/input/SegmentedControlView.d.ts

@@ -0,0 +1,23 @@
+import { ReactNode } from 'react';
+import { DuiSize } from '../../core/DuiTypes';
+export interface SegmentedControlOption {
+    value: string;
+    label: string;
+    icon?: ReactNode;
+    disabled?: boolean;
+}
+export interface SegmentedControlViewProps {
+    options: SegmentedControlOption[];
+    value: string;
+    onChange: (value: string) => void;
+    size?: DuiSize;
+    /** Accent color for the active segment indicator and text */
+    accentColor?: string;
+    /** Stretch to fill container width */
+    fullWidth?: boolean;
+}
+/**
+ * Segmented control with a sliding animated indicator.
+ * Active segment text color shifts to accentColor; inactive stays text-secondary.
+ */
+export declare function SegmentedControlView({ options, value, onChange, size, accentColor, fullWidth, }: SegmentedControlViewProps): import("react").JSX.Element;

package/dist/lib/components/input/SelectInputView.d.ts

@@ -0,0 +1,31 @@
+import { DuiSize, DuiRadius } from '../../core/DuiTypes';
+export interface SelectOption {
+    value: string;
+    label: string;
+    icon?: React.ReactNode;
+    color?: string;
+    isHeader?: boolean;
+    /** Colored pill chip rendered before the label — { label: 'TS', color: 'var(--color-primary)' } */
+    badge?: {
+        label: string;
+        color: string;
+    };
+}
+/** Backward-compatible size alias — accepts all DuiSize values plus legacy "default" (maps to "md"). */
+export type SelectInputSize = DuiSize | 'default';
+export interface SelectInputViewProps {
+    options: SelectOption[];
+    value: string;
+    onChange: (value: string) => void;
+    size?: SelectInputSize;
+    /** true = size-derived radius (default), false = 0px */
+    rounded?: boolean;
+    placeholder?: string;
+    accentColor?: string;
+    disabled?: boolean;
+    className?: string;
+    style?: React.CSSProperties;
+    width?: string | number;
+    borderRadius?: DuiRadius | number;
+}
+export declare function SelectInputView({ options, value, onChange, size, rounded, placeholder, accentColor, disabled, className, style, width, borderRadius, }: SelectInputViewProps): import("react").JSX.Element;

package/dist/lib/components/input/SelectTextInputView.d.ts

@@ -0,0 +1,44 @@
+import { DuiSize, DuiRadius, DuiWidth, DuiFontStyle } from '../../core/DuiTypes';
+export interface SelectTextOption {
+    value: string;
+    label: string;
+    /** Accent color for this option — e.g. HTTP methods */
+    color?: string;
+}
+/** Running mock server entry — shown at top of suggestions with server icon */
+export interface MockServerSuggestion {
+    url: string;
+    name: string;
+}
+export interface SelectTextInputViewProps {
+    selectValue: string;
+    selectOptions: SelectTextOption[];
+    onSelectChange: (value: string) => void;
+    inputValue: string;
+    onInputChange: (value: string) => void;
+    placeholder?: string;
+    /** Falls back to DuiProvider size when omitted. */
+    size?: DuiSize;
+    disabled?: boolean;
+    /** Accent border color on focus */
+    accentColor?: string;
+    /** Override the select section width in px */
+    selectWidth?: number;
+    /** URL / text autocomplete suggestions */
+    suggestions?: string[];
+    /** Running mock server URLs — shown at the top with a server icon */
+    mockServers?: MockServerSuggestion[];
+    /** Called when user picks a mock server entry (in addition to onInputChange) */
+    onMockServerSelect?: (url: string) => void;
+    onKeyDown?: (e: React.KeyboardEvent<HTMLInputElement>) => void;
+    /** Minimum width (px) for the suggestions dropdown — useful when the input is narrow */
+    suggestionMinWidth?: number;
+    /** z-index for the suggestions dropdown portal (default: 9998) */
+    suggestionZIndex?: number;
+    width?: DuiWidth;
+    borderRadius?: DuiRadius | number;
+    color?: string;
+    fontStyle?: DuiFontStyle;
+    className?: string;
+}
+export declare function SelectTextInputView({ selectValue, selectOptions, onSelectChange, inputValue, onInputChange, placeholder, size, disabled, accentColor, selectWidth, suggestions, mockServers, onMockServerSelect, onKeyDown, suggestionMinWidth, suggestionZIndex, width, borderRadius, color, fontStyle, className, }: SelectTextInputViewProps): import("react").JSX.Element;

package/dist/lib/components/input/SliderView.d.ts

@@ -0,0 +1,15 @@
+import { DuiSize } from '../../core/DuiTypes';
+export interface SliderViewProps {
+    value: number;
+    onChange: (value: number) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    disabled?: boolean;
+    size?: DuiSize;
+    accentColor?: string;
+    showValue?: boolean;
+    width?: number | string;
+    className?: string;
+}
+export declare function SliderView({ value, onChange, min, max, step, disabled, accentColor, showValue, width, className, }: SliderViewProps): import("react").JSX.Element;