@octane-xplat/ui 0.9.0 → 0.11.0

package/types/generated/bottom-sheet-context.d.ts

@@ -0,0 +1,24 @@
+import type { BottomSheetProps } from './props.js';
+/** One `BottomSheet` child's registration inside a `BottomSheetSwitcher`.
+ *  `props` carries the whole prop bag so the switcher's single host can
+ *  render the active panel verbatim (children are descriptor data — safe
+ *  to hand across the overlay root boundary on native). */
+export interface BottomSheetRegistration {
+    sheetId: string;
+    props: BottomSheetProps;
+}
+/** The switcher handle BottomSheet children consume. Registrations flow
+ *  through the store so the switcher's overlay root (a separate Octane
+ *  root on native) observes them without context crossing roots. */
+export interface BottomSheetSwitcherHandle {
+    register(spec: BottomSheetRegistration): void;
+    unregister(sheetId: string): void;
+    /** Report a user dismissal (drag/scrim/Escape) to the switcher. */
+    requestDismiss(): void;
+    /** The sheetId the switcher is currently showing. */
+    activeSheet(): string | null;
+}
+export declare const BottomSheetSwitcherContext: import("octane").Context<BottomSheetSwitcherHandle | null>;
+/** JSX-provider form — universal-renderer contexts are callables, not
+ *  `.Provider` members (same aliasing as FieldProvider/DialogProvider). */
+export declare const BottomSheetSwitcherProvider: any;

package/types/generated/bottom-sheet-panel.macos.d.ts

@@ -0,0 +1,7 @@
+/**  Imperative content gets the same handle, scrolling and live theme as a
+ * declaration. Context stays inside this detached root. */
+export declare function ImperativeSheetPanel(props: {
+    component: any;
+    params: any;
+    close: (result?: any) => void;
+}): unknown;

package/types/generated/bottom-sheet-service.d.ts

@@ -0,0 +1,13 @@
+import { GridLayout } from '@nativescript/core';
+import type { ModalOpenResult, OpenBottomSheet } from './props.js';
+/** The most recently opened sheet's host view — for harness asserts (view
+ *  identity beats tree search; the owning rootlayout may unload/reload). */
+export declare function bottomSheetHost(): GridLayout | null;
+/** Close the most recently opened bottom sheet (resolve with `result`). */
+export declare function closeBottomSheet(result?: ModalOpenResult): void;
+/** Imperative in-window bottom sheet: a dedicated Octane root on a
+ *  bottom-docked GridLayout host opened on the CURRENT rootlayout
+ *  (topRootLayout — the service has no declaring view). Resolves when the
+ *  sheet closes. Astryx `snapPoints` fractions/percent/px all resolve
+ *  against the screen height. */
+export declare const openBottomSheet: OpenBottomSheet;

package/types/generated/bottom-sheet-service.macos.d.ts

@@ -0,0 +1,5 @@
+import type { ModalOpenResult, OpenBottomSheet } from './props.js';
+export declare function closeBottomSheet(result?: ModalOpenResult): void;
+/** Dedicated root in the key window's bottom-docked AppKit surface. */
+export declare const openBottomSheet: OpenBottomSheet;
+export declare function bottomSheetHost(): null;

package/types/generated/bottom-sheet-service.web.d.ts

@@ -0,0 +1,7 @@
+import type { ModalOpenResult, OpenBottomSheet } from './props.js';
+/** Close the most recently opened bottom sheet (resolve with `result`). */
+export declare function closeBottomSheet(result?: ModalOpenResult): void;
+/** Imperative in-window bottom sheet: portal layer at document root,
+ *  bottom-anchored panel, dedicated Octane root, grabber + snap/swipe
+ *  gestures. Resolves when the sheet closes. */
+export declare const openBottomSheet: OpenBottomSheet;

package/types/generated/busy-lane.d.ts

