@octane-xplat/ui 0.9.0 → 0.10.0

package/types/generated/time-format.d.ts

@@ -0,0 +1,40 @@
+import type { TimestampFormat, TimestampTooltipEntry, TimestampTooltipFormat } from './props.js';
+export type { TimestampTooltipEntry, TimestampTooltipFormat } from './props.js';
+/** A rendered tooltip line for the Timestamp hover card. */
+export interface TimestampTooltipLine {
+    label?: string;
+    value: string;
+    isCopyable: boolean;
+}
+type Locale = string | string[] | undefined;
+export interface FormatInstantOptions {
+    /** IANA zone id; omit for the viewer's own zone. */
+    timeZone?: string;
+    /** Append the short zone abbreviation (`date_time`/`time`/`full` only). */
+    isTimezoneShown?: boolean;
+    /** 'short' ("PST") or 'long' ("Pacific Standard Time") — `full` only. */
+    timeZoneNameStyle?: 'short' | 'long';
+}
+/** Render one instant in one absolute format. Pure in its arguments. */
+export declare function formatInstant(date: Date, format: TimestampTooltipFormat, locale?: Locale, { timeZone, isTimezoneShown, timeZoneNameStyle }?: FormatInstantOptions): string;
+type RelativeTimeStyle = 'long' | 'narrow';
+/**
+ * Locale-correct relative time: the fixed tier selection is ours, wording,
+ * plural rules, and word order belong to the CLDR-backed formatter.
+ */
+export declare function formatRelativeTime(date: Date, now: Date, locale?: Locale, style?: RelativeTimeStyle): string;
+/** Render one tooltip line per entry, in the order given. Pure. */
+export declare function formatTooltipLines(date: Date, entries: readonly TimestampTooltipEntry[], locale?: Locale): TimestampTooltipLine[];
+/** Seconds threshold for 'auto' format: below this, relative; else date_time. */
+export declare const DEFAULT_AUTO_THRESHOLD: number;
+/** Parse the `Timestamp.value` contract: number < 1e12 = Unix seconds,
+ *  larger = ms; strings parse as dates (ISO 8601 recommended). */
+export declare function parseTimestampValue(value: string | number): Date;
+/** Interval (ms) for a live relative timestamp's next update. */
+export declare function getLiveInterval(diffSeconds: number): number;
+export declare function isRelativeFormat(format: TimestampFormat): boolean;
+export declare function isAbsoluteFormat(format: TimestampFormat): format is Exclude<TimestampFormat, 'relative' | 'relative_short' | 'auto'>;
+/** Resolve the 'auto' alias to the concrete format for a given diff. */
+export declare function resolveTimestampFormat(format: TimestampFormat, diffSeconds: number, autoThreshold: number): TimestampFormat;
+/** The visible text for one instant in the effective (resolved) format. */
+export declare function formatTimestampText(date: Date, format: Exclude<TimestampFormat, 'auto'>, now: Date, locale: Locale, isTimezoneShown: boolean): string;

package/types/generated/timer-format.d.ts

@@ -0,0 +1,13 @@
+import type { TimerFormat } from './props.js';
+export interface TimerPresentation {
+    /** ISO 8601 duration, e.g. 'PT95S' — the `dateTime` value on web. */
+    dateTime: string;
+    text: string;
+}
+export declare function resolveTimerFormat(format: TimerFormat | undefined): TimerFormat;
+export declare function elapsedMilliseconds(now: number, startTime: number): number;
+export declare function timerPresentation(elapsedMs: number, format: TimerFormat): TimerPresentation;
+/** Ms until the next visible change — also the cadence the tick loop uses.
+ *  Elapsed mode relaxes to once a minute past the hour mark; a future
+ *  startTime schedules the first tick for the start boundary. */
+export declare function msUntilNextChange(now: number, startTime: number, elapsedMs: number, format: TimerFormat): number;

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

@@ -0,0 +1,14 @@
+import type { ToastPosition } from './props.js';
+/** The nearest `ToastViewport`'s routing identity + defaults. `useToast`
+ *  reads this in the declaring tree; the pushed entry carries the id so
+ *  the right stack renders it — context never has to cross the overlay
+ *  root boundary on native. */
+export interface ToastViewportContextValue {
+    id: string;
+    position: ToastPosition;
+    maxVisible: number;
+}
+export declare const ToastViewportContext: import("octane").Context<ToastViewportContextValue | null>;
+/** JSX-provider form — universal-renderer contexts are callables, not
+ *  `.Provider` members (same aliasing as DialogProvider). */
+export declare const ToastViewportProvider: any;

