@octane-xplat/ui 0.9.0 → 0.10.0

package/types/generated/TopNav.d.ts

@@ -0,0 +1,25 @@
+import type { TopNavHeadingProps, TopNavItemProps, TopNavMenuProps, TopNavMegaMenuProps, TopNavMegaMenuItemProps, TopNavMegaMenuFeaturedCardProps, TopNavProps } from './props.js';
+import { TopNavMobileContentContext, TopNavRenderContext, TopNavSlotContext, useTopNavMobileContent, useTopNavRenderMode, useTopNavSlot } from './nav-contexts.js';
+export { TopNavRenderContext, TopNavSlotContext, TopNavMobileContentContext, useTopNavRenderMode, useTopNavSlot, useTopNavMobileContent };
+/**  TopNav — the app's top navigation bar. Native leaf: the same three
+ *  render modes — `default` full bar, `mobile-bar` (heading + end +
+ *  toggle), `drawer` (content inside MobileNav). Hover-driven menus open on
+ *  tap on pointer platforms. */
+export declare function TopNav(props: TopNavProps): unknown;
+/**  TopNavHeading — the brand block: logo + heading link with optional
+ *  super/subheading lines and an optional heading menu popover. */
+export declare function TopNavHeading(props: TopNavHeadingProps): unknown;
+/**  TopNavItem — one nav link in the bar. Native leaf: Pressable rows;
+ *  `href` routes through `followHref`. */
+export declare function TopNavItem(props: TopNavItemProps): unknown;
+/**  TopNavMenu — trigger that opens a list popover on press (hover platforms
+ *  get hover intent in the web leaf). */
+export declare function TopNavMenu(props: TopNavMenuProps): unknown;
+/**  TopNavMegaMenu — trigger opening a wide panel with an items grid plus an
+ *  optional featured panel. Native leaf: a press-opened anchored popover. */
+export declare function TopNavMegaMenu(props: TopNavMegaMenuProps): unknown;
+/**  TopNavMegaMenuItem — one link in the mega menu items grid. */
+export declare function TopNavMegaMenuItem(props: TopNavMegaMenuItemProps): unknown;
+/**  TopNavMegaMenuFeaturedCard — the marketing card inside a mega menu's
+ *  featured panel. */
+export declare function TopNavMegaMenuFeaturedCard(props: TopNavMegaMenuFeaturedCardProps): unknown;

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

@@ -0,0 +1,23 @@
+import type { TopNavHeadingProps, TopNavItemProps, TopNavMenuProps, TopNavMegaMenuProps, TopNavMegaMenuItemProps, TopNavMegaMenuFeaturedCardProps, TopNavProps } from './props.js';
+import { TopNavMobileContentContext, TopNavRenderContext, TopNavSlotContext, useTopNavMobileContent, useTopNavRenderMode, useTopNavSlot } from './nav-contexts.js';
+export { TopNavRenderContext, TopNavSlotContext, TopNavMobileContentContext, useTopNavRenderMode, useTopNavSlot, useTopNavMobileContent };
+/**  TopNav — the app's top navigation bar. Three render modes: `default`
+ *  (full bar), `mobile-bar` (heading + end + toggle, set by AppShell below
+ *  the breakpoint), and `drawer` (content inside the MobileNav overlay). */
+export declare function TopNav(props: TopNavProps): import("octane/jsx-runtime").JSX.Element;
+/**  TopNavHeading — the brand block: logo + heading link with optional
+ *  super/subheading lines and an optional heading menu popover. */
+export declare function TopNavHeading(props: TopNavHeadingProps): import("octane/jsx-runtime").JSX.Element;
+/**  TopNavItem — one nav link in the bar (start/center/end slots); in the
+ *  drawer render mode it stretches to a full-width row. */
+export declare function TopNavItem(props: TopNavItemProps): import("octane/jsx-runtime").JSX.Element;
+/**  TopNavMenu — trigger that opens a list popover on hover or press. */
+export declare function TopNavMenu(props: TopNavMenuProps): import("octane/jsx-runtime").JSX.Element;
+/**  TopNavMegaMenu — trigger opening a wide panel with an items grid plus an
+ *  optional featured panel. */
+export declare function TopNavMegaMenu(props: TopNavMegaMenuProps): import("octane/jsx-runtime").JSX.Element;
+/**  TopNavMegaMenuItem — one link in the mega menu items grid. */
+export declare function TopNavMegaMenuItem(props: TopNavMegaMenuItemProps): import("octane/jsx-runtime").JSX.Element;
+/**  TopNavMegaMenuFeaturedCard — the marketing card inside a mega menu's
+ *  featured panel. */
+export declare function TopNavMegaMenuFeaturedCard(props: TopNavMegaMenuFeaturedCardProps): import("octane/jsx-runtime").JSX.Element;