@@ -0,0 +1,15 @@
+/** How BaseTypeahead hands its busy state to a wrapper that owns the
+ *  inline-end lane (Typeahead/Tokenizer paint the spinner beside their own
+ *  controls instead of a second indicator inside the base). A store rather
+ *  than wrapper state so a search transition re-renders only the leaf that
+ *  draws the Spinner. This is a context, not a prop, because the wiring is
+ *  package-internal — anything on the public props becomes API. */
+export interface BusyIndicatorLane {
+    onBusyChange: (isBusy: boolean) => void;
+    subscribe: (onStoreChange: () => void) => () => void;
+    getIsBusy: () => boolean;
+}
+export declare function createBusyIndicatorLane(): BusyIndicatorLane;
+/** The wrapper's lane, or null when the base renders its own indicator. */
+export declare const BusyLaneContext: import("octane").Context<BusyIndicatorLane | null>;
+export declare const BusyLaneProvider: any;

package/types/generated/button-group-context.d.ts

@@ -0,0 +1,12 @@
+import type { ButtonGroupContextValue } from './props.js';
+/** Position a member occupies inside its ButtonGroup — the group's per-child
+ *  slot providers stamp it so grouped styling doesn't depend on
+ *  `:first-child`/`:has()` CSS (absent on NativeScript). */
+export interface ButtonGroupMember extends ButtonGroupContextValue {
+    position: 'first' | 'middle' | 'last' | 'only';
+}
+export declare const ButtonGroupContext: any;
+export declare const ButtonGroupProvider: any;
+/** Button (and grouped trigger components) read group membership here;
+ *  returns null outside a ButtonGroup. */
+export declare function useButtonGroup(): ButtonGroupMember | null;

package/types/generated/calendar-core.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Pure calendar engine shared by every Calendar leaf — month grids, selection
+ * state, constraint evaluation, range-pick reduction, and navigation bounds.
+ * No hooks, no DOM, no platform imports.
+ */
+import { type PlainDate } from './datetime.js';
+import type { DateRange, DayOfWeek, DayOfWeekName, ISODateString } from './props.js';
+export { isSameDay, isDateInRange, getWeekNumber };
+declare function isSameDay(a: ISODateString, b: ISODateString): boolean;
+declare function isDateInRange(iso: ISODateString, range: DateRange): boolean;
+declare function getWeekNumber(iso: ISODateString): number;
+export interface CalendarDay {
+    readonly date: PlainDate;
+    readonly iso: ISODateString;
+    readonly dayOfMonth: number;
+    readonly isToday: boolean;
+    readonly isOutsideMonth: boolean;
+    readonly isWeekend: boolean;
+    readonly isSunday: boolean;
+    readonly isMonday: boolean;
+    readonly isFirstWeekOfMonth: boolean;
+    readonly isLastWeekOfMonth: boolean;
+}
+export interface CalendarMonthGrid {
+    readonly year: number;
+    readonly month: number;
+    readonly weeks: CalendarDay[][];
+    /** Short standalone weekday labels, ordered from `weekStartsOn`. */
+    readonly dayNames: string[];
+}
+/**
+ * Build the week grid for a month. Outside-month days pad the first/last
+ * week so every row has 7 cells; fixed grids (`hasVariableRowCount` false,
+ * the default) always emit 6 weeks so the calendar height never shifts
+ * between months.
+ */
+export declare function buildMonthGrid(year: number, month: number, weekStartsOn: DayOfWeek | DayOfWeekName | undefined, hasVariableRowCount?: boolean, locale?: string): CalendarMonthGrid;
+export declare function monthLabel(year: number, month: number, locale?: string): string;
+export interface CalendarConstraintsInput {
+    min?: ISODateString;
+    max?: ISODateString;
+    dateConstraints?: ReadonlyArray<(date: Date) => boolean>;
+    maxRangeSpan?: number;
+    minRangeSpan?: number;
+    /** In-progress range anchor (range mode). */
+    rangeAnchor?: ISODateString | null;
+}
+export declare function createDateDisabledCheck(input: CalendarConstraintsInput): (date: PlainDate) => boolean;
+/** Validate a complete range at every commit boundary, including presets.
+ * Bounds/predicates apply to endpoints; interior days are not constrained. */
+export declare function isDateRangeAllowed(range: DateRange, input: CalendarConstraintsInput): boolean;
+export type RangePickResult = {
+    kind: 'start';
+    anchor: ISODateString;
+} | {
+    kind: 'commit';
+    range: DateRange;
+} | {
+    kind: 'cancel';
+};
+/** Second-pick reducer: earlier pick → ordered commit; same-day pick →
+ *  single-day range when minSpan allows, else cancel the in-progress
+ *  selection. */
+export declare function applyRangePick(anchor: ISODateString, iso: ISODateString, minRangeSpan?: number): RangePickResult;
+/** First-of-month basis for everything that navigates. */
+export declare function monthStart(pd: PlainDate): PlainDate;
+/** Initial focus precedence: explicit focusDate → selected value → today,
+ *  clamped into [min, max] so an all-disabled window still opens on its
+ *  nearest bound. With two months the base month shifts so `max` isn't
+ *  stranded in an out-of-range trailing pane. */
+export declare function getInitialFocusDate(input: {
+    focusDate?: ISODateString;
+    value?: ISODateString | DateRange;
+    min?: ISODateString;
+    max?: ISODateString;
+    numberOfMonths?: 1 | 2;
+}): PlainDate;
+export interface NavigationBounds {
+    canNavigatePrevious: boolean;
+    canNavigateNext: boolean;
+}
+export declare function navigationBounds(baseMonth: PlainDate, numberOfMonths: number, min?: ISODateString, max?: ISODateString): NavigationBounds;
+export interface DayCellState {
+    isSelected: boolean;
+    isRangeStart: boolean;
+    isRangeEnd: boolean;
+    isInRange: boolean;
+    /** Anchored but uncommitted first pick in range mode. */
+    isPendingStart: boolean;
+    isDisabled: boolean;
+}
+export declare function computeDayCellState(day: CalendarDay, opts: {
+    mode: 'single' | 'range';
+    value?: ISODateString | DateRange;
+    rangeAnchor?: ISODateString | null;
+    isDateDisabled: (date: PlainDate) => boolean;
+}): DayCellState;
+export interface CellContinuity {
+    /** The previous day cell exists in the pane and continues the range band. */
+    before: boolean;
+    /** The next day cell exists in the pane and continues the range band. */
+    after: boolean;
+}
+/** Whether an in-pane day carries the range band — committed span plus the
+ *  pending anchor. Outside-month pads never carry it (they would duplicate
+ *  the real day's styling in the adjacent pane). */
+export declare function dayCarriesBand(state: Pick<DayCellState, 'isInRange' | 'isRangeStart' | 'isRangeEnd'>): boolean;
+export type CellRounding = 'none' | 'start' | 'end' | 'both';
+/** Which corners get the selected-range radius: band edges round, band
+ *  interiors don't. */
+export declare function computeCellRounding(state: DayCellState, continuity: CellContinuity): CellRounding;