package/types/generated/toast-service.d.ts

@@ -0,0 +1,24 @@
+import type { RootLayout } from '@nativescript/core';
+import type { ShowToastFn, ToastPosition } from './props.js';
+/**  A viewport's registration — its declaring RootLayout hosts the toasts
+ *  routed to it. Written by `ToastViewport` (toast-viewport.tsrx). */
+interface NativeViewport {
+    rl: RootLayout;
+    position: ToastPosition;
+    maxVisible: number;
+}
+export declare function registerNativeToastViewport(id: string, viewport: NativeViewport): () => void;
+/**  Reconcile per-toast hosts with the store: mount visible newcomers,
+ *  re-render the rest so `exiting` reaches the card, unmount entries that
+ *  left the store or fell outside their bucket's `maxVisible` window
+ *  (they resurface when the stack drains — upstream parity). */
+export declare function sync(): void;
+/**  Module-level toast (Astryx `useToast` fallback path as a function):
+ *  lands on the current top RootLayout's edge stack. Returns the toast's
+ *  dismiss function. */
+export declare const showToast: ShowToastFn;
+/**  Imperative toast control (Astryx `useToast`), native leaf. Inside a
+ *  `ToastViewport` toasts dock on that viewport's RootLayout at its
+ *  configured edge; outside one they land on the top RootLayout stack. */
+export declare function useToast(): ShowToastFn;
+export {};

package/types/generated/toast-service.web.d.ts

@@ -0,0 +1,8 @@
+import type { ShowToastFn } from './props.js';
+/**  Show a toast on the fallback stack (Astryx `useToast` fallback path,
+ *  as a module-level function). Returns the toast's dismiss function. */
+export declare const showToast: ShowToastFn;
+/**  Imperative toast control (Astryx `useToast`), web leaf. Inside a
+ *  `ToastViewport` the returned function routes to that stack; outside
+ *  one it lands on the auto-mounted fallback stack, same as `showToast`. */
+export declare function useToast(): ShowToastFn;

package/types/generated/toast-store.d.ts

@@ -0,0 +1,37 @@
+import type { ToastDismissReason, ToastEntry, ToastOptions } from './props.js';
+/** Module-scope toast queue — the single source of truth for every leaf.
+ *  Cross-root state uses module stores (overlay roots never share context
+ *  with the declaring tree on native); each leaf's stack reads this and
+ *  owns only presentation. */
+export declare const toastStore: import("./props.js").Store<ToastEntry[]>;
+/** Stack id for toasts pushed without an enclosing `ToastViewport`
+ *  (`showToast`, or `useToast` outside a provider) — the auto-mounted
+ *  fallback stack. */
+export declare const FALLBACK_TOAST_VIEWPORT = "__xplat_toast_fallback__";
+/** Time the `exiting` flag holds before an entry leaves the store — the
+ *  leaf's exit presentation runs inside this window. */
+export declare const TOAST_EXIT_MS = 220;
+/** Registers a mounted stack so orphaned entries can drain to the
+ *  fallback instead of vanishing with their viewport. */
+export declare function registerToastViewport(id: string): () => void;
+/** Does this entry render on `viewportId`'s stack? Entries whose owning
+ *  viewport unmounted fall back so they still dismiss on schedule. */
+export declare function toastOnViewport(entry: ToastEntry, viewportId: string): boolean;
+/** Push a toast. Returns the entry id ('' when a same-`uniqueID` toast
+ *  with `collisionBehavior: 'ignore'` suppressed it). Overwrite collision
+ *  swaps the entry in place — the replaced toast's `onHide` does NOT fire
+ *  (it was superseded, not dismissed). */
+export declare function pushToast(options: ToastOptions, viewportId?: string): string;
+/** Dismiss a toast: fires `onHide` exactly once, flags `exiting` for the
+ *  exit presentation, then prunes the entry after `TOAST_EXIT_MS`.
+ *  Idempotent — a second call while exiting is a no-op. */
+export declare function dismissToast(id: string, reason?: ToastDismissReason): void;
+/** Look up a live toast by its deduplication key. */
+export declare function findToastByUniqueID(uniqueID: string): ToastEntry | undefined;
+/** Resolved auto-hide contract: error toasts hold for manual dismissal
+ *  unless `isAutoHide` overrides; info toasts auto-hide after
+ *  `autoHideDuration` (default 5000ms). */
+export declare function toastTiming(options: ToastOptions): {
+    isAutoHide: boolean;
+    autoHideDuration: number;
+};