package/types/generated/Typeahead.d.ts

@@ -0,0 +1,6 @@
+import type { SearchableItem, TypeaheadProps } from "./props.js";
+/**  Single-selection search-as-you-type field: Field chrome + input wrapper +
+ *  a Token over the input while a value is selected. Tapping the token or
+ *  wrapper enters edit mode (input repopulated with the label); leaving the
+ *  field without selecting restores the token. */
+export declare function Typeahead<T extends SearchableItem>(props: TypeaheadProps<T>): unknown;

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

@@ -0,0 +1,6 @@
+import type { SearchableItem, TypeaheadProps } from "./props.js";
+/**  Single-selection search-as-you-type field: Field chrome + input wrapper +
+ *  a Token painted over the input while a value is selected. Clicking the
+ *  token or wrapper enters edit mode (input repopulated with the label);
+ *  blur or Escape without a selection restores the token. */
+export declare function Typeahead<T extends SearchableItem>(props: TypeaheadProps<T>): import("octane/jsx-runtime").JSX.Element;

package/types/generated/TypeaheadItem.d.ts

@@ -0,0 +1,4 @@
+import type { SearchableItem, TypeaheadItemProps } from "./props.js";
+/**  Default option content for typeahead dropdowns — label with an optional
+ *  leading icon and supporting description. `item.element` wins when set. */
+export declare function TypeaheadItem<T extends SearchableItem>(props: TypeaheadItemProps<T>): unknown;

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

@@ -0,0 +1,5 @@
+import type { SearchableItem, TypeaheadItemProps } from "./props.js";
+/**  Default option content for typeahead dropdowns — label with an optional
+ *  leading icon and supporting description. `item.element` wins when set.
+ *  Exported for use in custom `renderItem` implementations. */
+export declare function TypeaheadItem<T extends SearchableItem>(props: TypeaheadItemProps<T>): import("octane/jsx-runtime").JSX.Element;

package/types/generated/VStack.d.ts

@@ -0,0 +1,5 @@
+/**  @jsxImportSource @nativescript-community/octane */
+import type { VStackProps } from './props.js';
+/**  Vertical flow stack — `Stack` with `direction="vertical"`.
+ *  `vAlign` is the main axis (justify-content), `hAlign` the cross axis. */
+export declare function VStack(props: VStackProps): unknown;

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

@@ -2,6 +2,6 @@ import type { ViewProps } from './props.js';
 /**  Neutral flex-column container — the RN-shaped default block.
  *  onPan is pointer plumbing: pointerdown/move/up on the element.
  *  pointermove isn't in octane's delegated-event set, so the leaf attaches
- *  raw listeners via a ref — that's why `bind` exists. Payloads normalize
+ *  raw listeners through its internal ref. Payloads normalize
  *  to the shared shape {x,y,dx,dy,vx,vy,state,target}. */
 export declare function View(props: ViewProps): import("octane/jsx-runtime").JSX.Element;

package/types/generated/VisuallyHidden.d.ts