package/types/generated/calendar-hooks.d.ts

@@ -0,0 +1,37 @@
+import type { DateRange, ISODateString } from './props.js';
+import { type PlainDate } from './datetime.js';
+import { type CalendarConstraintsInput, type CalendarMonthGrid } from './calendar-core.js';
+export interface UseCalendarConstraintsOptions extends CalendarConstraintsInput {
+}
+export interface UseCalendarConstraintsReturn {
+    isDateDisabled: (date: PlainDate) => boolean;
+}
+export declare function useCalendarConstraints(options: UseCalendarConstraintsOptions): UseCalendarConstraintsReturn;
+export interface UseCalendarDaysOptions {
+    year: number;
+    month: number;
+    weekStartsOn?: import('./props.js').DayOfWeek | import('./props.js').DayOfWeekName;
+    hasVariableRowCount?: boolean;
+    locale?: string;
+}
+export type UseCalendarDaysReturn = CalendarMonthGrid;
+export declare function useCalendarDays(options: UseCalendarDaysOptions): CalendarMonthGrid;
+export interface UseCalendarNavigationOptions {
+    numberOfMonths?: 1 | 2;
+    min?: ISODateString;
+    max?: ISODateString;
+    focusDate?: ISODateString;
+    onFocusDateChange?: (focusDate: ISODateString) => void;
+    /**  Seeds the uncontrolled view when `focusDate` is absent — selected
+ *  value or today, clamped into [min, max]. */
+    value?: ISODateString | DateRange;
+}
+export interface UseCalendarNavigationReturn {
+    /**  First-of-month basis for the leading pane. */
+    baseMonth: PlainDate;
+    canNavigatePrevious: boolean;
+    canNavigateNext: boolean;
+    navigateMonths(delta: number): void;
+    navigateTo(date: ISODateString): void;
+}
+export declare function useCalendarNavigation(options: UseCalendarNavigationOptions): UseCalendarNavigationReturn;

