@k2b/ui 0.1.0-rc.0 → 0.1.0

package/dist/types/content/calendar-event-layout.d.ts

@@ -0,0 +1,16 @@
+export type CalendarIntervalLayout<T> = {
+    item: T;
+    lane: number;
+    lanes: number;
+    groupId: number;
+    groupStart: number;
+    groupEnd: number;
+};
+/**
+ * Assigns the lowest available visual lane to overlapping intervals.
+ * Sorting plus two binary heaps keeps large overlap groups at O(n log n).
+ */
+export declare const layoutCalendarIntervals: <T>(items: readonly T[], bounds: (item: T) => {
+    start: number;
+    end: number;
+}) => CalendarIntervalLayout<T>[];

package/dist/types/content/calendar-pointer.d.ts

@@ -0,0 +1,22 @@
+export declare const CALENDAR_SNAP_MINUTES = 15;
+export declare const snapCalendarMinutes: (minutes: number, step?: number) => number;
+export declare const calendarDayIndexAtPoint: (clientX: number, startX: number, width: number, days: number) => number | null;
+export declare const calendarMinuteAtPoint: (clientY: number, top: number, height: number, startHour: number, endHour: number) => number;
+export declare const calendarAutoScrollSpeed: (clientY: number, top: number, bottom: number, edge?: number, maximum?: number) => number;
+type CalendarPointerSessionOptions<T> = {
+    event: PointerEvent;
+    resolve: (clientX: number, clientY: number) => T | null;
+    onActivate?: () => void;
+    onPreview: (value: T) => void;
+    onCommit: (value: T) => void;
+    onCancel?: () => void;
+    scrollContainer?: HTMLElement;
+    threshold?: number;
+};
+/**
+ * Owns one pointer gesture from threshold crossing through commit or cancel.
+ * Views provide geometry through `resolve`; this helper owns global cleanup,
+ * pointer cancellation, Escape handling, and edge auto-scroll.
+ */
+export declare const startCalendarPointerSession: <T>(options: CalendarPointerSessionOptions<T>) => (() => void);
+export {};

package/dist/types/content/chart-map-viewport.d.ts

@@ -0,0 +1,5 @@
+import type { MapViewport } from "@k2b/stdlib";
+export declare const DEFAULT_MAP_VIEWPORT: MapViewport;
+export declare const normalizeMapViewport: (viewport: MapViewport | undefined) => MapViewport;
+export declare const zoomMapViewport: (viewport: MapViewport, delta: number) => MapViewport;
+export declare const panMapViewport: (viewport: MapViewport, deltaX: number, deltaY: number, width: number, height: number) => MapViewport;

package/dist/types/content/chart-state-timeline.d.ts

@@ -0,0 +1,42 @@
+export type StateTimelineDomain = readonly [number, number];
+export type StateTimelineInterval = {
+    from: number;
+    to: number;
+    state: string;
+    label?: string;
+    href?: string;
+    tooltip?: string;
+};
+export type StateTimelineRow = {
+    label: string;
+    href?: string;
+    tooltip?: string;
+    intervals: StateTimelineInterval[];
+};
+export type StateTimelineState = {
+    state: string;
+    label?: string;
+    color?: string;
+};
+export type StateTimelineChartOptions = {
+    rows: StateTimelineRow[];
+    states?: StateTimelineState[];
+    domain?: StateTimelineDomain;
+    xAxis?: {
+        format?: (value: number) => string;
+        label?: string;
+    };
+    legend?: boolean;
+    interactive?: boolean;
+};
+export declare const stateTimelineDomain: (rows: readonly StateTimelineRow[], domain?: StateTimelineDomain) => StateTimelineDomain;
+export declare const normalizeStateTimelineViewport: (viewport: StateTimelineDomain | undefined, fullDomain: StateTimelineDomain) => StateTimelineDomain;
+export declare const zoomStateTimelineViewport: (viewport: StateTimelineDomain, fullDomain: StateTimelineDomain, delta: number, anchor?: number) => StateTimelineDomain;
+export declare const panStateTimelineViewport: (viewport: StateTimelineDomain, fullDomain: StateTimelineDomain, pixelDelta: number, plotWidth: number) => StateTimelineDomain;
+export declare const stateTimelineHeight: (rows: number, legend?: boolean) => number;
+export declare const renderStateTimelineSvg: (opts: StateTimelineChartOptions & {
+    width: number;
+    height: number;
+    viewport?: StateTimelineDomain;
+    className?: string;
+}) => string;