@@ -0,0 +1,6 @@
+import type { VisuallyHiddenProps } from './props.js';
+/**  VisuallyHidden — a 1dip, fully transparent container that keeps its
+ *  subtree in the native accessibility tree (opacity:0 views stay exposed
+ *  to TalkBack/VoiceOver, unlike visibility=hidden which drops them on
+ *  iOS). For screen-reader labels and live-region announcements. */
+export declare function VisuallyHidden(props: VisuallyHiddenProps): unknown;

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

@@ -0,0 +1,6 @@
+import type { VisuallyHiddenProps } from './props.js';
+/**  VisuallyHidden — content stays in the a11y tree / DOM flow but renders
+ *  at a clipped 1px box. No style/className: restyling a hidden node is a
+ *  bug waiting to ship. `as` picks the tag ('span' inline default; 'div'
+ *  for live regions / block announcements). */
+export declare function VisuallyHidden(props: VisuallyHiddenProps): import("octane/jsx-runtime").JSX.Element;

package/types/generated/aliases.d.ts

@@ -1,7 +1,3 @@
-import type { SelectProps } from './props.js';
+import type { MultiSelectorProps } from './props.js';
 /**  SelectMenu — multi-select anchored listbox (Select with `multiple`). */
-export declare function SelectMenu(props: SelectProps): unknown;
-/**  Combobox — searchable anchored listbox (Select with `searchable`). */
-export declare function Combobox(props: SelectProps): unknown;
-/**  InputMenu — alias of Combobox (searchable anchored listbox). */
-export declare function InputMenu(props: SelectProps): unknown;
+export declare function SelectMenu(props: MultiSelectorProps): unknown;

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

@@ -1,7 +1,3 @@
-import type { SelectProps } from './props.js';
+import type { MultiSelectorProps } from './props.js';
 /**  SelectMenu — multi-select anchored listbox (Select with `multiple`). */
-export declare function SelectMenu(props: SelectProps): import("octane/jsx-runtime").JSX.Element;
-/**  Combobox — searchable anchored listbox (Select with `searchable`). */
-export declare function Combobox(props: SelectProps): import("octane/jsx-runtime").JSX.Element;
-/**  InputMenu — alias of Combobox (searchable anchored listbox). */
-export declare function InputMenu(props: SelectProps): import("octane/jsx-runtime").JSX.Element;
+export declare function SelectMenu(props: MultiSelectorProps): import("octane/jsx-runtime").JSX.Element;

package/types/generated/android/DrawerLayout.android.d.ts

@@ -1,10 +1,4 @@
-import { Drawer as NSDrawer } from '@nativescript-community/ui-drawer';
 import type { DrawerProps, PlatformWidgetProps } from '../props.js';
-declare module '@nativescript-community/octane/intrinsics' {
-    interface NativeScriptElements {
-        drawer: Attributes<typeof NSDrawer>;
-    }
-}
 /**  DrawerLayout — ui-drawer host (AndroidX DrawerLayout behavior via the
  *  plugin). `main`/`drawer` are slot props wired via the driver's hostSlot
  *  mechanism; `open` drives the imperative open()/close(). Slot hosts are

package/types/generated/android/RecyclerView.android.d.ts

@@ -1,14 +1,15 @@
-import type { ListProps, PlatformWidgetProps } from "../props.js";
-/**  RecyclerView — the platform recycling list (Android RecyclerView via
- *  NativeScript `listview`). `items` is a plain array, ItemsSource, or
+import type { PlatformListProps, PlatformWidgetProps } from "../props.js";
+/**  RecyclerView — the Android public compatibility name for NativeScript
+ *  `listview`, backed by `android.widget.ListView`/`AbsListView` in core
+ *  9.1.x. `items` is a plain array, ItemsSource, or
  *  ObservableArray — the driver binds `items[index]` into the recycled
  *  cell's root and skips rebinds whose row, item, and renderer are
  *  unchanged. Cell identity = the recycled host view, not the item.
- *  The shared `ui` export has no List — compose ScrollView + mapped
- *  children there.
+ *  The shared `List` is a fully rendered content list, not an OS-backed
+ *  recycled collection. Use `VirtualList` for portable windowing.
  *
  *  `refreshing`/`onRefresh`/`refreshThreshold` enable pull-to-refresh:
  *  the indicator is self-drawn (vx-spinner) and the list is translated
  *  inside a clipped wrapper while the drag accumulates — no
- *  SwipeRefreshLayout, so the pixels match the shared ScrollView path. */
-export declare function RecyclerView(props: PlatformWidgetProps<ListProps>): unknown;
+ *  SwipeRefreshLayout, so the pixels match the shared ScrollableArea path. */
+export declare function RecyclerView(props: PlatformWidgetProps<PlatformListProps>): unknown;