package/types/generated/chat-context.d.ts

@@ -0,0 +1,17 @@
+import type { ChatComposerContextValue, ChatLayoutContextValue, ChatListContextValue, ChatMessageContextValue } from './props.js';
+/** Per-message context: sender + density for bubbles and metadata. */
+export declare const ChatMessageContext: any;
+export declare const ChatMessageProvider: any;
+/** Per-list context: density default for messages. */
+export declare const ChatListContext: any;
+export declare const ChatListProvider: any;
+/** Composer shell → slots context (value, submit, input control seam). */
+export declare const ChatComposerContext: any;
+export declare const ChatComposerProvider: any;
+/** Layout → message list context: scroll container + content refs. */
+export declare const ChatLayoutContext: any;
+export declare const ChatLayoutProvider: any;
+export declare function useChatMessageContext(): ChatMessageContextValue | null;
+export declare function useChatListContext(): ChatListContextValue | null;
+export declare function useChatComposerContext(): ChatComposerContextValue | null;
+export declare function useChatLayoutContext(): ChatLayoutContextValue | null;

package/types/generated/chat-group-items.d.ts

@@ -0,0 +1,8 @@
+import type { ChatComposerTriggerItem } from './props.js';
+export interface ChatItemGroup<T extends ChatComposerTriggerItem = ChatComposerTriggerItem> {
+    heading: string | null;
+    items: T[];
+}
+/** Group trigger items by `auxiliaryData.group`, preserving first-seen group
+ *  order; ungrouped items trail (matches upstream groupItems default). */
+export declare function groupChatItems<T extends ChatComposerTriggerItem>(items: T[]): ChatItemGroup<T>[];

package/types/generated/chat-tokenize.d.ts

@@ -0,0 +1,14 @@
+import type { ChatComposerToken } from './props.js';
+export type ChatTextPart = {
+    kind: 'text';
+    text: string;
+} | {
+    kind: 'token';
+    token: ChatComposerToken;
+    index: number;
+};
+/** Split serialized message text into text runs and token parts, matching
+ *  upstream's literal-value scan: each non-empty token `value` is matched
+ *  literally; empty values are ignored; first longest match wins per
+ *  position (alternation order follows the tokens array). */
+export declare function tokenizeChatText(text: string, tokens: ChatComposerToken[]): ChatTextPart[];

package/types/generated/chat-tokens.d.ts

@@ -0,0 +1,11 @@
+/**  @jsxImportSource @nativescript-community/octane */
+import type { ChatComposerToken, ChatComposerTokenCustom } from './props.js';
+/**  Is this token the custom-render form? Shared by the input and the
+ *  tokenized-text renderer. */
+export declare function isCustomToken(token: ChatComposerToken): token is ChatComposerTokenCustom;
+/**  The shared inline chip for badge-configured tokens — used by the
+ *  composer input, ChatComposerTokenElement, and ChatTokenizedText. */
+export declare function ChatTokenChip(props: {
+    token: ChatComposerToken;
+    className?: any;
+}): any;

package/types/generated/chat-tokens.web.d.ts

@@ -0,0 +1,11 @@
+/** @jsxImportSource octane */
+import type { ChatComposerToken, ChatComposerTokenCustom } from './props.js';
+/**  Is this token the custom-render form? Shared by the input and the
+ *  tokenized-text renderer. */
+export declare function isCustomToken(token: ChatComposerToken): token is ChatComposerTokenCustom;
+/**  The shared inline chip for badge-configured tokens — used by the
+ *  composer input, ChatComposerTokenElement, and ChatTokenizedText. */
+export declare function ChatTokenChip(props: {
+    token: ChatComposerToken;
+    className?: any;
+}): any;

package/types/generated/chatComposerSelection.web.d.ts