package/dist/types/content/code-highlight.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Small safe highlighters for CodeDisplay.
+ *
+ * These are display-only highlighters: no AST, no runtime parser, no
+ * dependency. Every input character is HTML-escaped before being wrapped
+ * in token spans, so the returned strings are safe to inject with
+ * `innerHTML`.
+ */
+export type CodeDisplayLanguage = "ts" | "tsx" | "js" | "jsx" | "script" | "markdown" | "md" | "text";
+export declare const escapeCodeHtml: (s: string) => string;
+export declare const highlightCode: (code: string) => string;
+export declare const highlightMarkdownDisplay: (code: string) => string;
+export declare const highlightCodeDisplayLines: (code: string, language?: CodeDisplayLanguage) => string[];
+export declare const highlightCodeDisplay: (code: string, language?: CodeDisplayLanguage) => string;

package/dist/types/content/file-tree.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Tree shaping for FileTree — flat paths in, sorted nodes out.
+ *
+ * Kept beside the component rather than inside it because it is pure: no JSX,
+ * no reactivity, nothing that needs a DOM. That is also what makes it testable
+ * — a test importing the .tsx pulls the whole component through Bun's JSX
+ * transform, which resolves against the root tsconfig and lands on the React
+ * runtime. Same reason `file-view-preview.ts` sits next to FileView.
+ */
+export type FileTreeEntry = {
+    /** Canonical identity, e.g. "/input/report.csv". */
+    path: string;
+    /** Folders are usually implicit from paths — explicit entries model empty dirs. */
+    kind?: "file" | "folder";
+    size?: number;
+    mediaType?: string;
+    updatedAt?: string;
+    /** Icon override (tabler class without "ti " prefix); default derives from the name. */
+    icon?: string;
+    /** Small trailing badge, e.g. "ro" on read-only mounts. */
+    badge?: string;
+};
+export type TreeNode = {
+    entry: FileTreeEntry;
+    name: string;
+    depth: number;
+    isFolder: boolean;
+    children: TreeNode[];
+};
+/** Containing directory of a path; "/" for top-level entries. */
+export declare const parentOf: (path: string) => string;
+/**
+ * Flat paths → sorted tree (folders first, then files, both alphabetical).
+ *
+ * Passing the previous tree preserves object identity by path while updating
+ * the cached node in place. Solid's keyed `<For>` can then keep rows, rename
+ * inputs, and focus alive even when a refetch changes metadata.
+ */
+export declare const buildTree: (entries: FileTreeEntry[], previous?: TreeNode[]) => TreeNode[];
+export declare const flattenVisible: (nodes: TreeNode[], expanded: Set<string>) => TreeNode[];
+export declare const allFolderPaths: (nodes: TreeNode[]) => string[];

package/dist/types/content/file-view-preview.d.ts

@@ -0,0 +1,22 @@
+export type FileViewFile = {
+    path: string;
+    mediaType?: string;
+    size?: number;
+};
+export type FileViewPreviewKind = "markdown" | "image" | "pdf" | "json" | "delimited-text" | "audio" | "video" | "text";
+export declare const fileViewExtension: (path: string) => string;
+/**
+ * Returns the built-in preview kind when FileView can render the file within
+ * its bounded client-side limits. Custom renderers remain registry-driven.
+ */
+export declare const getFileViewPreviewKind: (file: FileViewFile) => FileViewPreviewKind | null;
+/** Use this to expose preview actions only for files FileView can render. */
+export declare const canPreviewFile: (file: FileViewFile) => boolean;
+export type DelimitedTextPreview = {
+    rows: string[][];
+    truncated: boolean;
+};
+export declare const parseDelimitedText: (input: string, delimiter: "," | "\t", limits?: {
+    rows?: number;
+    columns?: number;
+}) => DelimitedTextPreview;

package/dist/types/content/index.d.ts