package/types/generated/android/index.d.ts

@@ -9,4 +9,4 @@ export { openModal } from './openModal.android.js';
 export { DrawerLayout } from './DrawerLayout.android.js';
 export { Icon } from './icon.android.js';
 export { modifier } from '../modifier-factories.js';
-export type { SwitchProps, SliderProps, ActivityIndicatorProps, ListProps, TabsProps, ModalProps, ModalOpenOptions, ModalOpenResult, OpenModal, DrawerProps, NativeModifier, NativeModifierValue, PlatformIconChoice, PlatformTabSpec, PlatformTabsProps, PlatformWidgetProps, RefreshProps, } from '../props.js';
+export type { SwitchProps, SliderProps, ActivityIndicatorProps, PlatformListProps as ListProps, ListVisibleItem, ListViewabilityChange, ListViewabilityInfo, ListViewabilityConfig, PlatformListHandle, TabsProps, ModalProps, ModalOpenOptions, ModalOpenResult, OpenModal, DrawerProps, NativeModifier, NativeModifierValue, PlatformIconChoice, PlatformTabSpec, PlatformTabsProps, PlatformWidgetProps, RefreshProps, } from '../props.js';

package/types/generated/anim.d.ts

@@ -1,10 +1,3 @@
-/**
- * Imperative animation value (decision #10 — no worklets; JS runs on the UI
- * thread on NS so a rAF tween writes the view directly). `bind` is a leaf
- * `bind` prop target: the leaf forwards it to the intrinsic's `ref`, and the
- * runtime hands us the NS view. */
-export type { AnimatedValue } from './props.js';
 import type { AnimatedValue } from './props.js';
-/**  useAnimation — a stable animated value across renders. `prop` is the NS
- *  view property written per frame (translateX default). */
+export type { AnimatedValue } from './props.js';
 export declare function useAnimation(initial?: number, prop?: string): AnimatedValue;

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

@@ -1,3 +1,3 @@
-export type { AnimatedValue } from './props.js';
 import type { AnimatedValue } from './props.js';
+export type { AnimatedValue } from './props.js';
 export declare function useAnimation(initial?: number, prop?: string): AnimatedValue;

package/types/generated/animated-value.d.ts

@@ -0,0 +1,12 @@
+import type { AnimatedValue } from './props.js';
+/** Host scheduling and writes stay outside the shared UI animation contract. */
+export interface AnimationHost {
+    now(): number;
+    request(callback: () => void): number;
+    cancel(id: number): void;
+    write(view: any, value: number): void;
+    reducedMotion?(): boolean;
+}
+export declare function createAnimatedValue(initial: number, host: AnimationHost): AnimatedValue & {
+    dispose(): void;
+};

package/types/generated/app-shell-config.d.ts

@@ -0,0 +1,5 @@
+import type { MobileNavConfig } from './props.js';
+/** Distinguish the plain mobile-nav options object from a portable child.
+ *  JSX elements and arrays remain opaque values; no renderer element API is
+ *  needed in shared/native modules. */
+export declare function isMobileNavConfig(value: unknown): value is MobileNavConfig;

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-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.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.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 };