@@ -0,0 +1,13 @@
+/** Selection helpers for the web contenteditable composer — ported from
+ *  Astryx chatComposerSelection. A programmatic focus() collapses the caret
+ *  to the start (Chromium) or leaves no Range at all, so the composer never
+ *  infers the caret from a bare focus: placeCaretAtEnd for click-to-focus,
+ *  getSelectionRangeInside/restoreSelectionRange to keep a user's own
+ *  selection, ensureCaretInside when any valid Range suffices. */
+export declare function getSelectionRangeInside(editable: HTMLElement): Range | null;
+export declare function restoreSelectionRange(range: Range): void;
+export declare function placeCaretAtEnd(editable: HTMLElement): boolean;
+export declare function ensureCaretInside(editable: HTMLElement): Selection | null;
+export declare function isSelectionAtStart(editable: HTMLElement): boolean;
+export declare function isSelectionAtEnd(editable: HTMLElement): boolean;
+export declare function insertTextAtCursor(editable: HTMLElement, text: string): boolean;

package/types/generated/child-array.d.ts

@@ -1,3 +1,4 @@
-/** Normalize a JSX children value to a flat array — children may be a
- *  single node, an array, or nested arrays from `.map` calls. */
+/** Normalize supported JSX children through their owning renderer. */
 export declare function toChildArray(children: any): any[];
+/** Preserve each child's key when placing it inside a wrapper host. */
+export declare function mapChildren(children: any, render: (child: any, index: number) => any): any;

package/types/generated/clipboard-write.d.ts

@@ -0,0 +1,2 @@
+/** Write text to the system clipboard. Resolves false on failure. */
+export declare function copyText(text: string): Promise<boolean>;

package/types/generated/clipboard-write.macos.d.ts

@@ -0,0 +1,3 @@
+/** Write text to the macOS pasteboard via the __xplatAppKit bridge
+ *  (NSPasteboard). Resolves false when the bridge is absent. */
+export declare function copyText(text: string): Promise<boolean>;

package/types/generated/clipboard-write.web.d.ts

@@ -0,0 +1,3 @@
+/** Write text to the system clipboard. Resolves false when the Clipboard API
+ *  is unavailable (insecure context) or rejects. */
+export declare function copyText(text: string): Promise<boolean>;

package/types/generated/code-highlight.web.d.ts

@@ -0,0 +1,31 @@
+import type { TokenLine } from './props.js';
+interface RangeEntry {
+    range: Range;
+    highlight: Highlight;
+}
+/** Whether the CSS Custom Highlight API is usable in this engine. */
+export declare function hasHighlightAPI(): boolean;
+/**
+ * Safari exposes the Highlight API objects but has rendering issues with
+ * ::highlight() in code blocks — detect WebKit-without-Chrome so callers can
+ * fall back to spans.
+ */
+export declare function isWebKitOnly(): boolean;
+declare function cleanupRanges(ranges: RangeEntry[]): void;
+/**
+ * Apply CSS Custom Highlight ranges lazily as content-visibility chunks
+ * scroll into view. Small files (lines directly inside <code>) apply
+ * immediately. Returns a cleanup removing all ranges and listeners.
+ */
+export declare function applyHighlightRangesChunked(codeEl: HTMLElement, tokenLines: TokenLine[]): () => void;
+/**
+ * Apply highlight ranges for a batch of lines starting at `startLine` — used
+ * by the streaming tokenizer to apply highlights progressively.
+ */
+export declare function applyHighlightRangesBatch(codeEl: HTMLElement, tokenLines: TokenLine[], startLine: number): RangeEntry[];
+/**
+ * Apply ranges to a flat element (no [data-line] structure), e.g. a
+ * contentEditable code surface where all text is Text nodes with newlines.
+ */
+export declare function applyHighlightRangesFlat(el: HTMLElement, tokenLines: TokenLine[]): () => void;
+export { cleanupRanges };

package/types/generated/code-tokenizer.d.ts