@@ -0,0 +1,26 @@
+export type { CalendarAttendee, CalendarDayBadge, CalendarEvent, CalendarEventColor, CalendarEventRenderContext, CalendarEventTimeChange, CalendarLabels, CalendarProps, CalendarRecurrence, CalendarResource, CalendarView, } from "./Calendar";
+export { default as Calendar } from "./Calendar";
+export type { ChartKind, ChartLabels, ChartProps } from "./Chart";
+export { default as Chart } from "./Chart";
+export type { CodeDisplayLanguage, CodeDisplayProps } from "./CodeDisplay";
+export { default as CodeDisplay } from "./CodeDisplay";
+export type { StateTimelineChartOptions, StateTimelineDomain, StateTimelineInterval, StateTimelineRow, StateTimelineState, } from "./chart-state-timeline";
+export type { DataTableColumn, DataTableControlsProps, DataTableFooter, DataTableHeaderProps, DataTablePanelFooterProps, DataTablePanelProps, DataTableProps, DataTableRenderCell, DataTableRenderHeader, DataTableSort, } from "./DataTable";
+export { default as DataTable } from "./DataTable";
+export type { DocCodeHighlighter, DocCodeProps, DocConcept, DocNoteVariant, DocRow } from "./Docs";
+export { DocCode, DocConceptGrid, DocInlineCode, DocLead, DocNote, DocPage, DocRows, DocSection } from "./Docs";
+export { FileBrowserPanel, type FileBrowserPanelProps, type FileSource, openFileBrowser } from "./FileBrowser";
+export { default as FileTree, type FileTreeActions, type FileTreeEntry, type FileTreeProps } from "./FileTree";
+export { canPreviewFile, default as FileView, type FileViewContent, type FileViewFile, type FileViewPreviewKind, type FileViewProps, type FileViewRenderer, type FileViewRendererProps, formatFileViewSize, getFileViewPreviewKind, } from "./FileView";
+export type { LightboxImage } from "./Lightbox";
+export { default as Lightbox } from "./Lightbox";
+export type { LogTableEntry } from "./LogEntriesTable";
+export { default as LogEntriesTable } from "./LogEntriesTable";
+export { default as MarkdownView, renderSafeMarkdown, type MarkdownRenderOptions, type MarkdownViewProps } from "./MarkdownView";
+export { Pagination, type PaginationProps } from "./Pagination";
+export type { PdfPreviewProps, PdfPreviewRequest } from "./PdfPreview";
+export { default as PdfPreview } from "./PdfPreview";
+export type { RangeOption, RangePickerProps } from "./RangePicker";
+export { default as RangePicker } from "./RangePicker";
+export type { StructuredDataPreviewMode, StructuredDataPreviewProps, StructuredDataValue } from "./StructuredDataPreview";
+export { default as StructuredDataPreview, isStructuredDataValue } from "./StructuredDataPreview";

package/dist/types/feedback/InlineGuidance.d.ts

@@ -0,0 +1,10 @@
+import { type JSX } from "solid-js";
+import type { IntentTone } from "../semantics";
+export type InlineGuidanceProps = Omit<JSX.HTMLAttributes<HTMLDivElement>, "children" | "class"> & {
+    children: JSX.Element;
+    tone?: IntentTone;
+    icon?: string | false;
+    class?: string;
+};
+export declare function InlineGuidance(props: InlineGuidanceProps): JSX.Element;
+export default InlineGuidance;

package/dist/types/feedback/Tooltip.d.ts

@@ -0,0 +1,18 @@
+import { type JSX } from "solid-js";
+import { type TooltipPlacement } from "./tooltip-position";
+export type TooltipProps = {
+    content: JSX.Element;
+    target: () => HTMLElement | undefined;
+    placement?: TooltipPlacement;
+    delay?: number;
+    disabled?: boolean;
+};
+export type TooltipAnchorProps = Omit<JSX.HTMLAttributes<HTMLSpanElement>, "content"> & Omit<TooltipProps, "target">;
+export type TooltipTriggerProps = Omit<JSX.ButtonHTMLAttributes<HTMLButtonElement>, "content"> & Omit<TooltipProps, "target">;
+type TooltipComponent = ((props: TooltipProps) => JSX.Element) & {
+    Anchor: (props: TooltipAnchorProps) => JSX.Element;
+    Trigger: (props: TooltipTriggerProps) => JSX.Element;
+};
+export declare const Tooltip: TooltipComponent;
+export type { TooltipPlacement } from "./tooltip-position";
+export default Tooltip;

package/dist/types/feedback/dialog-core.d.ts