package/types/generated/toast-viewport.d.ts

@@ -0,0 +1,8 @@
+import type { ToastViewportProps } from './props.js';
+/**  Toast stack container (Astryx `ToastViewport`), native leaf. Toasts
+ *  render as sibling hosts on this screen's RootLayout — the viewport
+ *  owns routing config (`position`, `maxVisible`) and registers its
+ *  RootLayout so `useToast` inside it docks there. `inset` and
+ *  `isTopLayer` are web semantics (documented; `inset` applies as extra
+ *  edge margin where noted on the service). */
+export declare function ToastViewport(props: ToastViewportProps): unknown;

package/types/generated/toast-viewport.web.d.ts

@@ -0,0 +1,15 @@
+import type { ToastPosition, ToastViewportProps } from './props.js';
+/**  The toast stack for one viewport id — the fixed, top-layer container
+ *  holding a column per occupied edge. Shared by `ToastViewport` and the
+ *  auto-mounted fallback stack (`showToast` without a provider). */
+export declare function ToastViewportSurface(props: {
+    viewportId: string;
+    position: ToastPosition;
+    maxVisible: number;
+    inset?: ToastViewportProps['inset'];
+    isTopLayer?: boolean;
+}): import("octane/jsx-runtime").JSX.Element;
+/**  Toast stack container (Astryx `ToastViewport`), web leaf. Provides the
+ *  context `useToast` routes through and renders its own fixed stack;
+ *  toasts pushed unscoped land on the auto-mounted fallback stack. */
+export declare function ToastViewport(props: ToastViewportProps): import("octane/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,13 @@
+import type { FieldControlSize } from './props.js';
+export interface ToggleButtonGroupContextValue {
+    /** Currently pressed member values. */
+    selectedValues: Set<string>;
+    /** Toggle a member value on/off — applies single/multiple policy. */
+    toggle: (value: string) => void;
+    /** Group default size; members may override. */
+    size?: FieldControlSize;
+    isDisabled?: boolean;
+}
+export declare const ToggleButtonGroupContext: any;
+/** ToggleButton reads group membership here; null outside a group. */
+export declare function useToggleButtonGroup(): ToggleButtonGroupContextValue | null;

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

@@ -1,6 +1,6 @@
 import type { SetTranslate } from './props.js';
 /** Imperative translate write on a bound view — the gesture seam. Called
- *  per frame from pan handlers (docs/animation-gestures.md: animation
+ *  per frame from pan handlers (docs/app/animation-gestures.md: animation
  *  writes imperative, state stays declarative). Composes with other
  *  transform writes on the same element via ./transform.web. */
 export declare const setTranslate: SetTranslate;

package/types/generated/typeahead-source.d.ts

@@ -0,0 +1,20 @@
+import type { CreateStaticSourceOptions, SearchableItem, SearchSource } from './props.js';
+/** Create a SearchSource from a static item array — substring match on
+ *  `label` plus optional `keywords`. For fuzzy/ranked/server-side matching
+ *  implement `SearchSource` directly. */
+export declare function createStaticSource<T extends SearchableItem>(items: T[], options?: CreateStaticSourceOptions<T>): SearchSource<T>;
+/** User-perceived character count — one emoji/flag/accented grapheme counts
+ *  once. `minQueryLength` is measured in these, not UTF-16 code units. */
+export declare function characterCount(str: string): number;
+/** An item's group heading, read from `auxiliaryData.group`. */
+export declare function getItemGroup(item: SearchableItem): string | undefined;
+export interface TypeaheadItemGroup<T extends SearchableItem = SearchableItem> {
+    heading: string | null;
+    items: T[];
+}
+/** Group results by `auxiliaryData.group`, preserving insertion order.
+ *  Ungrouped items collect into a `heading: null` group; `ungroupedFirst`
+ *  places it before the named groups. No groups → one `heading: null` group. */
+export declare function groupTypeaheadItems<T extends SearchableItem>(items: T[], { ungroupedFirst }?: {
+    ungroupedFirst?: boolean;
+}): TypeaheadItemGroup<T>[];

package/types/generated/use-hover-card.d.ts

@@ -0,0 +1,8 @@
+import type { HoverCardOptions, HoverCardReturn } from './props.js';
+/**
+ * Default (macOS) leaf of the hover-card hook — the AppKit host bridge
+ * supplies real pointer intent (`observeHover` tracking areas) and the
+ * card mounts through the in-window useLayer primitive
+ * in its own root. iOS/Android resolve the
+ * `.mobile` leaf instead. */
+export declare function useHoverCard(options?: HoverCardOptions): HoverCardReturn;

package/types/generated/use-hover-card.mobile.d.ts

@@ -0,0 +1,9 @@
+import type { HoverCardOptions, HoverCardReturn } from './props.js';
+/**
+ * Touch-leaf of the hover card hook. There is no hover or focus traversal
+ * on touch platforms, so `delay`/`hideDelay`/`focusTrigger` are inert;
+ * `touchTrigger` drives a tap on the interaction element. 'auto' cannot
+ * detect an action trigger on native — it behaves as 'tap' (documented
+ * deviation). The card dismisses on an outside tap (or Escape-equivalent
+ * platform back through the popover's own dismissal). */
+export declare function useHoverCard(options?: HoverCardOptions): HoverCardReturn;

package/types/generated/use-hover-card.web.d.ts

@@ -0,0 +1,10 @@
+import type { HoverCardOptions, HoverCardPlacement, HoverCardReturn, PopoverPlacement } from './props.js';
+export declare function placementFor(place: HoverCardPlacement, rtl: boolean): PopoverPlacement;
+/**
+ * Hover/focus/tap-triggered anchored card (Astryx `useHoverCard`), web
+ * leaf. Hover opens after `delay` and hides after `hideDelay`; the card
+ * stays open while the pointer or focus moves into it. Focus triggers
+ * attach when `focusTrigger` allows (auto = naturally focusable). A tap
+ * on a touch pointer opens immediately per `touchTrigger`. Escape hides
+ * (or reports, when `isOpen` is controlled). */
+export declare function useHoverCard(options?: HoverCardOptions): HoverCardReturn;

package/types/generated/use-imperative-alert-dialog.d.ts

@@ -0,0 +1,6 @@
+import type { ImperativeAlertDialogReturn } from './props.js';
+/**  Imperative AlertDialog control (Astryx `useImperativeAlertDialog`).
+ *  `show(options)` mounts the confirmation dialog; `element` renders it —
+ *  keep it mounted in the tree. User dismissal closes the hook's own
+ *  state. */
+export declare function useImperativeAlertDialog(): ImperativeAlertDialogReturn;

package/types/generated/use-imperative-alert-dialog.web.d.ts

@@ -0,0 +1,6 @@
+import type { ImperativeAlertDialogReturn } from './props.js';
+/**  Imperative AlertDialog control (Astryx `useImperativeAlertDialog`).
+ *  `show(options)` mounts the confirmation dialog; `element` renders it —
+ *  keep it mounted in the tree. User dismissal closes the hook's own
+ *  state. */
+export declare function useImperativeAlertDialog(): ImperativeAlertDialogReturn;

package/types/generated/use-imperative-dialog.d.ts

@@ -0,0 +1,6 @@
+import type { ImperativeDialogReturn } from './props.js';
+/**  Imperative dialog control (Astryx `useImperativeDialog`). `show()`
+ *  mounts the dialog with arbitrary content; `element` renders it — keep
+ *  it mounted in the tree. The hook owns open state; user dismissal is
+ *  reported back as `isOpen: false` (the hook closes itself). */
+export declare function useImperativeDialog(): ImperativeDialogReturn;

package/types/generated/use-imperative-dialog.web.d.ts

@@ -0,0 +1,6 @@
+import type { ImperativeDialogReturn } from './props.js';
+/**  Imperative dialog control (Astryx `useImperativeDialog`). `show()`
+ *  mounts the dialog with arbitrary content; `element` renders it — keep
+ *  it mounted in the tree. The hook owns open state; user dismissal is
+ *  reported back as `isOpen: false` (the hook closes itself). */
+export declare function useImperativeDialog(): ImperativeDialogReturn;

package/types/generated/use-layer.d.ts

@@ -0,0 +1,8 @@
+import type { ContextLayerReturn, FixedLayerOptions, FixedLayerReturn, LayerOptions } from './props.js';
+/**
+ * Anchored-layer primitive (Astryx `useLayer`), native-default/macOS leaf.
+ * The AppKit host bridge presents a self-drawn in-window view (`showLayer`).
+ * Context mode measures the ref view; fixed/custom use top-left window points. The panel is a separate
+ * Octane root; `render` passes updated content and surface props to that root
+ * while the layer is open. Context from the declaring tree is not shared. */
+export declare function useLayer<O extends LayerOptions>(options: O): O extends FixedLayerOptions ? FixedLayerReturn : ContextLayerReturn;

package/types/generated/use-layer.mobile.d.ts

@@ -0,0 +1,7 @@
+import type { ContextLayerReturn, FixedLayerOptions, FixedLayerReturn, LayerOptions } from './props.js';
+/**
+ * Anchored-layer primitive (Astryx `useLayer`), iOS/Android leaf. Context
+ * mode delegates to `Popover` — JS measure/flip placement on the page's
+ * RootLayout, not CSS anchor positioning. Logical sides and horizontal alignment use the anchor's effective OS direction. Fixed mode positions at page-coordinate x/y. The
+ * layer is a separate Octane root: pass data as props, not context. */
+export declare function useLayer<O extends LayerOptions>(options: O): O extends FixedLayerOptions ? FixedLayerReturn : ContextLayerReturn;

package/types/generated/use-layer.web.d.ts

@@ -0,0 +1,9 @@
+import type { ContextLayerReturn, FixedLayerOptions, FixedLayerReturn, LayerOptions } from './props.js';
+/**
+ * Anchored-layer primitive (Astryx `useLayer`). Context mode positions a
+ * portal layer against the `ref`-bound anchor — flip/clamp rides the shared
+ * `positionPopover` geometry instead of CSS anchor positioning; `ref` still
+ * stamps `anchor-name` (`anchorId`) so `positioning: 'custom'` render props
+ * can author native CSS `anchor()` insets. Fixed mode positions at explicit
+ * viewport x/y. Content only mounts while open. */
+export declare function useLayer<O extends LayerOptions>(options: O): O extends FixedLayerOptions ? FixedLayerReturn : ContextLayerReturn;

package/types/generated/use-lightbox.d.ts

@@ -0,0 +1,3 @@
+import type { UseLightboxOptions, UseLightboxReturn } from './props.js';
+/**  Imperative lightbox control (Astryx `useLightbox`), native leaf. */
+export declare function useLightbox(options: UseLightboxOptions): UseLightboxReturn;

package/types/generated/use-lightbox.web.d.ts

@@ -0,0 +1,5 @@
+import type { UseLightboxOptions, UseLightboxReturn } from './props.js';
+/**  Imperative lightbox control (Astryx `useLightbox`): `open(index)`
+ *  shows the viewer; `triggerProps`/`getTriggerProps` spread onto a
+ *  trigger element. `element` renders the lightbox — keep it mounted. */
+export declare function useLightbox(options: UseLightboxOptions): UseLightboxReturn;

package/types/generated/use-scrollable-area.d.ts

@@ -0,0 +1,10 @@
+import type { UseScrollableAreaOptions, UseScrollableAreaResult } from './props.js';
+/**
+ * Headless scroll-viewport behavior (Astryx `useScrollableArea`), native
+ * leaf. NS ScrollView reports `scrollableWidth/Height` + offsets through
+ * its `scroll` event; `layoutChanged` on the viewport covers content
+ * resize. The getters merge `ref` (element hook) and `accessibilityLabel`
+ * — there is no tab stop, role, overscroll-chaining, or sticky
+ * containment to own on native, so `keyboardAccess`, `overscroll`, and
+ * `stickyContainment` are accepted but inert. */
+export declare function useScrollableArea(options?: UseScrollableAreaOptions): UseScrollableAreaResult;

package/types/generated/use-scrollable-area.web.d.ts

@@ -0,0 +1,9 @@
+import type { UseScrollableAreaOptions, UseScrollableAreaResult } from './props.js';
+/**
+ * Headless scroll-viewport behavior (Astryx `useScrollableArea`), web leaf.
+ * Observes the bound viewport + content with ResizeObserver and `scroll`
+ * and reports per-axis overflow/edge state; the getters merge the owned
+ * semantics (overflow, overscroll, tab stop, role/label, data attributes)
+ * into caller props. The getters compose their internal ref with the caller's `ref`, for either
+ * a host element or a shared primitive. */
+export declare function useScrollableArea(options?: UseScrollableAreaOptions): UseScrollableAreaResult;

package/types/generated/useChatComposerTokens.d.ts

@@ -0,0 +1,9 @@
+import type { UseChatComposerTokensOptions, UseChatComposerTokensReturn } from './props.js';
+import { isCustomToken } from './chat-tokens.js';
+export { isCustomToken };
+/**  Token bookkeeping for the native composer input. Native has no
+ *  contenteditable, so `editableRef.current` is the host object the native
+ *  ChatComposerInput installs: `{ insertTokenAtCaret, expandTokenToText }`.
+ *  The hook owns only the portal-style record list (`tokenPortals` carries
+ *  token entries; `span` is the chip's host marker, not a DOM node). */
+export declare function useChatComposerTokens({ editableRef, onEmitChange }: UseChatComposerTokensOptions): UseChatComposerTokensReturn;

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

@@ -0,0 +1,10 @@
+import type { UseChatComposerTokensOptions, UseChatComposerTokensReturn } from './props.js';
+import { isCustomToken } from './chat-tokens.web.js';
+export { isCustomToken };
+export declare const TOKEN_ATTR = "data-vx-chat-token";
+export declare const TOKEN_VALUE_ATTR = "data-vx-chat-token-value";
+export declare const TOKEN_ID_ATTR = "data-vx-chat-token-id";
+/**  Inline token chips inside the web contenteditable: insert at caret into
+ *  a non-editable span (portal-rendered), backspace/paste interception near
+ *  tokens, expansion back to text, and portal cleanup after DOM changes. */
+export declare function useChatComposerTokens({ editableRef, onEmitChange }: UseChatComposerTokensOptions): UseChatComposerTokensReturn;

package/types/generated/useChatDictation.d.ts

@@ -0,0 +1,6 @@
+/**  @jsxImportSource @nativescript-community/octane */
+import type { UseChatDictationOptions, UseChatDictationReturn } from './props.js';
+/**  Dictation — same contract as web, but there is no shared speech engine
+ *  on native: `isSupported` is false and controls are inert (the speech
+ *  recognition API is browser-only; a plugin leaf could host a real one). */
+export declare function useChatDictation(options?: UseChatDictationOptions): UseChatDictationReturn;

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

@@ -0,0 +1,6 @@
+import type { UseChatDictationOptions, UseChatDictationReturn } from './props.js';
+/**  Dictation for the chat composer — useSpeechRecognition plus a
+ *  calibrated volume/bands analyser, start/stop audio cues, sustained-volume
+ *  CAPS transform, and interim ghost text inside the composer input when
+ *  `inputRef` is supplied (`.vx-chatinput` contenteditable). */
+export declare function useChatDictation(options?: UseChatDictationOptions): UseChatDictationReturn;

package/types/generated/useChatNewMessages.d.ts

@@ -0,0 +1,6 @@
+import type { UseChatNewMessagesOptions, UseChatNewMessagesReturn } from './props.js';
+/**  Flags new chat messages while the scroll is unlocked. `contentRef`
+ *  attaches to the message column view and listens to `layoutChanged`
+ *  (native's ResizeObserver equivalent): every size change fires
+ *  `onResize`, and a changed last child view sets `hasNewMessages`. */
+export declare function useChatNewMessages({ isLocked, onResize }: UseChatNewMessagesOptions): UseChatNewMessagesReturn;

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

@@ -0,0 +1,6 @@
+import type { UseChatNewMessagesOptions, UseChatNewMessagesReturn } from './props.js';
+/**  Flags new chat messages while the scroll is unlocked. `contentRef`
+ *  attaches a ResizeObserver to the message column: every size change fires
+ *  `onResize` (so the scroll hook can follow streaming growth), and a
+ *  changed last `.vx-chatmsg` element sets `hasNewMessages`. */
+export declare function useChatNewMessages({ isLocked, onResize }: UseChatNewMessagesOptions): UseChatNewMessagesReturn;

package/types/generated/useChatPasteAsToken.d.ts

@@ -0,0 +1,7 @@
+import type { UseChatPasteAsTokenOptions, UseChatPasteAsTokenReturn } from './props.js';
+/**  Converts long pastes into token chips — pastes over `threshold` chars call
+ *  `inputRef.current.insertToken` instead of inserting raw text. The hook is
+ *  portable (it only talks to the input handle); on native there is no paste
+ *  event to intercept, so wire it only where paste events exist (web), or
+ *  call `onPaste` yourself from a custom native input. */
+export declare function useChatPasteAsToken({ inputRef, threshold, toToken }: UseChatPasteAsTokenOptions): UseChatPasteAsTokenReturn;

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

@@ -0,0 +1,4 @@
+import type { UseChatPasteAsTokenOptions, UseChatPasteAsTokenReturn } from './props.js';
+/**  Converts long pastes into token chips — pastes over `threshold` chars call
+ *  `inputRef.current.insertToken` instead of inserting raw text. */
+export declare function useChatPasteAsToken({ inputRef, threshold, toToken }: UseChatPasteAsTokenOptions): UseChatPasteAsTokenReturn;

package/types/generated/useChatStreamScroll.d.ts

@@ -0,0 +1,7 @@
+import type { UseChatStreamScrollOptions, UseChatStreamScrollReturn } from './props.js';
+/**  Native follow-the-stream scroll behavior. `scrollRef.current` is the NS
+ *  ScrollView (ChatLayout binds it). Lock/unlock semantics match web:
+ *  scrolling up unlocks, settling near the bottom re-locks. The spring maps
+ *  to the platform's animated scroll (`scrollToVerticalOffset(_, true)`);
+ *  `behavior:'instant'` jumps. */
+export declare function useChatStreamScroll({ scrollRef, enabled, lockThreshold, buttonThreshold }: UseChatStreamScrollOptions): UseChatStreamScrollReturn;

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

@@ -0,0 +1,6 @@
+import type { UseChatStreamScrollOptions, UseChatStreamScrollReturn } from './props.js';
+/**  Follow-the-stream scroll behavior for a chat container: locked (default)
+ *  springs to the bottom on growth; any upward scroll unlocks; settling at
+ *  the bottom re-locks. `scrollToBottom({behavior:'instant'})` jumps in one
+ *  frame. The first fill positions instantly; only later growth animates. */
+export declare function useChatStreamScroll({ scrollRef, enabled, lockThreshold, buttonThreshold, damping, stiffness, mass }: UseChatStreamScrollOptions): UseChatStreamScrollReturn;

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

@@ -0,0 +1,6 @@
+export interface UseMediaQueryOptions {
+    /**  Initial match before the media query can be read (SSR/first paint). */
+    defaultIsMobile?: boolean;
+}
+/**  useMediaQuery — width/media-condition subscription for web leaves. */
+export declare function useMediaQuery(query: string, options?: UseMediaQueryOptions): boolean;

package/types/generated/useResizable.d.ts

@@ -0,0 +1,8 @@
+import type { ResizableRegion, UseResizableMultiConfig, UseResizableSingleConfig } from './props.js';
+/**
+ * useResizable — resizable-region state for ResizeHandle and host
+ * components (SideNav). A single config yields one region; `regions`
+ * yields an independent region per stable key (upstream contract: keys
+ * must not change between renders). */
+export declare function useResizable(config: UseResizableSingleConfig): ResizableRegion;
+export declare function useResizable(config: UseResizableMultiConfig): Record<string, ResizableRegion>;

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

@@ -0,0 +1,8 @@
+import type { ResizableRegion, UseResizableMultiConfig, UseResizableSingleConfig } from './props.js';
+/**
+ * useResizable — resizable-region state for ResizeHandle and host
+ * components (SideNav). A single config yields one region; `regions`
+ * yields an independent region per stable key (upstream contract: keys
+ * must not change between renders). */
+export declare function useResizable(config: UseResizableSingleConfig): ResizableRegion;
+export declare function useResizable(config: UseResizableMultiConfig): Record<string, ResizableRegion>;

package/types/generated/useSelect.d.ts

@@ -0,0 +1,25 @@
+import type { SelectOption, SelectProps } from './props.js';
+/** Shared finite-list state; platform leaves own focus, events, and hosting. */
+export declare function useSelect(props: SelectProps): {
+    open: boolean;
+    selected: string[];
+    query: string;
+    groups: {
+        heading: string | undefined;
+        options: SelectOption[];
+    }[];
+    shown: SelectOption[];
+    enabled: SelectOption[];
+    selectAllState: "checked" | "indeterminate" | "unchecked";
+    busy: boolean;
+    pending: boolean;
+    blocked: boolean;
+    triggerText: string;
+    emptyText: string;
+    announcement: string;
+    setOpen: (next: boolean) => void;
+    setQuery: (next: string) => void;
+    pick: (option: SelectOption) => void;
+    clear: () => void;
+    selectAll: () => void;
+};

package/types/generated/useSpeechRecognition.d.ts

@@ -0,0 +1,6 @@
+import type { UseSpeechRecognitionOptions, UseSpeechRecognitionReturn } from './props.js';
+/**  Speech recognition is a browser API — native has no shared engine in
+ *  `ui` (a plugin-backed leaf package could host one). The contract is
+ *  honest rather than absent: `isSupported` is false and the controls are
+ *  inert no-ops. */
+export declare function useSpeechRecognition(_options?: UseSpeechRecognitionOptions): UseSpeechRecognitionReturn;

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

@@ -0,0 +1,5 @@
+import type { UseSpeechRecognitionOptions, UseSpeechRecognitionReturn } from './props.js';
+/**  Web SpeechRecognition wrapper: start/stop/abort/toggle, interim +
+ *  final transcripts, live mic volume + voice bands via an AudioContext
+ *  analyser with noise-floor calibration. */
+export declare function useSpeechRecognition(options?: UseSpeechRecognitionOptions): UseSpeechRecognitionReturn;

package/types/generated/useTriggerMenu.d.ts

@@ -0,0 +1,72 @@
+import type { ChatComposerTrigger, ChatComposerTriggerItem } from './props.js';
+export interface TriggerMenuState {
+    isActive: boolean;
+    activeTrigger: ChatComposerTrigger | null;
+    query: string;
+    items: ChatComposerTriggerItem[];
+    highlightedIndex: number;
+    isLoading: boolean;
+}
+export interface UseTriggerMenuOptions {
+    triggers?: ChatComposerTrigger[];
+    /**  Host adapter installed by the native input — reads the field text and
+ *  caret, splices trigger text out, and anchors the menu to the field. */
+    hostRef: {
+        current: ChatTriggerHost | null;
+    };
+    onInsertToken: (token: any) => void;
+    onInsertText: (text: string) => void;
+    onEmitChange: () => void;
+    debounceMs?: number;
+}
+/**  What the trigger menu needs from the native text host. */
+export interface ChatTriggerHost {
+    getText(): string;
+    getCaretOffset(): number;
+    spliceText(start: number, end: number, insert: string): void;
+    anchorView: any;
+}
+interface TriggerMenuItemsProps {
+    state: TriggerMenuState;
+    selectItem(item: ChatComposerTriggerItem): void;
+}
+interface TriggerMenuOverlayProps extends TriggerMenuItemsProps {
+    anchor: any;
+    onDismiss(): void;
+}
+export declare function ChatTriggerMenuOverlay(props: TriggerMenuOverlayProps): unknown;
+/**  Trigger-character menus for the native composer input — same contract as
+ *  the web version: detect a trigger run before the caret, search the
+ *  trigger's source (debounced when async), anchor a Popover to the field,
+ *  tap to select. Hardware-keyboard arrow navigation isn't wired — the
+ *  highlighted index still tracks for consumers that drive it. */
+export declare function useTriggerMenu(options: UseTriggerMenuOptions): {
+    state: TriggerMenuState;
+    handleInput: () => void;
+    handleKeyDown: (e: any) => boolean;
+    anchor: {
+        current: unknown;
+    };
+    selectItem: (item: ChatComposerTriggerItem) => void;
+    reset: () => void;
+    ariaProps: {
+        readonly role: "textbox";
+        readonly 'aria-multiline': "true";
+        readonly 'aria-expanded'?: undefined;
+        readonly 'aria-controls'?: undefined;
+        readonly 'aria-haspopup'?: undefined;
+    } | {
+        readonly role: "combobox";
+        readonly 'aria-expanded': true;
+        readonly 'aria-controls': string;
+        readonly 'aria-multiline'?: undefined;
+        readonly 'aria-haspopup'?: undefined;
+    } | {
+        readonly role: "combobox";
+        readonly 'aria-expanded': false;
+        readonly 'aria-haspopup': "listbox";
+        readonly 'aria-multiline'?: undefined;
+        readonly 'aria-controls'?: undefined;
+    };
+};
+export {};