@@ -0,0 +1,50 @@
+import type { TokenLine } from './props.js';
+export type { SyntaxToken, TokenLine } from './props.js';
+/** Threshold below which we tokenize synchronously (characters). */
+export declare const SYNC_TOKENIZE_THRESHOLD = 2000;
+/**
+ * Tokenizes a code string into per-line token arrays.
+ *
+ * Each line's tokens use line-relative offsets. Tokens matching the
+ * language's default color type are omitted (~30% reduction).
+ */
+export declare function tokenize(code: string, language: string): TokenLine[];
+/**
+ * Async tokenizer that yields to the main thread between batches
+ * of lines (~800 chars per batch).
+ */
+export declare function tokenizeAsync(code: string, language: string, signal?: AbortSignal): Promise<TokenLine[]>;
+/**
+ * Streaming tokenizer with per-batch callback. Tokenizes lines in
+ * batches and invokes `onBatch` after each so consumers can apply
+ * highlights progressively.
+ */
+export declare function tokenizeStreaming(code: string, language: string, onBatch: (lines: TokenLine[], startLine: number) => void, signal?: AbortSignal): Promise<void>;
+/**
+ * Convert legacy flat tokens (absolute offsets) to per-line tokens
+ * (line-relative offsets). For backwards compatibility with custom
+ * tokenizers that return the old format.
+ */
+export declare function flatTokensToLines(tokens: {
+    type: string;
+    start: number;
+    end: number;
+}[], code: string): TokenLine[];
+/** Token types with built-in syntax colors — the Astryx 14-token vocabulary. */
+export declare const TOKEN_TYPES: readonly ["keyword", "string", "comment", "number", "function", "type", "tag", "attribute", "property", "operator", "constant", "punctuation", "variable"];
+export type SyntaxTokenType = (typeof TOKEN_TYPES)[number];
+/** CSS custom property carrying a token type's color. */
+export declare function syntaxTokenVar(type: string): string;
+/** `var(--color-syntax-*)` reference for the given token type, with a
+ *  currentColor fallback for unknown types — used by native spans, which
+ *  cannot resolve CSS vars themselves and read concrete colors from
+ *  {@link syntaxColor} instead. */
+export declare function syntaxTokenVarRef(type: string): string;
+/** Concrete token colors for native text runs (CSS vars don't reach
+ *  FormattedString spans). Mirrors the `--color-syntax-*` defaults in
+ *  chrome.css; `syntaxTheme` entries override per block. */
+export declare function syntaxColor(type: string, scheme: 'light' | 'dark', theme?: {
+    tokens?: Record<string, string | [string, string]>;
+} | null): string | undefined;
+/** The `--color-syntax-*` var names published in chrome.css. */
+export declare const SYNTAX_TOKEN_VARS: readonly [...string[], "--color-syntax-background"];

package/types/generated/codeblock-shared.d.ts

@@ -0,0 +1,11 @@
+import type { CodeBlockProps } from './props.js';
+import { type TokenLine } from './code-tokenizer.js';
+/**  The mode each leaf resolves once at mount — 'ranges' needs the CSS Custom
+ *  Highlight API, which only the web leaf can probe. */
+export type ResolvedHighlightMode = 'ranges' | 'spans';
+export declare function useTokenLines(code: string, language: string, tokenizer: CodeBlockProps['tokenizer']): TokenLine[];
+/**  Copy-button state: writes the block's code, flips to a check for a beat. */
+export declare function useCodeCopy(code: string, onCopy: (() => void) | undefined): {
+    copy: () => void;
+    copied: boolean;
+};

package/types/generated/colorScheme.macos.d.ts

@@ -0,0 +1,4 @@
+import type { ColorScheme } from './props.js';
+export declare function getColorScheme(): ColorScheme;
+export declare function subscribeSystemScheme(callback: () => void): () => void;
+export declare function useColorScheme(): ColorScheme;

package/types/generated/command-palette-accessibility.mobile.d.ts

@@ -0,0 +1,2 @@
+/** Announce search status through the active native accessibility service. */
+export declare function announceCommandPalette(view: any, message: string): void;

package/types/generated/command-palette-keys.macos.d.ts

@@ -0,0 +1,2 @@
+/** Scope AppKit key monitoring to the palette field's editor and owning window. */
+export declare function bindCommandPaletteKeys(input: any, keyDown: (event: any) => void, autoFocus: boolean, queryChanged: (query: string) => void): () => void;

package/types/generated/command-palette-scroll.macos.d.ts

@@ -0,0 +1,2 @@
+/** AppKit converts a row's local bounds through its enclosing clip view. */
+export declare function scrollCommandPaletteHighlight(row: any): void;

package/types/generated/command-palette-state.d.ts