@@ -0,0 +1,19 @@
+import type { JSX } from "solid-js";
+export type DialogClose<T> = (result?: T) => void;
+export type OpenDialogOptions = {
+    panelClassName?: string;
+    contentClassName?: string;
+    initialFocus?: "first-input" | "none" | ((dialog: HTMLDialogElement) => HTMLElement | null);
+    cancelBehavior?: "resolve-undefined" | "ignore";
+    ariaLabel?: string;
+};
+export type DialogRender<T> = (close: DialogClose<T>, context: {
+    dialog: HTMLDialogElement;
+}) => JSX.Element;
+export type DialogCore = {
+    open: <T>(view: DialogRender<T>, options?: OpenDialogOptions) => Promise<T | undefined>;
+    close: (result?: unknown) => void;
+    isOpen: () => boolean;
+};
+export declare const createDialogCore: () => DialogCore;
+export declare const dialogCore: DialogCore;

package/dist/types/feedback/index.d.ts

@@ -0,0 +1,10 @@
+export type { DialogClose, DialogCore, DialogRender, OpenDialogOptions } from "./dialog-core";
+export { dialogCore } from "./dialog-core";
+export type { InlineGuidanceProps } from "./InlineGuidance";
+export { default as InlineGuidance } from "./InlineGuidance";
+export type { ConfirmOptions, DialogOptions, FieldSchema, PromptFieldBase, PromptSearchInput, PromptSearchItem, PromptSearchOptions, } from "./prompts";
+export { createFormState, DialogHeader, prompts } from "./prompts";
+export type { TooltipAnchorProps, TooltipPlacement, TooltipProps, TooltipTriggerProps } from "./Tooltip";
+export { Tooltip } from "./Tooltip";
+export type { ToastAction, ToastFn, ToastHandle, ToastOptions, ToastVariant } from "./toast";
+export { isPointInsideToast, toast } from "./toast";

package/dist/types/feedback/prompts.d.ts

@@ -0,0 +1,164 @@
+import { type JSX } from "solid-js";
+import { type OpenDialogOptions } from "./dialog-core";
+export interface DialogOptions {
+    title?: string;
+    ariaLabel?: string;
+    icon?: string;
+    confirmText?: string;
+    cancelText?: string | false;
+    variant?: "danger" | "primary" | "success";
+    size?: "small" | "medium" | "large" | "wide";
+    surface?: "default" | "bare";
+    header?: false;
+    cancelBehavior?: OpenDialogOptions["cancelBehavior"];
+}
+export interface ConfirmOptions extends DialogOptions {
+    confirmationPhrase?: string;
+}
+type PromptContent = string | HTMLElement | JSX.Element;
+export type PromptSearchItem<T = unknown> = {
+    label: string;
+    desc?: string;
+    icon?: string;
+    previewUrl?: string;
+    value?: T;
+};
+export type PromptSearchInput = {
+    query: string;
+    abortSignal: AbortSignal;
+};
+export type PromptSearchOptions = DialogOptions & {
+    placeholder?: string;
+    icon?: string;
+    initialQuery?: string;
+    minQueryLength?: number;
+    debounceMs?: number;
+    emptyText?: string;
+    noResultsText?: string;
+};
+export type PromptFieldBase<T = any> = {
+    label?: string | false;
+    description?: string;
+    placeholder?: string;
+    required?: boolean;
+    default?: T;
+    validate?: (value: T | undefined) => string | null;
+};
+export type FieldSchema = (PromptFieldBase<string> & {
+    type: "text";
+    multiline?: boolean;
+    lines?: number;
+    maxLength?: number;
+    minLength?: number;
+    icon?: string;
+    activeIcon?: string;
+    password?: boolean;
+    markdown?: boolean;
+}) | (PromptFieldBase<number> & {
+    type: "number";
+    min?: number;
+    max?: number;
+    step?: number;
+}) | (PromptFieldBase<string> & {
+    type: "image";
+    round?: boolean;
+    ariaLabel?: string;
+    accept?: string;
+}) | (PromptFieldBase<string> & {
+    type: "pin";
+    length?: number;
+    stretch?: boolean;
+}) | (PromptFieldBase<string> & {
+    type: "select";
+    options: string[] | {
+        id: string;
+        label?: string;
+        description?: string;
+        icon?: string;
+    }[];
+    icon?: string;
+    activeIcon?: string;
+    clearable?: boolean;
+}) | (PromptFieldBase<string[]> & {
+    type: "tags";
+    maxTags?: number;
+    minTags?: number;
+    icon?: string;
+    activeIcon?: string;
+}) | (PromptFieldBase<boolean> & {
+    type: "boolean";
+}) | (PromptFieldBase<string> & {
+    type: "datetime";
+    dateOnly?: boolean;
+}) | {
+    type: "info";
+    content: string | JSX.Element | (() => JSX.Element);
+};
+type InferFieldType<T extends FieldSchema> = T extends {
+    type: "text";
+} ? string : T extends {
+    type: "number";
+} ? number : T extends {
+    type: "image";
+} ? string : T extends {
+    type: "pin";
+} ? string : T extends {
+    type: "select";
+} ? string : T extends {
+    type: "tags";
+} ? string[] : T extends {
+    type: "boolean";
+} ? boolean : T extends {
+    type: "datetime";
+} ? string : T extends {
+    type: "currency";
+} ? number : T extends {
+    type: "info";
+} ? never : never;
+type InferFormValues<T extends Record<string, FieldSchema>> = {
+    [K in keyof T as T[K] extends {
+        type: "info";
+    } ? never : K]: T[K] extends {
+        required: true;
+    } ? InferFieldType<T[K]> : InferFieldType<T[K]> | undefined;
+};
+type PromptFormValue = string | number | boolean | string[] | undefined;
+type PromptFormOptions<T extends Record<string, FieldSchema>> = {
+    title?: string;
+    ariaLabel?: string;
+    icon?: string;
+    fields: T;
+    confirmText?: string;
+    cancelText?: string | false;
+    variant?: "danger" | "primary" | "success";
+    size?: DialogOptions["size"];
+    cancelBehavior?: DialogOptions["cancelBehavior"];
+};
+export declare const createFormState: <T extends Record<string, FieldSchema>>(schema: T) => {
+    values: Record<string, PromptFormValue>;
+    errors: Record<string, string | undefined>;
+    updateField: (key: string, value: PromptFormValue) => void;
+    validateAll: () => boolean;
+    reset: () => void;
+};
+export declare const DialogHeader: (props: {
+    close: () => void;
+    title?: string;
+    icon?: string;
+}) => JSX.Element;
+type CloudSearchResolver<T> = (input: PromptSearchInput) => Promise<PromptSearchItem<T>[]> | PromptSearchItem<T>[];
+export declare const prompts: {
+    alert: (content: PromptContent, options?: DialogOptions) => Promise<void | undefined>;
+    success: (content: PromptContent, options?: Omit<DialogOptions, "variant">) => Promise<void | undefined>;
+    confirm: (content: PromptContent, options?: ConfirmOptions) => Promise<boolean | undefined>;
+    prompt: (content: string, defaultValue?: string, options?: DialogOptions) => Promise<string | null>;
+    promptNumber: (content: string, defaultValue?: number, options?: DialogOptions & {
+        min?: number;
+        max?: number;
+    }) => Promise<number | null>;
+    form: <T extends Record<string, FieldSchema>>(config: PromptFormOptions<T>) => Promise<InferFormValues<T> | null>;
+    dialog: <T = unknown>(component: (close: (result?: T) => void) => JSX.Element, options?: DialogOptions) => Promise<T | undefined>;
+    search: <T = unknown>(resolver: CloudSearchResolver<T>, options?: PromptSearchOptions) => Promise<PromptSearchItem<T> | undefined>;
+    error: (content: string | HTMLElement, options?: DialogOptions) => Promise<unknown>;
+};
+export {};

package/dist/types/feedback/toast.d.ts

@@ -0,0 +1,25 @@
+export type ToastVariant = "default" | "success" | "error";
+export type ToastAction = {
+    label: string;
+    href: string;
+};
+export type ToastOptions = {
+    variant?: ToastVariant;
+    duration?: number;
+    iconClass?: string;
+    title?: string;
+    action?: ToastAction | null;
+};
+export type ToastHandle = {
+    dismiss: () => void;
+    update: (description: string, options?: ToastOptions) => void;
+};
+export interface ToastFn {
+    (description: string, options?: ToastOptions): ToastHandle;
+    success: (description: string, options?: Omit<ToastOptions, "variant">) => ToastHandle;
+    error: (description: string, options?: Omit<ToastOptions, "variant">) => ToastHandle;
+    dismissAll: () => void;
+}
+export declare const K2B_TOAST_CONTAINER_ID = "k2b-ui-toast-container";
+export declare const isPointInsideToast: (x: number, y: number) => boolean;
+export declare const toast: ToastFn;