@@ -0,0 +1,27 @@
+import type { CommandPaletteItem, CommandPaletteProps } from './props.js';
+export declare function staticCommands(props: Pick<CommandPaletteProps, 'items' | 'searchMode'>, query: string): CommandPaletteItem[];
+export interface CommandPaletteState<T extends CommandPaletteItem> {
+    open: boolean;
+    query: string;
+    results: T[];
+    highlighted: string | null;
+    selected: string;
+    status: 'idle' | 'loading' | 'ready' | 'error';
+}
+/** Hook-free search/interaction owner. Every rendered root subscribes to store. */
+export declare function createCommandPaletteController<T extends CommandPaletteItem>(read: () => CommandPaletteProps<T>): {
+    store: import("./props.js").Store<CommandPaletteState<T>>;
+    search: (query: string) => void;
+    close: () => void;
+    select: (id: string) => void;
+    highlight: (id: string | null) => void;
+    keyDown: (event: {
+        key: string;
+        isComposing?: boolean;
+        keyCode?: number;
+        defaultPrevented?: boolean;
+        preventDefault(): void;
+    }) => void;
+    configure(props?: CommandPaletteProps<T>): void;
+    dispose(): void;
+};

package/types/generated/controls.macos.d.ts

@@ -0,0 +1,8 @@
+import type { ActivityIndicatorProps, ButtonProps, CheckboxProps, SearchInputProps, SegmentedControlProps, SliderProps, SwitchProps } from './props.js';
+export declare function Button(props: ButtonProps): unknown;
+export declare function Checkbox(inputProps: CheckboxProps): unknown;
+export declare function Switch(inputProps: SwitchProps): unknown;
+export declare function Slider(props: SliderProps): unknown;
+export declare function SegmentedControl(_props: SegmentedControlProps): unknown;
+export declare function SearchInput(props: SearchInputProps): unknown;
+export declare function ActivityIndicator(props: ActivityIndicatorProps): unknown;

package/types/generated/date-composition.d.ts

@@ -0,0 +1,5 @@
+/** Read native marked/composing text without replacing the OS input delegate. */
+export declare function hasDateComposition(view: any, event?: {
+    isComposing?: boolean;
+    keyCode?: number;
+}): boolean;

package/types/generated/date-composition.macos.d.ts

@@ -0,0 +1,5 @@
+/** AppKit field editor owns marked text; action callbacks are committed text. */
+export declare function hasDateComposition(view: any, event?: {
+    isComposing?: boolean;
+    keyCode?: number;
+}): boolean;

package/types/generated/date-composition.web.d.ts

@@ -0,0 +1,4 @@
+export declare function hasDateComposition(_view: unknown, event?: {
+    isComposing?: boolean;
+    keyCode?: number;
+}): boolean;

package/types/generated/date-field-action.d.ts

@@ -0,0 +1,4 @@
+/** Run an app-owned date-field action and release loading on either outcome.
+ * The app owns failure messaging through `status`. Rejection must not leave
+ * a field busy or create an unhandled event-handler promise rejection. */
+export declare function runDateChangeAction(action: () => void | Promise<void>, onSettled: () => void): void;

package/types/generated/date-keyboard.d.ts

@@ -0,0 +1,27 @@
+import { type PlainDate } from './datetime.js';
+import type { ISODateString } from './props.js';
+import type { CalendarMonthGrid } from './calendar-core.js';
+export interface DateKeyEvent {
+    key: string;
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+    altKey?: boolean;
+    isComposing?: boolean;
+    keyCode?: number;
+    defaultPrevented?: boolean;
+}
+export declare function isDateComposing(event: Pick<DateKeyEvent, 'isComposing' | 'keyCode'>): boolean;
+/** Portable navigation model. Adapters own event delivery and actual focus.
+ * Vertical traversal retains the weekday column; row edges never leave the row.
+ * Unbounded predicates are searched for at most one year to avoid hanging. */
+export declare function calendarKeyTarget(input: {
+    iso: ISODateString;
+    event: DateKeyEvent;
+    months: readonly CalendarMonthGrid[];
+    isDisabled: (date: PlainDate) => boolean;
+    rtl?: boolean;
+    min?: ISODateString;
+    max?: ISODateString;
+}): ISODateString | null;
+/** Clamp highlighted options; -1 means no active option, including empty lists. */
+export declare function timeOptionIndex(key: string, index: number, length: number): number;

package/types/generated/date-messages.d.ts

@@ -0,0 +1,2 @@
+import type { DateInputMessages } from './props.js';
+export declare function dateMessages(messages?: Partial<DateInputMessages>): DateInputMessages;