package/dist/types/feedback/tooltip-position.d.ts

@@ -0,0 +1,2 @@
+export type TooltipPlacement = "top" | "bottom";
+export declare const positionTooltipSurface: (tooltip: HTMLElement, target: HTMLElement, placement?: TooltipPlacement) => void;

package/dist/types/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./actions";
+export * from "./chat";
+export * from "./content";
+export * from "./feedback";
+export * from "./inputs";
+export * from "./intl";
+export * from "./layout";
+export type { AccentColor, IntentTone } from "./semantics";
+export * from "./surfaces";
+export * from "./widgets";

package/dist/types/inputs/AutocompleteEditor.d.ts

@@ -0,0 +1,21 @@
+import { type JSX } from "solid-js";
+import { type Completion } from "./completion";
+import type { ValueFieldProps } from "./field-contract";
+export type AutocompleteEditorProps = ValueFieldProps<string> & {
+    onSubmit?: () => void;
+    completions?: readonly Completion[];
+    restoreExpansionOnBackspace?: boolean;
+    highlight?: (text: string) => string;
+    singleLine?: boolean;
+    lines?: number;
+    fill?: boolean;
+    placeholder?: string;
+    spellcheck?: boolean;
+    name?: string;
+    maxLength?: number;
+    textareaRef?: (element: HTMLTextAreaElement) => void;
+    variant?: "default" | "paper";
+};
+export declare function AutocompleteEditor(props: AutocompleteEditorProps): JSX.Element;
+export type { Completion, SuggestContext, Suggestion } from "./completion";
+export { abbreviations } from "./completion";

package/dist/types/inputs/AutocompleteSelect.d.ts

@@ -0,0 +1,30 @@
+import { type JSX } from "solid-js";
+import { type ChoiceOption } from "./choice";
+import type { ValueFieldProps } from "./field-contract";
+import type { SelectGroup } from "./Select";
+export type AutocompleteSelectOption = ChoiceOption<string>;
+export type AutocompleteSelectSearchResult = {
+    /** Ranked suggestions shown in the popup. */
+    options: readonly AutocompleteSelectOption[];
+    /** The authoritative option that Tab or blur may accept automatically. */
+    match?: AutocompleteSelectOption;
+};
+export type AutocompleteSelectProps = ValueFieldProps<string | null> & {
+    search: (query: string, signal: AbortSignal, group: string | null) => Promise<AutocompleteSelectSearchResult>;
+    selectedOption?: AutocompleteSelectOption;
+    formatValue?: (option: AutocompleteSelectOption) => string;
+    groups?: readonly SelectGroup[];
+    defaultGroup?: string;
+    groupsAriaLabel?: string;
+    allGroupLabel?: string;
+    placeholder?: string;
+    debounceMs?: number;
+    clearable?: boolean;
+    name?: string;
+    autofocus?: boolean;
+    noMatchText?: string;
+    checkingText?: string;
+    noOptionsText?: string;
+};
+export declare function AutocompleteSelect(props: AutocompleteSelectProps): JSX.Element;
+export default AutocompleteSelect;

package/dist/types/inputs/Checkbox.d.ts

@@ -0,0 +1,9 @@
+import { type JSX } from "solid-js";
+import type { ValueFieldProps } from "./field-contract";
+export type CheckboxProps = ValueFieldProps<boolean> & {
+    /** Visual and accessible mixed state for partial bulk selections. */
+    indeterminate?: boolean;
+    name?: string;
+};
+export declare function Checkbox(props: CheckboxProps): JSX.Element;
+export default Checkbox;

package/dist/types/inputs/CheckboxCard.d.ts

@@ -0,0 +1,9 @@
+import { type JSX } from "solid-js";
+import type { ValueFieldProps } from "./field-contract";
+export type CheckboxCardProps = Omit<JSX.InputHTMLAttributes<HTMLInputElement>, "checked" | "onChange" | "type" | "value" | keyof ValueFieldProps<boolean>> & ValueFieldProps<boolean> & {
+    icon?: string;
+    color?: string;
+    variant?: "card" | "input";
+};
+export declare function CheckboxCard(props: CheckboxCardProps): JSX.Element;
+export default CheckboxCard;

package/dist/types/inputs/ChoiceGroups.d.ts

@@ -0,0 +1,13 @@
+import { type JSX } from "solid-js";
+type ChoiceGroup = {
+    value: string | null;
+    label: string;
+};
+export declare function ChoiceGroups(props: {
+    choices: readonly ChoiceGroup[];
+    value: string | null;
+    onValueChange: (value: string | null) => void;
+    ariaLabel: string;
+    controls: string;
+}): JSX.Element;
+export {};

package/dist/types/inputs/ChoiceInputs.d.ts

@@ -0,0 +1,24 @@
+import { type JSX } from "solid-js";
+import type { FieldProps, MaybeAccessor, ValueFieldProps } from "./field-contract";
+export type PinInputProps = ValueFieldProps<string> & {
+    length?: number;
+    name?: string;
+    stretch?: boolean;
+};
+export declare function PinInput(props: PinInputProps): JSX.Element;
+export type SliderProps = FieldProps & Omit<JSX.InputHTMLAttributes<HTMLInputElement>, "type" | "value" | "onInput" | "onChange" | keyof FieldProps> & ValueFieldProps<number> & {
+    value: MaybeAccessor<number>;
+    formatValue?: (value: number) => string;
+    showValue?: boolean;
+    center?: boolean;
+    defaultValue?: number;
+};
+export declare function Slider(props: SliderProps): JSX.Element;
+export type ColorInputProps = ValueFieldProps<string> & {
+    name?: string;
+    compact?: boolean;
+    transparent?: boolean;
+    transparentValue?: MaybeAccessor<boolean>;
+    onTransparentValueChange?: (value: boolean) => void;
+};
+export declare function ColorInput(props: ColorInputProps): JSX.Element;

package/dist/types/inputs/Combobox.d.ts

@@ -0,0 +1,18 @@
+import { type JSX } from "solid-js";
+import type { FieldProps, MaybeAccessor } from "./field-contract";
+export type ComboboxOption = {
+    id: string;
+    label: string;
+    description?: string;
+    icon?: string;
+};
+export type ComboboxProps = FieldProps & {
+    query?: MaybeAccessor<string>;
+    onQueryChange?: (query: string) => void;
+    placeholder?: string;
+    fetchData: (query: string, signal: AbortSignal) => Promise<ComboboxOption[]>;
+    onSelect: (option: ComboboxOption) => void;
+    debounceMs?: number;
+};
+export declare function Combobox(props: ComboboxProps): JSX.Element;
+export default Combobox;

package/dist/types/inputs/DatePicker.d.ts

@@ -0,0 +1,31 @@
+import { type DateContext } from "@k2b/stdlib";
+import { type JSX } from "solid-js";
+import { type DateRangeValue } from "./date-picker";
+import type { MaybeAccessor, ValueFieldProps } from "./field-contract";
+export type { DateRangeValue } from "./date-picker";
+export type DatePreset<T> = {
+    label: string;
+    value: T;
+};
+export type DurationPreset = {
+    label: string;
+    minutes: number;
+};
+export type DatePickerBaseProps<T> = Omit<ValueFieldProps<T>, "value"> & {
+    placeholder?: string;
+    value: MaybeAccessor<T>;
+    presets?: readonly DatePreset<T>[];
+    dateConfig?: DateContext;
+    clearable?: boolean;
+};
+export type DatePickerProps = DatePickerBaseProps<string | null>;
+export type DateTimePickerProps = DatePickerBaseProps<string | null>;
+export type DateRangePickerProps = DatePickerBaseProps<DateRangeValue> & {
+    withTime?: boolean;
+    datePresets?: readonly DatePreset<string | null>[];
+    durationPresets?: readonly DurationPreset[];
+};
+export declare const placeDatePopover: (trigger: HTMLElement, popover: HTMLElement, wide: boolean) => void;
+export declare function DatePicker(props: DatePickerProps): JSX.Element;
+export declare function DateTimePicker(props: DateTimePickerProps): JSX.Element;
+export declare function DateRangePicker(props: DateRangePickerProps): JSX.Element;