@thelacanians/vue-native-runtime 0.4.14 → 0.6.0

package/dist/index.d.cts

@@ -1,5 +1,5 @@
 import * as _vue_runtime_core from '@vue/runtime-core';
-import { PropType, Directive, App, Component } from '@vue/runtime-core';
+import { PropType, VNode, Ref, Component, Directive, ComputedRef, App } from '@vue/runtime-core';
 export * from '@vue/runtime-core';
 import * as _vue_reactivity from '@vue/reactivity';
 
@@ -13,7 +13,7 @@ interface NativeNode {
     text?: string;
 }
 /**
- * Reset the node ID counter. Used for testing and hot reload teardown.
+ * Reset the node ID counter and active ID set. Used for testing and hot reload teardown.
  */
 declare function resetNodeId(): void;
 /**
@@ -151,8 +151,8 @@ interface ViewStyle {
     accessibilityLabel?: string;
     accessibilityRole?: string;
     accessibilityHint?: string;
-    accessibilityState?: Record<string, any>;
-    accessibilityValue?: Record<string, any>;
+    accessibilityState?: Record<string, unknown>;
+    accessibilityValue?: Record<string, unknown>;
     accessible?: boolean;
     importantForAccessibility?: ImportantForAccessibility;
 }
@@ -194,12 +194,12 @@ declare const validStyleProperties: ReadonlySet<string>;
  * Can be a ViewStyle, TextStyle, or ImageStyle from the typed interfaces,
  * or a plain record for backwards compatibility.
  */
-type StyleProp = Record<string, any>;
+type StyleProp = Record<string, unknown>;
 /**
  * The result type of createStyleSheet — keys are the same as the input,
  * values are frozen style objects.
  */
-type StyleSheet<T extends Record<string, StyleProp>> = Readonly<{
+type StyleSheet<T extends Record<string, object>> = Readonly<{
     [K in keyof T]: Readonly<T[K]>;
 }>;
 
@@ -231,7 +231,7 @@ type AnyStyle = ViewStyle | TextStyle | ImageStyle;
  * })
  * ```
  */
-declare function createStyleSheet<T extends Record<string, StyleProp>>(styles: T): StyleSheet<T>;
+declare function createStyleSheet<T extends Record<string, object>>(styles: T): StyleSheet<T>;
 
 /**
  * TypeScript prop interfaces for Vue Native components.
@@ -245,7 +245,7 @@ interface AccessibilityProps {
     accessibilityLabel?: string;
     accessibilityRole?: string;
     accessibilityHint?: string;
-    accessibilityState?: Record<string, any>;
+    accessibilityState?: Record<string, unknown>;
 }
 interface VViewProps extends AccessibilityProps {
     style?: ViewStyle;
@@ -314,9 +314,9 @@ interface VSliderProps extends AccessibilityProps {
     max?: number;
     style?: ViewStyle;
 }
-interface VListProps {
-    data: any[];
-    keyExtractor?: (item: any, index: number) => string;
+interface VListProps<T = unknown> {
+    data: T[];
+    keyExtractor?: (item: T, index: number) => string;
     estimatedItemHeight?: number;
     showsScrollIndicator?: boolean;
     bounces?: boolean;
@@ -451,18 +451,59 @@ interface VVideoProps extends AccessibilityProps {
     style?: ViewStyle;
     testID?: string;
 }
-interface VSectionListProps {
-    sections: Array<{
-        title: string;
-        data: any[];
-    }>;
-    keyExtractor?: (item: any, index: number) => string;
+interface VSectionListSection<T = unknown> {
+    title: string;
+    data: T[];
+}
+interface VSectionListProps<T = unknown> {
+    sections: VSectionListSection<T>[];
+    keyExtractor?: (item: T, index: number) => string;
     estimatedItemHeight?: number;
     stickySectionHeaders?: boolean;
     showsScrollIndicator?: boolean;
     bounces?: boolean;
     style?: ViewStyle;
 }
+interface VFlatListProps<T = unknown, TRendered = unknown> {
+    data: T[];
+    renderItem?: (info: {
+        item: T;
+        index: number;
+    }) => TRendered;
+    keyExtractor?: (item: T, index: number) => string | number;
+    itemHeight: number;
+    windowSize?: number;
+    style?: ViewStyle;
+    showsScrollIndicator?: boolean;
+    bounces?: boolean;
+    headerHeight?: number;
+    endReachedThreshold?: number;
+}
+interface VTabBarProps {
+    tabs: Array<{
+        id: string;
+        label: string;
+        icon?: string;
+        badge?: number | string;
+    }>;
+    activeTab: string;
+    position?: 'top' | 'bottom';
+}
+interface VDrawerProps {
+    open?: boolean;
+    position?: 'left' | 'right';
+    width?: number;
+    closeOnPress?: boolean;
+}
+interface VDrawerItemProps extends AccessibilityProps {
+    icon?: string;
+    label: string;
+    badge?: number | string | null;
+    disabled?: boolean;
+}
+interface VDrawerSectionProps {
+    title?: string;
+}
 
 /**
  * VView — the fundamental container component in Vue Native.
@@ -976,10 +1017,10 @@ declare const VImage: _vue_runtime_core.DefineComponent<_vue_runtime_core.Extrac
     accessibilityHint: StringConstructor;
     accessibilityState: ObjectConstructor;
 }>> & Readonly<{
-    onLoad?: ((...args: any[]) => any) | undefined;
     onError?: ((...args: any[]) => any) | undefined;
+    onLoad?: ((...args: any[]) => any) | undefined;
 }>, {
-    resizeMode: "cover" | "contain" | "stretch" | "center";
+    resizeMode: "center" | "stretch" | "cover" | "contain";
 }, {}, {}, {}, string, _vue_runtime_core.ComponentProvideOptions, true, {}, any>;
 
 /**
@@ -1099,13 +1140,13 @@ declare const VSlider: _vue_runtime_core.DefineComponent<_vue_runtime_core.Extra
 declare const VList: _vue_runtime_core.DefineComponent<_vue_runtime_core.ExtractPropTypes<{
     /** Array of data items to render */
     data: {
-        type: () => any[];
+        type: PropType<unknown[]>;
         required: true;
     };
     /** Extract a unique key from each item. Defaults to index as string. */
     keyExtractor: {
-        type: () => (item: any, index: number) => string;
-        default: (_item: any, index: number) => string;
+        type: PropType<(item: unknown, index: number) => string>;
+        default: (_item: unknown, index: number) => string;
     };
     /** Estimated height per row in points. Used before layout runs. Default: 44 */
     estimatedItemHeight: {
@@ -1131,18 +1172,18 @@ declare const VList: _vue_runtime_core.DefineComponent<_vue_runtime_core.Extract
         type: PropType<ViewStyle>;
         default: () => {};
     };
-}>, () => _vue_runtime_core.VNode<_vue_runtime_core.RendererNode, _vue_runtime_core.RendererElement, {
+}>, () => VNode<_vue_runtime_core.RendererNode, _vue_runtime_core.RendererElement, {
     [key: string]: any;
 }>, {}, {}, {}, _vue_runtime_core.ComponentOptionsMixin, _vue_runtime_core.ComponentOptionsMixin, ("scroll" | "endReached")[], "scroll" | "endReached", _vue_runtime_core.PublicProps, Readonly<_vue_runtime_core.ExtractPropTypes<{
     /** Array of data items to render */
     data: {
-        type: () => any[];
+        type: PropType<unknown[]>;
         required: true;
     };
     /** Extract a unique key from each item. Defaults to index as string. */
     keyExtractor: {
-        type: () => (item: any, index: number) => string;
-        default: (_item: any, index: number) => string;
+        type: PropType<(item: unknown, index: number) => string>;
+        default: (_item: unknown, index: number) => string;
     };
     /** Estimated height per row in points. Used before layout runs. Default: 44 */
     estimatedItemHeight: {
@@ -1175,7 +1216,7 @@ declare const VList: _vue_runtime_core.DefineComponent<_vue_runtime_core.Extract
     style: ViewStyle;
     horizontal: boolean;
     bounces: boolean;
-    keyExtractor: (item: any, index: number) => string;
+    keyExtractor: (item: unknown, index: number) => string;
     estimatedItemHeight: number;
     showsScrollIndicator: boolean;
 }, {}, {}, {}, string, _vue_runtime_core.ComponentProvideOptions, true, {}, any>;
@@ -1260,7 +1301,7 @@ declare const VAlertDialog: _vue_runtime_core.DefineComponent<_vue_runtime_core.
     };
 }>, () => _vue_runtime_core.VNode<_vue_runtime_core.RendererNode, _vue_runtime_core.RendererElement, {
     [key: string]: any;
-}>, {}, {}, {}, _vue_runtime_core.ComponentOptionsMixin, _vue_runtime_core.ComponentOptionsMixin, ("confirm" | "cancel" | "action")[], "confirm" | "cancel" | "action", _vue_runtime_core.PublicProps, Readonly<_vue_runtime_core.ExtractPropTypes<{
+}>, {}, {}, {}, _vue_runtime_core.ComponentOptionsMixin, _vue_runtime_core.ComponentOptionsMixin, ("cancel" | "confirm" | "action")[], "cancel" | "confirm" | "action", _vue_runtime_core.PublicProps, Readonly<_vue_runtime_core.ExtractPropTypes<{
     visible: {
         type: BooleanConstructor;
         default: boolean;
@@ -1286,12 +1327,12 @@ declare const VAlertDialog: _vue_runtime_core.DefineComponent<_vue_runtime_core.
         default: string;
     };
 }>> & Readonly<{
-    onConfirm?: ((...args: any[]) => any) | undefined;
     onCancel?: ((...args: any[]) => any) | undefined;
+    onConfirm?: ((...args: any[]) => any) | undefined;
     onAction?: ((...args: any[]) => any) | undefined;
 }>, {
-    visible: boolean;
     title: string;
+    visible: boolean;
     message: string;
     buttons: AlertButton[];
     confirmText: string;
@@ -1334,8 +1375,8 @@ declare const VStatusBar: _vue_runtime_core.DefineComponent<_vue_runtime_core.Ex
         default: boolean;
     };
 }>> & Readonly<{}>, {
-    barStyle: StatusBarStyle;
     hidden: boolean;
+    barStyle: StatusBarStyle;
     animated: boolean;
 }, {}, {}, {}, string, _vue_runtime_core.ComponentProvideOptions, true, {}, any>;
 
@@ -1381,8 +1422,8 @@ declare const VWebView: _vue_runtime_core.DefineComponent<_vue_runtime_core.Extr
         default: boolean;
     };
 }>> & Readonly<{
-    onLoad?: ((...args: any[]) => any) | undefined;
     onError?: ((...args: any[]) => any) | undefined;
+    onLoad?: ((...args: any[]) => any) | undefined;
     onMessage?: ((...args: any[]) => any) | undefined;
 }>, {
     style: ViewStyle;
@@ -1574,8 +1615,8 @@ declare const VSegmentedControl: _vue_runtime_core.DefineComponent<_vue_runtime_
     onChange?: ((...args: any[]) => any) | undefined;
 }>, {
     style: ViewStyle;
-    selectedIndex: number;
     tintColor: string;
+    selectedIndex: number;
     enabled: boolean;
 }, {}, {}, {}, string, _vue_runtime_core.ComponentProvideOptions, true, {}, any>;
 
@@ -1639,8 +1680,8 @@ declare const VActionSheet: _vue_runtime_core.DefineComponent<_vue_runtime_core.
     onCancel?: ((...args: any[]) => any) | undefined;
     onAction?: ((...args: any[]) => any) | undefined;
 }>, {
-    visible: boolean;
     title: string;
+    visible: boolean;
     message: string;
     actions: ActionSheetAction[];
 }, {}, {}, {}, string, _vue_runtime_core.ComponentProvideOptions, true, {}, any>;
@@ -1784,18 +1825,18 @@ declare const VPressable: _vue_runtime_core.DefineComponent<_vue_runtime_core.Ex
  */
 interface Section {
     title: string;
-    data: any[];
+    data: unknown[];
 }
 declare const VSectionList: _vue_runtime_core.DefineComponent<_vue_runtime_core.ExtractPropTypes<{
     /** Array of section objects, each with a title and data array */
     sections: {
-        type: () => Section[];
+        type: PropType<Section[]>;
         required: true;
     };
     /** Extract a unique key from each item. Defaults to index as string. */
     keyExtractor: {
-        type: () => (item: any, index: number) => string;
-        default: (_item: any, index: number) => string;
+        type: PropType<(item: unknown, index: number) => string>;
+        default: (_item: unknown, index: number) => string;
     };
     /** Estimated height per row in points. Default: 44 */
     estimatedItemHeight: {
@@ -1821,18 +1862,18 @@ declare const VSectionList: _vue_runtime_core.DefineComponent<_vue_runtime_core.
         type: ObjectConstructor;
         default: () => {};
     };
-}>, () => _vue_runtime_core.VNode<_vue_runtime_core.RendererNode, _vue_runtime_core.RendererElement, {
+}>, () => VNode<_vue_runtime_core.RendererNode, _vue_runtime_core.RendererElement, {
     [key: string]: any;
 }>, {}, {}, {}, _vue_runtime_core.ComponentOptionsMixin, _vue_runtime_core.ComponentOptionsMixin, ("scroll" | "endReached")[], "scroll" | "endReached", _vue_runtime_core.PublicProps, Readonly<_vue_runtime_core.ExtractPropTypes<{
     /** Array of section objects, each with a title and data array */
     sections: {
-        type: () => Section[];
+        type: PropType<Section[]>;
         required: true;
     };
     /** Extract a unique key from each item. Defaults to index as string. */
     keyExtractor: {
-        type: () => (item: any, index: number) => string;
-        default: (_item: any, index: number) => string;
+        type: PropType<(item: unknown, index: number) => string>;
+        default: (_item: unknown, index: number) => string;
     };
     /** Estimated height per row in points. Default: 44 */
     estimatedItemHeight: {
@@ -1864,7 +1905,7 @@ declare const VSectionList: _vue_runtime_core.DefineComponent<_vue_runtime_core.
 }>, {
     style: Record<string, any>;
     bounces: boolean;
-    keyExtractor: (item: any, index: number) => string;
+    keyExtractor: (item: unknown, index: number) => string;
     estimatedItemHeight: number;
     showsScrollIndicator: boolean;
     stickySectionHeaders: boolean;
@@ -1923,9 +1964,9 @@ declare const VCheckbox: _vue_runtime_core.DefineComponent<_vue_runtime_core.Ext
     "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
     onChange?: ((...args: any[]) => any) | undefined;
 }>, {
+    label: string;
     disabled: boolean;
     modelValue: boolean;
-    label: string;
 }, {}, {}, {}, string, _vue_runtime_core.ComponentProvideOptions, true, {}, any>;
 
 interface RadioOption {
@@ -2168,7 +2209,7 @@ declare const VVideo: _vue_runtime_core.DefineComponent<_vue_runtime_core.Extrac
     onPause?: ((...args: any[]) => any) | undefined;
     onEnd?: ((...args: any[]) => any) | undefined;
 }>, {
-    resizeMode: "cover" | "contain" | "stretch" | "center";
+    resizeMode: "center" | "stretch" | "cover" | "contain";
     autoplay: boolean;
     loop: boolean;
     muted: boolean;
@@ -2177,130 +2218,398 @@ declare const VVideo: _vue_runtime_core.DefineComponent<_vue_runtime_core.Extrac
     volume: number;
 }, {}, {}, {}, string, _vue_runtime_core.ComponentProvideOptions, true, {}, any>;
 
-declare const ErrorBoundary: _vue_runtime_core.DefineComponent<_vue_runtime_core.ExtractPropTypes<{
-    onError: PropType<(error: Error, info: string) => void>;
-    resetKeys: {
-        type: PropType<any[]>;
-        default: () => never[];
-    };
-}>, () => _vue_runtime_core.VNode<_vue_runtime_core.RendererNode, _vue_runtime_core.RendererElement, {
-    [key: string]: any;
-}>[] | undefined, {}, {}, {}, _vue_runtime_core.ComponentOptionsMixin, _vue_runtime_core.ComponentOptionsMixin, {}, string, _vue_runtime_core.PublicProps, Readonly<_vue_runtime_core.ExtractPropTypes<{
-    onError: PropType<(error: Error, info: string) => void>;
-    resetKeys: {
-        type: PropType<any[]>;
-        default: () => never[];
-    };
-}>> & Readonly<{}>, {
-    resetKeys: any[];
-}, {}, {}, {}, string, _vue_runtime_core.ComponentProvideOptions, true, {}, any>;
-
 /**
- * v-show directive for Vue Native.
- * Maps to the 'hidden' prop on native views (view.isHidden in Swift).
+ * Information provided to the renderItem function.
  */
-declare const vShow: Directive<NativeNode>;
-
+interface FlatListRenderItemInfo<T = unknown> {
+    item: T;
+    index: number;
+}
+declare function getDefaultItemKey(item: unknown, index: number): string | number;
 /**
- * Haptic feedback composable.
+ * VFlatList — A high-performance virtualized list for large datasets.
  *
- * Wraps the native Haptics module to provide tactile feedback.
+ * Unlike VList (which renders all items), VFlatList only creates native views
+ * for items currently visible on screen plus a configurable buffer. This reduces
+ * memory usage from O(n) to O(visible) — critical for lists with 1000+ items.
+ *
+ * Uses VScrollView internally with absolutely-positioned items in a tall
+ * content container. The scroll position drives which items are mounted.
  *
  * @example
- * ```ts
- * const { vibrate, selectionChanged } = useHaptics()
- * vibrate('medium')
- * ```
- */
-declare function useHaptics(): {
-    vibrate: (style?: "light" | "medium" | "heavy" | "rigid" | "soft") => Promise<void>;
-    notificationFeedback: (type?: "success" | "warning" | "error") => Promise<void>;
-    selectionChanged: () => Promise<void>;
-};
-
-/**
- * Async key-value storage composable backed by UserDefaults.
+ * ```vue
+ * <script setup>
+ * import { VFlatList } from '@thelacanians/vue-native-runtime'
  *
- * All operations are Promise-based and run on a background thread.
- * Write operations (setItem, removeItem) are serialized per key to
- * prevent race conditions from concurrent access.
+ * const data = Array.from({ length: 10000 }, (_, i) => ({ id: i, title: `Item ${i}` }))
  *
- * @example
- * ```ts
- * const storage = useAsyncStorage()
- * await storage.setItem('theme', 'dark')
- * const theme = await storage.getItem('theme')
+ * function renderItem({ item, index }) {
+ *   return h('VView', { style: { padding: 16 } }, [
+ *     h('VText', {}, `${item.title}`),
+ *   ])
+ * }
+ * </script>
+ *
+ * <template>
+ *   <VFlatList
+ *     :data="data"
+ *     :renderItem="renderItem"
+ *     :itemHeight="52"
+ *     :style="{ flex: 1 }"
+ *     @endReached="loadMore"
+ *   />
+ * </template>
  * ```
- */
-declare function useAsyncStorage(): {
-    getItem: (key: string) => Promise<string | null>;
-    setItem: (key: string, value: string) => Promise<void>;
-    removeItem: (key: string) => Promise<void>;
-    getAllKeys: () => Promise<string[]>;
-    clear: () => Promise<void>;
-};
-
-/**
- * Clipboard composable providing read/write access to UIPasteboard.
- *
- * `content` is a reactive ref that updates when `paste()` is called.
  *
- * @example
- * ```ts
- * const { copy, paste, content } = useClipboard()
- * await copy('Hello, World!')
- * const text = await paste()
+ * For slot-based usage:
+ * ```vue
+ * <VFlatList :data="data" :itemHeight="52" :style="{ flex: 1 }">
+ *   <template #item="{ item, index }">
+ *     <VText>{{ item.title }}</VText>
+ *   </template>
+ * </VFlatList>
  * ```
  */
-declare function useClipboard(): {
-    copy: (text: string) => Promise<void>;
-    paste: () => Promise<string>;
-    content: _vue_reactivity.Ref<string, string>;
-};
+declare const VFlatList: _vue_runtime_core.DefineComponent<_vue_runtime_core.ExtractPropTypes<{
+    /** Array of data items to render. */
+    data: {
+        type: PropType<unknown[]>;
+        required: true;
+    };
+    /**
+     * Render function for each item. Receives { item, index } and returns a VNode.
+     * If not provided, the `#item` slot is used instead.
+     */
+    renderItem: {
+        type: PropType<(info: FlatListRenderItemInfo<unknown>) => VNode>;
+        default: undefined;
+    };
+    /** Extract a unique key from each item. Defaults to item.id, item.key, or index. */
+    keyExtractor: {
+        type: PropType<(item: unknown, index: number) => string | number>;
+        default: typeof getDefaultItemKey;
+    };
+    /** Fixed height for each item in points. Required for virtualization math. */
+    itemHeight: {
+        type: NumberConstructor;
+        required: true;
+    };
+    /**
+     * Number of viewport-heights to render above and below the visible area.
+     * Higher values reduce blank flashes during fast scrolling but use more memory.
+     * Default: 3 (3 viewports above + 3 below = 7 total viewports of items).
+     */
+    windowSize: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /** Style for the outer scroll container. */
+    style: {
+        type: PropType<ViewStyle>;
+        default: () => {};
+    };
+    /** Show vertical scroll indicator. Default: true */
+    showsScrollIndicator: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Enable bounce at scroll boundaries. Default: true */
+    bounces: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Height of the header slot in points. Used to offset items below the header. */
+    headerHeight: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /**
+     * How far from the end (in viewport fractions) to trigger endReached.
+     * Default: 0.5 (trigger when within 50% of a viewport from the bottom).
+     */
+    endReachedThreshold: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, () => VNode<_vue_runtime_core.RendererNode, _vue_runtime_core.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, _vue_runtime_core.ComponentOptionsMixin, _vue_runtime_core.ComponentOptionsMixin, ("scroll" | "endReached")[], "scroll" | "endReached", _vue_runtime_core.PublicProps, Readonly<_vue_runtime_core.ExtractPropTypes<{
+    /** Array of data items to render. */
+    data: {
+        type: PropType<unknown[]>;
+        required: true;
+    };
+    /**
+     * Render function for each item. Receives { item, index } and returns a VNode.
+     * If not provided, the `#item` slot is used instead.
+     */
+    renderItem: {
+        type: PropType<(info: FlatListRenderItemInfo<unknown>) => VNode>;
+        default: undefined;
+    };
+    /** Extract a unique key from each item. Defaults to item.id, item.key, or index. */
+    keyExtractor: {
+        type: PropType<(item: unknown, index: number) => string | number>;
+        default: typeof getDefaultItemKey;
+    };
+    /** Fixed height for each item in points. Required for virtualization math. */
+    itemHeight: {
+        type: NumberConstructor;
+        required: true;
+    };
+    /**
+     * Number of viewport-heights to render above and below the visible area.
+     * Higher values reduce blank flashes during fast scrolling but use more memory.
+     * Default: 3 (3 viewports above + 3 below = 7 total viewports of items).
+     */
+    windowSize: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /** Style for the outer scroll container. */
+    style: {
+        type: PropType<ViewStyle>;
+        default: () => {};
+    };
+    /** Show vertical scroll indicator. Default: true */
+    showsScrollIndicator: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Enable bounce at scroll boundaries. Default: true */
+    bounces: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Height of the header slot in points. Used to offset items below the header. */
+    headerHeight: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /**
+     * How far from the end (in viewport fractions) to trigger endReached.
+     * Default: 0.5 (trigger when within 50% of a viewport from the bottom).
+     */
+    endReachedThreshold: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{
+    onScroll?: ((...args: any[]) => any) | undefined;
+    onEndReached?: ((...args: any[]) => any) | undefined;
+}>, {
+    style: ViewStyle;
+    bounces: boolean;
+    keyExtractor: (item: unknown, index: number) => string | number;
+    showsScrollIndicator: boolean;
+    renderItem: (info: FlatListRenderItemInfo<unknown>) => VNode;
+    windowSize: number;
+    headerHeight: number;
+    endReachedThreshold: number;
+}, {}, {}, {}, string, _vue_runtime_core.ComponentProvideOptions, true, {}, any>;
 
+interface TabConfig {
+    id: string;
+    label: string;
+    icon?: string;
+    badge?: number | string;
+}
 /**
- * Device information composable.
- *
- * Fetches device info once on mount and exposes reactive refs.
+ * VTabBar - Tab bar navigation component
  *
  * @example
- * ```ts
- * const { model, screenWidth, screenHeight } = useDeviceInfo()
+ * ```vue
+ * <VTabBar
+ *   :tabs="tabs"
+ *   :activeTab="activeTab"
+ *   @change="handleTabChange"
+ * />
  * ```
  */
-declare function useDeviceInfo(): {
-    model: _vue_reactivity.Ref<string, string>;
-    systemVersion: _vue_reactivity.Ref<string, string>;
-    systemName: _vue_reactivity.Ref<string, string>;
-    name: _vue_reactivity.Ref<string, string>;
-    screenWidth: _vue_reactivity.Ref<number, number>;
-    screenHeight: _vue_reactivity.Ref<number, number>;
-    scale: _vue_reactivity.Ref<number, number>;
-    isLoaded: _vue_reactivity.Ref<boolean, boolean>;
-    fetchInfo: () => Promise<void>;
-};
+declare const VTabBar: _vue_runtime_core.DefineComponent<_vue_runtime_core.ExtractPropTypes<{
+    /** Array of tab configurations */
+    tabs: {
+        type: PropType<TabConfig[]>;
+        required: true;
+    };
+    /** Currently active tab ID */
+    activeTab: {
+        type: StringConstructor;
+        required: true;
+    };
+    /** Position: 'top' | 'bottom' */
+    position: {
+        type: PropType<"top" | "bottom">;
+        default: string;
+    };
+}>, () => _vue_runtime_core.VNode<_vue_runtime_core.RendererNode, _vue_runtime_core.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, _vue_runtime_core.ComponentOptionsMixin, _vue_runtime_core.ComponentOptionsMixin, "change"[], "change", _vue_runtime_core.PublicProps, Readonly<_vue_runtime_core.ExtractPropTypes<{
+    /** Array of tab configurations */
+    tabs: {
+        type: PropType<TabConfig[]>;
+        required: true;
+    };
+    /** Currently active tab ID */
+    activeTab: {
+        type: StringConstructor;
+        required: true;
+    };
+    /** Position: 'top' | 'bottom' */
+    position: {
+        type: PropType<"top" | "bottom">;
+        default: string;
+    };
+}>> & Readonly<{
+    onChange?: ((...args: any[]) => any) | undefined;
+}>, {
+    position: "top" | "bottom";
+}, {}, {}, {}, string, _vue_runtime_core.ComponentProvideOptions, true, {}, any>;
 
 /**
- * Keyboard state composable.
- *
- * Provides reactive keyboard visibility state and a dismiss function.
- * The `isVisible` and `height` refs are updated by native keyboard events
- * dispatched through a special keyboard node.
+ * VDrawer - Drawer navigation component (side menu)
  *
  * @example
- * ```ts
- * const { isVisible, height, dismiss } = useKeyboard()
+ * ```vue
+ * <VDrawer v-model:open="drawerOpen">
+ *   <template #header>
+ *     <VText>Menu Header</VText>
+ *   </template>
+ *   <VDrawer.Item
+ *     icon="🏠"
+ *     label="Home"
+ *     @press="navigateTo('home')"
+ *   />
+ * </VDrawer>
  * ```
  */
-declare function useKeyboard(): {
-    isVisible: _vue_reactivity.Ref<boolean, boolean>;
-    height: _vue_reactivity.Ref<number, number>;
-    dismiss: () => Promise<void>;
-    getHeight: () => Promise<{
-        height: number;
-        isVisible: boolean;
-    }>;
-};
+declare const VDrawer: _vue_runtime_core.DefineComponent<_vue_runtime_core.ExtractPropTypes<{
+    /** Whether the drawer is open */
+    open: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Drawer position: 'left' | 'right' */
+    position: {
+        type: PropType<"left" | "right">;
+        default: string;
+    };
+    /** Drawer width */
+    width: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /** Close on item press */
+    closeOnPress: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => (VNode<_vue_runtime_core.RendererNode, _vue_runtime_core.RendererElement, {
+    [key: string]: any;
+}> | null)[] | null, {}, {}, {}, _vue_runtime_core.ComponentOptionsMixin, _vue_runtime_core.ComponentOptionsMixin, ("update:open" | "close")[], "update:open" | "close", _vue_runtime_core.PublicProps, Readonly<_vue_runtime_core.ExtractPropTypes<{
+    /** Whether the drawer is open */
+    open: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Drawer position: 'left' | 'right' */
+    position: {
+        type: PropType<"left" | "right">;
+        default: string;
+    };
+    /** Drawer width */
+    width: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /** Close on item press */
+    closeOnPress: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    "onUpdate:open"?: ((...args: any[]) => any) | undefined;
+    onClose?: ((...args: any[]) => any) | undefined;
+}>, {
+    position: "left" | "right";
+    open: boolean;
+    width: number;
+    closeOnPress: boolean;
+}, {}, {}, {}, string, _vue_runtime_core.ComponentProvideOptions, true, {}, any>;
+/**
+ * VDrawer.Item - Drawer menu item component
+ */
+declare const VDrawerItem: _vue_runtime_core.DefineComponent<_vue_runtime_core.ExtractPropTypes<{
+    /** Icon (emoji or icon name) */
+    icon: {
+        type: StringConstructor;
+        default: string;
+    };
+    /** Label text */
+    label: {
+        type: StringConstructor;
+        required: true;
+    };
+    /** Badge count */
+    badge: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: null;
+    };
+    /** Disabled state */
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => VNode<_vue_runtime_core.RendererNode, _vue_runtime_core.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, _vue_runtime_core.ComponentOptionsMixin, _vue_runtime_core.ComponentOptionsMixin, "press"[], "press", _vue_runtime_core.PublicProps, Readonly<_vue_runtime_core.ExtractPropTypes<{
+    /** Icon (emoji or icon name) */
+    icon: {
+        type: StringConstructor;
+        default: string;
+    };
+    /** Label text */
+    label: {
+        type: StringConstructor;
+        required: true;
+    };
+    /** Badge count */
+    badge: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: null;
+    };
+    /** Disabled state */
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onPress?: ((...args: any[]) => any) | undefined;
+}>, {
+    icon: string;
+    badge: string | number;
+    disabled: boolean;
+}, {}, {}, {}, string, _vue_runtime_core.ComponentProvideOptions, true, {}, any>;
+/**
+ * VDrawer.Section - Drawer section divider
+ */
+declare const VDrawerSection: _vue_runtime_core.DefineComponent<_vue_runtime_core.ExtractPropTypes<{
+    /** Section title */
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => VNode<_vue_runtime_core.RendererNode, _vue_runtime_core.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, _vue_runtime_core.ComponentOptionsMixin, _vue_runtime_core.ComponentOptionsMixin, {}, string, _vue_runtime_core.PublicProps, Readonly<_vue_runtime_core.ExtractPropTypes<{
+    /** Section title */
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    title: string;
+}, {}, {}, {}, string, _vue_runtime_core.ComponentProvideOptions, true, {}, any>;
 
 declare const Easing: {
     readonly linear: "linear";
@@ -2334,25 +2643,47 @@ interface KeyframeStep {
 interface SequenceAnimation {
     type: 'timing' | 'spring';
     viewId: number;
-    toStyles: Record<string, any>;
+    toStyles: Record<string, unknown>;
     options: TimingConfig | SpringConfig;
 }
 type TimingOptions = TimingConfig;
 type SpringOptions = SpringConfig;
+/**
+ * Accepted view target for animation methods.
+ * - `number` — raw node ID (backward compatible)
+ * - `Ref` — a Vue template ref whose `.value` has an `id` (NativeNode)
+ * - `NativeNode` — a node object directly
+ *
+ * @example
+ * const myView = ref()  // template ref
+ * await timing(myView, { opacity: 1 }, { duration: 300 })
+ */
+type AnimatableNode$1 = NativeNode | {
+    id: number;
+};
+type AnimationTargetRef = Ref<AnimatableNode$1 | null | undefined>;
+type AnimationTarget = number | AnimationTargetRef | AnimatableNode$1;
 /**
  * Imperative animation API backed by native UIView/CALayer animations.
  *
+ * All methods accept either a raw node ID (number), a template ref, or
+ * a NativeNode object as the first argument.
+ *
  * @example
- * const { timing, spring, keyframe, sequence, parallel } = useAnimation()
+ * const myView = ref()  // <VView ref="myView" ...>
+ * const { timing, spring, fadeIn } = useAnimation()
  *
- * // Fade in
- * await timing(viewId, { opacity: 1 }, { duration: 300 })
+ * // Using template ref (recommended)
+ * await timing(myView, { opacity: 1 }, { duration: 300 })
+ *
+ * // Using raw node ID (still works)
+ * await timing(42, { opacity: 1 }, { duration: 300 })
  *
  * // Spring bounce
- * await spring(viewId, { translateY: 0 }, { tension: 40, friction: 7 })
+ * await spring(myView, { translateY: 0 }, { tension: 40, friction: 7 })
  *
  * // Keyframe flash
- * await keyframe(viewId, [
+ * await keyframe(myView, [
  *   { offset: 0, opacity: 1 },
  *   { offset: 0.5, opacity: 0 },
  *   { offset: 1, opacity: 1 },
@@ -2360,28 +2691,23 @@ type SpringOptions = SpringConfig;
  *
  * // Sequence: fade then slide
  * await sequence([
- *   { type: 'timing', viewId, toStyles: { opacity: 0 }, options: { duration: 200 } },
- *   { type: 'timing', viewId, toStyles: { translateX: 100 }, options: { duration: 300 } },
- * ])
- *
- * // Parallel: fade + scale at once
- * await parallel([
- *   { type: 'timing', viewId, toStyles: { opacity: 0 }, options: { duration: 300 } },
- *   { type: 'spring', viewId, toStyles: { scale: 0 }, options: { tension: 50, friction: 10 } },
+ *   { type: 'timing', viewId: resolveId(myView), toStyles: { opacity: 0 }, options: { duration: 200 } },
+ *   { type: 'timing', viewId: resolveId(myView), toStyles: { translateX: 100 }, options: { duration: 300 } },
  * ])
  */
 declare function useAnimation(): {
-    timing: (viewId: number, toStyles: Record<string, any>, config?: TimingConfig) => Promise<void>;
-    spring: (viewId: number, toStyles: Record<string, any>, config?: SpringConfig) => Promise<void>;
-    keyframe: (viewId: number, steps: KeyframeStep[], config?: {
+    timing: (target: AnimationTarget, toStyles: Record<string, unknown>, config?: TimingConfig) => Promise<void>;
+    spring: (target: AnimationTarget, toStyles: Record<string, unknown>, config?: SpringConfig) => Promise<void>;
+    keyframe: (target: AnimationTarget, steps: KeyframeStep[], config?: {
         duration?: number;
     }) => Promise<void>;
     sequence: (animations: SequenceAnimation[]) => Promise<void>;
     parallel: (animations: SequenceAnimation[]) => Promise<void>;
-    fadeIn: (viewId: number, duration?: number) => Promise<void>;
-    fadeOut: (viewId: number, duration?: number) => Promise<void>;
-    slideInFromRight: (viewId: number, duration?: number) => Promise<void>;
-    slideOutToRight: (viewId: number, duration?: number) => Promise<void>;
+    fadeIn: (target: AnimationTarget, duration?: number) => Promise<void>;
+    fadeOut: (target: AnimationTarget, duration?: number) => Promise<void>;
+    slideInFromRight: (target: AnimationTarget, duration?: number) => Promise<void>;
+    slideOutToRight: (target: AnimationTarget, duration?: number) => Promise<void>;
+    resolveId: (target: AnimationTarget) => number;
     Easing: {
         readonly linear: "linear";
         readonly ease: "ease";
@@ -2391,6 +2717,158 @@ declare function useAnimation(): {
     };
 };
 
+/**
+ * Built-in Vue Native components.
+ *
+ * These components are automatically registered when using createApp()
+ * from @thelacanians/vue-native-runtime, so they can be used directly in templates
+ * without explicit imports. They can also be imported individually for
+ * use in render functions or JSX.
+ */
+
+declare const builtInComponents: Record<string, Component>;
+
+declare const ErrorBoundary: _vue_runtime_core.DefineComponent<_vue_runtime_core.ExtractPropTypes<{
+    onError: PropType<(error: Error, info: string) => void>;
+    resetKeys: {
+        type: PropType<unknown[]>;
+        default: () => unknown[];
+    };
+}>, () => _vue_runtime_core.VNode<_vue_runtime_core.RendererNode, _vue_runtime_core.RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, _vue_runtime_core.ComponentOptionsMixin, _vue_runtime_core.ComponentOptionsMixin, {}, string, _vue_runtime_core.PublicProps, Readonly<_vue_runtime_core.ExtractPropTypes<{
+    onError: PropType<(error: Error, info: string) => void>;
+    resetKeys: {
+        type: PropType<unknown[]>;
+        default: () => unknown[];
+    };
+}>> & Readonly<{}>, {
+    resetKeys: unknown[];
+}, {}, {}, {}, string, _vue_runtime_core.ComponentProvideOptions, true, {}, any>;
+
+/**
+ * v-show directive for Vue Native.
+ * Maps to the 'hidden' prop on native views (view.isHidden in Swift).
+ */
+declare const vShow: Directive<NativeNode>;
+
+/**
+ * v-model directive for native inputs.
+ *
+ * Provides two-way data binding for form elements like VInput, VSwitch, VSlider, etc.
+ *
+ * @example
+ * ```vue
+ * <VInput v-model="text" />
+ * <VSwitch v-model="enabled" />
+ * <VInput v-model.lazy="text" />
+ * <VInput v-model.number="count" />
+ * <VInput v-model.trim="text" />
+ * ```
+ */
+declare const vModel: Directive<NativeNode>;
+
+/**
+ * Haptic feedback composable.
+ *
+ * Wraps the native Haptics module to provide tactile feedback.
+ *
+ * @example
+ * ```ts
+ * const { vibrate, selectionChanged } = useHaptics()
+ * vibrate('medium')
+ * ```
+ */
+declare function useHaptics(): {
+    vibrate: (style?: "light" | "medium" | "heavy" | "rigid" | "soft") => Promise<void>;
+    notificationFeedback: (type?: "success" | "warning" | "error") => Promise<void>;
+    selectionChanged: () => Promise<void>;
+};
+
+/**
+ * Async key-value storage composable backed by UserDefaults.
+ *
+ * All operations are Promise-based and run on a background thread.
+ * Write operations (setItem, removeItem) are serialized per key to
+ * prevent race conditions from concurrent access.
+ *
+ * @example
+ * ```ts
+ * const storage = useAsyncStorage()
+ * await storage.setItem('theme', 'dark')
+ * const theme = await storage.getItem('theme')
+ * ```
+ */
+declare function useAsyncStorage(): {
+    getItem: (key: string) => Promise<string | null>;
+    setItem: (key: string, value: string) => Promise<void>;
+    removeItem: (key: string) => Promise<void>;
+    getAllKeys: () => Promise<string[]>;
+    clear: () => Promise<void>;
+};
+
+/**
+ * Clipboard composable providing read/write access to UIPasteboard.
+ *
+ * `content` is a reactive ref that updates when `paste()` is called.
+ *
+ * @example
+ * ```ts
+ * const { copy, paste, content } = useClipboard()
+ * await copy('Hello, World!')
+ * const text = await paste()
+ * ```
+ */
+declare function useClipboard(): {
+    copy: (text: string) => Promise<void>;
+    paste: () => Promise<string>;
+    content: _vue_reactivity.Ref<string, string>;
+};
+
+/**
+ * Device information composable.
+ *
+ * Fetches device info once on mount and exposes reactive refs.
+ *
+ * @example
+ * ```ts
+ * const { model, screenWidth, screenHeight } = useDeviceInfo()
+ * ```
+ */
+declare function useDeviceInfo(): {
+    model: _vue_reactivity.Ref<string, string>;
+    systemVersion: _vue_reactivity.Ref<string, string>;
+    systemName: _vue_reactivity.Ref<string, string>;
+    name: _vue_reactivity.Ref<string, string>;
+    screenWidth: _vue_reactivity.Ref<number, number>;
+    screenHeight: _vue_reactivity.Ref<number, number>;
+    scale: _vue_reactivity.Ref<number, number>;
+    isLoaded: _vue_reactivity.Ref<boolean, boolean>;
+    fetchInfo: () => Promise<void>;
+};
+
+/**
+ * Keyboard state composable.
+ *
+ * Provides reactive keyboard visibility state and a dismiss function.
+ * The `isVisible` and `height` refs are updated by native keyboard events
+ * dispatched through a special keyboard node.
+ *
+ * @example
+ * ```ts
+ * const { isVisible, height, dismiss } = useKeyboard()
+ * ```
+ */
+declare function useKeyboard(): {
+    isVisible: _vue_reactivity.Ref<boolean, boolean>;
+    height: _vue_reactivity.Ref<number, number>;
+    dismiss: () => Promise<void>;
+    getHeight: () => Promise<{
+        height: number;
+        isVisible: boolean;
+    }>;
+};
+
 type ConnectionType = 'wifi' | 'cellular' | 'ethernet' | 'none' | 'unknown';
 interface NetworkState {
     isConnected: boolean;
@@ -2585,19 +3063,19 @@ interface LocalNotification {
     delay?: number;
     sound?: 'default' | null;
     badge?: number;
-    data?: Record<string, any>;
+    data?: Record<string, unknown>;
 }
 interface NotificationPayload {
     id: string;
     title: string;
     body: string;
-    data: Record<string, any>;
+    data: Record<string, unknown>;
     action?: string;
 }
 interface PushNotificationPayload {
     title: string;
     body: string;
-    data: Record<string, any>;
+    data: Record<string, unknown>;
     remote: true;
 }
 /**
@@ -2651,6 +3129,9 @@ declare function useBiometry(): {
     isAvailable: () => Promise<boolean>;
 };
 
+declare global {
+    var __VN_configurePins: ((pinsJson: string) => void) | undefined;
+}
 interface HttpRequestConfig {
     baseURL?: string;
     headers?: Record<string, string>;
@@ -2667,12 +3148,16 @@ interface HttpRequestConfig {
      */
     pins?: Record<string, string[]>;
 }
-interface HttpResponse<T = any> {
+interface HttpResponse<T = unknown> {
     data: T;
     status: number;
     ok: boolean;
     headers: Record<string, string>;
 }
+interface QueryRequestOptions {
+    params?: Record<string, string>;
+    headers?: Record<string, string>;
+}
 /**
  * HTTP client composable with reactive loading/error state.
  * Uses the native fetch polyfill under the hood.
@@ -2684,20 +3169,14 @@ interface HttpResponse<T = any> {
 declare function useHttp(config?: HttpRequestConfig): {
     loading: _vue_reactivity.Ref<boolean, boolean>;
     error: _vue_reactivity.Ref<string | null, string | null>;
-    get: <T = any>(url: string, options?: {
-        params?: Record<string, string>;
-        headers?: Record<string, string>;
-    } | Record<string, string>) => Promise<HttpResponse<T>>;
-    post: <T = any>(url: string, body?: any, headers?: Record<string, string>) => Promise<HttpResponse<T>>;
-    put: <T = any>(url: string, body?: any, headers?: Record<string, string>) => Promise<HttpResponse<T>>;
-    patch: <T = any>(url: string, body?: any, headers?: Record<string, string>) => Promise<HttpResponse<T>>;
-    delete: <T = any>(url: string, options?: {
-        params?: Record<string, string>;
-        headers?: Record<string, string>;
-    } | Record<string, string>) => Promise<HttpResponse<T>>;
+    get: <T = unknown>(url: string, options?: QueryRequestOptions | Record<string, string>) => Promise<HttpResponse<T>>;
+    post: <T = unknown>(url: string, body?: unknown, headers?: Record<string, string>) => Promise<HttpResponse<T>>;
+    put: <T = unknown>(url: string, body?: unknown, headers?: Record<string, string>) => Promise<HttpResponse<T>>;
+    patch: <T = unknown>(url: string, body?: unknown, headers?: Record<string, string>) => Promise<HttpResponse<T>>;
+    delete: <T = unknown>(url: string, options?: QueryRequestOptions | Record<string, string>) => Promise<HttpResponse<T>>;
 };
 
-type ColorScheme = 'light' | 'dark';
+type ColorScheme$1 = 'light' | 'dark';
 /**
  * Reactive dark mode / color scheme detection.
  * Updates automatically when the user switches between light and dark mode.
@@ -2708,7 +3187,7 @@ type ColorScheme = 'light' | 'dark';
  * const bgColor = computed(() => isDark.value ? '#000' : '#FFF')
  */
 declare function useColorScheme(): {
-    colorScheme: _vue_reactivity.Ref<ColorScheme, ColorScheme>;
+    colorScheme: _vue_reactivity.Ref<ColorScheme$1, ColorScheme$1>;
     isDark: _vue_reactivity.Ref<boolean, boolean>;
 };
 
@@ -2759,22 +3238,26 @@ declare function useI18n(): {
     locale: _vue_reactivity.Ref<string, string>;
 };
 
-type Platform = 'ios' | 'android';
+type Platform = 'ios' | 'android' | 'macos';
 /**
- * Returns the current platform ('ios' or 'android').
+ * Returns the current platform and convenience boolean flags.
  *
  * Relies on the `__PLATFORM__` compile-time constant injected by the Vite plugin.
  * Falls back to 'ios' if not defined.
  *
  * @example
  * ```ts
- * const { platform, isIOS, isAndroid } = usePlatform()
+ * const { platform, isIOS, isAndroid, isMacOS, isApple, isDesktop, isMobile } = usePlatform()
  * ```
  */
 declare function usePlatform(): {
     platform: Platform;
     isIOS: boolean;
     isAndroid: boolean;
+    isMacOS: boolean;
+    isApple: boolean;
+    isDesktop: boolean;
+    isMobile: boolean;
 };
 
 interface Dimensions {
@@ -2965,10 +3448,10 @@ interface ExecuteResult {
     rowsAffected: number;
     insertId?: number;
 }
-type Row = Record<string, any>;
+type Row = Record<string, unknown>;
 interface TransactionContext {
-    execute: (sql: string, params?: any[]) => Promise<ExecuteResult>;
-    query: <T extends Row = Row>(sql: string, params?: any[]) => Promise<T[]>;
+    execute: (sql: string, params?: unknown[]) => Promise<ExecuteResult>;
+    query: <T extends Row = Row>(sql: string, params?: unknown[]) => Promise<T[]>;
 }
 /**
  * Reactive SQLite database access. Opens a named database on first use
@@ -2995,8 +3478,8 @@ interface TransactionContext {
  * })
  */
 declare function useDatabase(name?: string): {
-    execute: (sql: string, params?: any[]) => Promise<ExecuteResult>;
-    query: <T extends Row = Row>(sql: string, params?: any[]) => Promise<T[]>;
+    execute: (sql: string, params?: unknown[]) => Promise<ExecuteResult>;
+    query: <T extends Row = Row>(sql: string, params?: unknown[]) => Promise<T[]>;
     transaction: (callback: (ctx: TransactionContext) => Promise<void>) => Promise<void>;
     close: () => Promise<void>;
     isOpen: _vue_reactivity.Ref<boolean, boolean>;
@@ -3496,26 +3979,328 @@ declare function useContacts(): {
     error: _vue_reactivity.Ref<string | null, string | null>;
 };
 
+interface WindowInfo {
+    width: number;
+    height: number;
+    x: number;
+    y: number;
+    isFullScreen: boolean;
+    isVisible: boolean;
+    title: string;
+}
+/**
+ * macOS-only composable for window management.
+ * No-op on iOS and Android.
+ *
+ * @example
+ * ```ts
+ * const { setTitle, setSize, center, minimize, toggleFullScreen, getInfo } = useWindow()
+ * setTitle('My App')
+ * setSize(1024, 768)
+ * ```
+ */
+declare function useWindow(): {
+    setTitle: (title: string) => Promise<void>;
+    setSize: (width: number, height: number) => Promise<void>;
+    center: () => Promise<void>;
+    minimize: () => Promise<void>;
+    toggleFullScreen: () => Promise<void>;
+    close: () => Promise<void>;
+    getInfo: () => Promise<WindowInfo | null>;
+};
+
+interface MenuItem {
+    id?: string;
+    title: string;
+    key?: string;
+    disabled?: boolean;
+    separator?: boolean;
+}
+interface MenuSection {
+    title: string;
+    items: MenuItem[];
+}
+/**
+ * macOS-only composable for menu bar and context menu control.
+ * No-op on iOS and Android.
+ *
+ * @example
+ * ```ts
+ * const { setAppMenu, showContextMenu, onMenuItemClick } = useMenu()
+ *
+ * setAppMenu([
+ *   { title: 'File', items: [{ id: 'new', title: 'New', key: 'n' }] },
+ *   { title: 'Edit', items: [{ id: 'copy', title: 'Copy', key: 'c' }] },
+ * ])
+ *
+ * onMenuItemClick((id, title) => {
+ *   console.log('Clicked:', id, title)
+ * })
+ * ```
+ */
+declare function useMenu(): {
+    setAppMenu: (sections: MenuSection[]) => Promise<void>;
+    showContextMenu: (items: MenuItem[]) => Promise<void>;
+    onMenuItemClick: (callback: (id: string, title: string) => void) => () => void;
+};
+
+interface OpenFileOptions {
+    multiple?: boolean;
+    allowedTypes?: string[];
+    title?: string;
+}
+interface SaveFileOptions {
+    title?: string;
+    defaultName?: string;
+}
 /**
- * NativeBridge -- the communication layer between JavaScript and Swift/UIKit.
+ * macOS-only composable for native file open/save dialogs.
+ * No-op on iOS and Android.
  *
- * All renderer operations (create, update, insert, remove) are batched into
- * a pending operations array. On the first enqueue within a microtask cycle,
- * a queueMicrotask callback is scheduled. When the microtask fires, all
- * accumulated operations are JSON-serialized and sent to Swift via
- * `globalThis.__VN_flushOperations(json)`.
+ * @example
+ * ```ts
+ * const { openFile, openDirectory, saveFile } = useFileDialog()
  *
- * Operation format:
- *   { op: "<name>", args: [arg0, arg1, ...] }
+ * const files = await openFile({ multiple: true, allowedTypes: ['png', 'jpg'] })
+ * const dir = await openDirectory()
+ * const savePath = await saveFile({ defaultName: 'export.json' })
+ * ```
+ */
+declare function useFileDialog(): {
+    openFile: (options?: OpenFileOptions) => Promise<string[] | null>;
+    openDirectory: (options?: {
+        title?: string;
+    }) => Promise<string | null>;
+    saveFile: (options?: SaveFileOptions) => Promise<string | null>;
+};
+
+/**
+ * macOS-only composable for drag and drop.
+ * No-op on iOS and Android.
+ *
+ * @example
+ * ```ts
+ * const { enableDropZone, onDrop, isDragging } = useDragDrop()
+ *
+ * enableDropZone()
+ * onDrop((files) => {
+ *   console.log('Dropped files:', files)
+ * })
+ * ```
+ */
+declare function useDragDrop(): {
+    enableDropZone: () => Promise<void>;
+    onDrop: (callback: (files: string[]) => void) => () => void;
+    onDragEnter: (callback: () => void) => () => void;
+    onDragLeave: (callback: () => void) => () => void;
+    isDragging: Readonly<_vue_reactivity.Ref<boolean, boolean>>;
+};
+
+/**
+ * Composable for programmatic teleportation.
+ * Allows moving native nodes to different containers (e.g., modal, root).
  *
- * This matches the Swift NativeBridge.processOperations() parser which
- * extracts `operation["op"]` and `operation["args"]`.
+ * @param target - Teleport target name ('modal', 'root', etc.)
+ * @returns Object with teleport function
  *
- * This batching strategy ensures that all synchronous Vue updates triggered
- * by a single state change are coalesced into one native bridge call,
- * minimizing JS-to-native context switches.
+ * @example
+ * ```ts
+ * import { useTeleport } from '@thelacanians/vue-native-runtime'
+ *
+ * const { teleport } = useTeleport('modal')
+ * const node = createNativeNode('VView')
+ * teleport(node)
+ * ```
  */
-type EventCallback = (payload: any) => void;
+declare function useTeleport(target: string): {
+    teleport: (node: NativeNode) => void;
+};
+
+interface PanGestureState {
+    translationX: number;
+    translationY: number;
+    velocityX: number;
+    velocityY: number;
+    state: 'began' | 'changed' | 'ended' | 'cancelled';
+}
+interface PinchGestureState {
+    scale: number;
+    velocity: number;
+    state: 'began' | 'changed' | 'ended' | 'cancelled';
+}
+interface RotateGestureState {
+    rotation: number;
+    velocity: number;
+    state: 'began' | 'changed' | 'ended' | 'cancelled';
+}
+interface SwipeGestureState {
+    direction: 'left' | 'right' | 'up' | 'down';
+    locationX: number;
+    locationY: number;
+}
+interface TapGestureState {
+    locationX: number;
+    locationY: number;
+    tapCount: number;
+}
+interface ForceTouchState {
+    force: number;
+    locationX: number;
+    locationY: number;
+    stage: number;
+}
+interface HoverState {
+    locationX: number;
+    locationY: number;
+    state: 'entered' | 'moved' | 'exited';
+}
+type GestureState = PanGestureState | PinchGestureState | RotateGestureState | SwipeGestureState | TapGestureState | ForceTouchState | HoverState;
+interface GestureConfig {
+    enabled?: boolean;
+    simultaneousGestures?: string[];
+    exclusiveGestures?: string[];
+    threshold?: number;
+    minPointers?: number;
+    maxPointers?: number;
+    waitFor?: Ref<GestureHandler | null>[];
+}
+interface GestureHandler {
+    id: symbol;
+    event: string;
+    config: GestureConfig;
+    callback: (state: GestureState) => void;
+}
+type AnimatableNode = NativeNode | {
+    id: number;
+};
+type GestureTargetRef = Ref<AnimatableNode | null | undefined>;
+type GestureTarget = number | GestureTargetRef | AnimatableNode;
+interface GestureEventMap {
+    pan: PanGestureState;
+    pinch: PinchGestureState;
+    rotate: RotateGestureState;
+    swipeLeft: SwipeGestureState;
+    swipeRight: SwipeGestureState;
+    swipeUp: SwipeGestureState;
+    swipeDown: SwipeGestureState;
+    press: TapGestureState;
+    longPress: TapGestureState;
+    doubleTap: TapGestureState;
+    forceTouch: ForceTouchState;
+    hover: HoverState;
+}
+type AnyGestureState = PanGestureState | PinchGestureState | RotateGestureState | SwipeGestureState | TapGestureState | ForceTouchState | HoverState;
+interface UseGestureReturn {
+    pan: Ref<PanGestureState | null>;
+    pinch: Ref<PinchGestureState | null>;
+    rotate: Ref<RotateGestureState | null>;
+    swipeLeft: Ref<SwipeGestureState | null>;
+    swipeRight: Ref<SwipeGestureState | null>;
+    swipeUp: Ref<SwipeGestureState | null>;
+    swipeDown: Ref<SwipeGestureState | null>;
+    press: Ref<TapGestureState | null>;
+    longPress: Ref<TapGestureState | null>;
+    doubleTap: Ref<TapGestureState | null>;
+    forceTouch: Ref<ForceTouchState | null>;
+    hover: Ref<HoverState | null>;
+    gestureState: Ref<AnyGestureState | null>;
+    activeGesture: Ref<string | null>;
+    isGesturing: Ref<boolean>;
+    attach: (target: GestureTarget) => void;
+    detach: () => void;
+    on: <K extends keyof GestureEventMap>(event: K, callback: (state: GestureEventMap[K]) => void) => () => void;
+}
+interface UseGestureOptions {
+    pan?: boolean | GestureConfig;
+    pinch?: boolean | GestureConfig;
+    rotate?: boolean | GestureConfig;
+    swipeLeft?: boolean | GestureConfig;
+    swipeRight?: boolean | GestureConfig;
+    swipeUp?: boolean | GestureConfig;
+    swipeDown?: boolean | GestureConfig;
+    press?: boolean | GestureConfig;
+    longPress?: boolean | GestureConfig;
+    doubleTap?: boolean | GestureConfig;
+    forceTouch?: boolean | GestureConfig;
+    hover?: boolean | GestureConfig;
+    simultaneousGestures?: string[];
+}
+declare function useGesture(target?: GestureTarget, options?: UseGestureOptions): UseGestureReturn;
+interface GestureCompositionOptions {
+    enabled?: Ref<boolean>;
+}
+interface ComposedGesture {
+    pan: Ref<PanGestureState | null>;
+    pinch: Ref<PinchGestureState | null>;
+    rotate: Ref<RotateGestureState | null>;
+    gestureState: Ref<AnyGestureState | null>;
+    activeGesture: Ref<string | null>;
+    isGesturing: Ref<boolean>;
+    isPinchingAndRotating: Ref<boolean>;
+    isPanningAndPinching: Ref<boolean>;
+}
+declare function useComposedGestures(target: GestureTarget, options?: GestureCompositionOptions & UseGestureOptions): ComposedGesture;
+
+type ColorScheme = 'light' | 'dark';
+interface ThemeDefinition<T extends Record<string, unknown> = Record<string, unknown>> {
+    light: T;
+    dark: T;
+}
+interface ThemeContext<T> {
+    /** The current resolved theme object (reactive). */
+    theme: ComputedRef<T>;
+    /** Current color scheme. */
+    colorScheme: Ref<ColorScheme>;
+    /** Toggle between light and dark mode. */
+    toggleColorScheme: () => void;
+    /** Set a specific color scheme. */
+    setColorScheme: (scheme: ColorScheme) => void;
+}
+/**
+ * Create a theme system with light and dark variants.
+ *
+ * Returns a `ThemeProvider` component (wraps children with provide) and a
+ * `useTheme` composable for consuming the theme in any descendant component.
+ */
+declare function createTheme<T extends Record<string, unknown>>(definition: ThemeDefinition<T>): {
+    ThemeProvider: _vue_runtime_core.DefineComponent<_vue_runtime_core.ExtractPropTypes<{
+        initialColorScheme: {
+            type: () => ColorScheme;
+            default: string;
+        };
+    }>, () => _vue_runtime_core.VNode<_vue_runtime_core.RendererNode, _vue_runtime_core.RendererElement, {
+        [key: string]: any;
+    }>[] | undefined, {}, {}, {}, _vue_runtime_core.ComponentOptionsMixin, _vue_runtime_core.ComponentOptionsMixin, {}, string, _vue_runtime_core.PublicProps, Readonly<_vue_runtime_core.ExtractPropTypes<{
+        initialColorScheme: {
+            type: () => ColorScheme;
+            default: string;
+        };
+    }>> & Readonly<{}>, {
+        initialColorScheme: ColorScheme;
+    }, {}, {}, {}, string, _vue_runtime_core.ComponentProvideOptions, true, {}, any>;
+    useTheme: () => ThemeContext<T>;
+};
+/**
+ * Create a computed stylesheet that automatically re-evaluates when the theme changes.
+ *
+ * @param theme - A reactive/computed theme object (from `useTheme().theme`)
+ * @param factory - A function that receives the current theme and returns a style map
+ * @returns A computed ref containing the frozen stylesheet
+ *
+ * @example
+ * ```ts
+ * const { theme } = useTheme()
+ * const styles = createDynamicStyleSheet(theme, (t) => ({
+ *   container: { flex: 1, backgroundColor: t.colors.background },
+ *   text: { color: t.colors.text, fontSize: 16 },
+ * }))
+ * ```
+ */
+declare function createDynamicStyleSheet<T extends Record<string, unknown>, S extends Record<string, AnyStyle>>(theme: ComputedRef<T> | Ref<T>, factory: (themeValue: T) => S): ComputedRef<StyleSheet<S>>;
+
+type EventCallback<T = unknown> = {
+    bivarianceHack(payload: T): void;
+}['bivarianceHack'];
 declare class NativeBridgeImpl {
     /** Pending operations waiting to be flushed to native */
     private pendingOps;
@@ -3578,7 +4363,7 @@ declare class NativeBridgeImpl {
      * Update a single property on a native view.
      * Swift handler: handleUpdateProp(args: [nodeId, key, value])
      */
-    updateProp(nodeId: number, key: string, value: any): void;
+    updateProp(nodeId: number, key: string, value: unknown): void;
     /**
      * Update a single style property on a native view.
      * Swift handler: handleUpdateStyle(args: [nodeId, { key: value }])
@@ -3586,7 +4371,15 @@ declare class NativeBridgeImpl {
      * Each style property update is sent as a dictionary with one key,
      * matching the Swift side which iterates over the dictionary entries.
      */
-    updateStyle(nodeId: number, key: string, value: any): void;
+    updateStyle(nodeId: number, key: string, value: unknown): void;
+    /**
+     * Update multiple style properties on a native view in a single bridge op.
+     * Swift/Kotlin handler: handleUpdateStyle(args: [nodeId, { key1: val1, key2: val2, ... }])
+     *
+     * More efficient than calling updateStyle() per property — sends one op
+     * instead of N ops, reducing JSON overhead and bridge dispatch.
+     */
+    updateStyles(nodeId: number, styles: Record<string, unknown>): void;
     /**
      * Append a child node to a parent node.
      * Swift handler: handleAppendChild(args: [parentId, childId])
@@ -3608,7 +4401,7 @@ declare class NativeBridgeImpl {
      * The native side will call __VN_handleEvent when this event fires.
      * Swift handler: handleAddEventListener(args: [nodeId, eventName])
      */
-    addEventListener(nodeId: number, eventName: string, callback: EventCallback): void;
+    addEventListener<T = unknown>(nodeId: number, eventName: string, callback: EventCallback<T>): void;
     /**
      * Remove a previously registered event listener.
      * Swift handler: handleRemoveEventListener(args: [nodeId, eventName])
@@ -3618,7 +4411,7 @@ declare class NativeBridgeImpl {
      * Called from Swift via globalThis.__VN_handleEvent when a native event fires.
      * Looks up the registered handler and invokes it with the event payload.
      */
-    handleNativeEvent(nodeId: number, eventName: string, payload: any): void;
+    handleNativeEvent(nodeId: number, eventName: string, payload: unknown): void;
     /**
      * Tell native which node ID is the root of the view tree.
      * Swift handler: handleSetRootView(args: [nodeId])
@@ -3632,23 +4425,39 @@ declare class NativeBridgeImpl {
      * a crash or unregistered module), the Promise rejects with a clear error instead
      * of hanging forever.
      */
-    invokeNativeModule(moduleName: string, methodName: string, args?: any[], timeoutMs?: number): Promise<any>;
+    invokeNativeModule(moduleName: string, methodName: string, args?: unknown[], timeoutMs?: number): Promise<any>;
     /**
      * Invoke a native module method synchronously.
      * This sends the operation immediately and expects no callback.
      * Use sparingly -- prefer the async variant.
      */
-    invokeNativeModuleSync(moduleName: string, methodName: string, args?: any[]): void;
+    invokeNativeModuleSync(moduleName: string, methodName: string, args?: unknown[]): void;
     /**
      * Called from Swift via globalThis.__VN_resolveCallback when an async
      * native module invocation completes.
      */
-    resolveCallback(callbackId: number, result: any, error: any): void;
+    resolveCallback(callbackId: number, result: unknown, error: unknown): void;
+    /**
+     * Create teleport markers in native.
+     * Used for Teleport component to render content outside parent hierarchy.
+     */
+    createTeleport(parentId: number, startId: number, endId: number): void;
+    /**
+     * Remove teleport markers from native.
+     * Cleans up teleport containers and markers.
+     */
+    removeTeleport(parentId: number, startId: number, endId: number): void;
+    /**
+     * Move a node to a teleport target.
+     * @param target - Teleport target name ('modal', 'root', etc.)
+     * @param nodeId - Node ID to teleport
+     */
+    teleportTo(target: string, nodeId: number): void;
     /**
      * Register a handler for a push-based global event from native.
      * Returns an unsubscribe function.
      */
-    onGlobalEvent(eventName: string, handler: (payload: any) => void): () => void;
+    onGlobalEvent<T = unknown>(eventName: string, handler: EventCallback<T>): () => void;
     /**
      * Called from Swift via globalThis.__VN_handleGlobalEvent when a push event fires.
      */
@@ -3706,6 +4515,6 @@ interface NativeApp extends App {
  * app.start()
  * ```
  */
-declare function createApp(rootComponent: Component, rootProps?: Record<string, any>): NativeApp;
+declare function createApp(rootComponent: Component, rootProps?: Record<string, unknown>): NativeApp;
 
-export { type AccessibilityProps, type ActionSheetAction, type AlertButton, type AlignContent, type AlignItems, type AlignSelf, type AnyStyle, type AppStateStatus, type AudioPlayOptions, type AudioRecordOptions, type AudioRecordResult, type AuthResult, type BLECharacteristic, type BLECharacteristicChange, type BLEDevice, type BLEState, type BackgroundTaskOptions, type BackgroundTaskType, type BiometryResult, type BiometryType, type BorderStyle, type Calendar, type CalendarEvent, type CameraOptions, type CameraResult, type ColorScheme, type ConnectionType, type Contact, type ContactField, type CreateContactData, type CreateEventOptions, type Dimensions, type Direction, type Display, type DropdownOption, ErrorBoundary, type ExecuteResult, type FileStat, type FlexDirection, type FlexWrap, type FontStyle, type FontWeight, type GeoCoordinates, type HttpRequestConfig, type HttpResponse, type ImageStyle, type ImportantForAccessibility, type JustifyContent, type LocalNotification, type NativeApp, NativeBridge, type NativeNode, type NetworkState, type NotificationPayload, type Overflow, type PerformanceMetrics, type Permission, type PermissionStatus, type Platform, type Position, type Product, type ProductType, type Purchase, type PushNotificationPayload, type QRCodeResult, type RadioOption, type ResizeMode, type Row, type SensorData, type SensorOptions, type ShadowOffset, type ShareContent, type ShareResult, type SharedElementFrame, type SharedElementRegistration, type SocialUser, type SpringOptions, type StatusBarStyle, type StyleProp, type StyleSheet, type TextAlign, type TextDecorationLine, type TextDecorationStyle, type TextStyle, type TextTransform, type TimingOptions, type TransactionContext, type TransactionState, type TransactionUpdate, type TransformValue, type UpdateInfo, type UpdateStatus, VActionSheet, type VActionSheetProps, VActivityIndicator, type VActivityIndicatorProps, VAlertDialog, type VAlertDialogProps, VButton, type VButtonProps, VCheckbox, type VCheckboxProps, VDropdown, type VDropdownProps, VImage, type VImageProps, VInput, type VInputProps, VKeyboardAvoiding, type VKeyboardAvoidingProps, VList, type VListProps, VModal, type VModalProps, VPicker, type VPickerProps, VPressable, type VPressableProps, VProgressBar, type VProgressBarProps, VRadio, type VRadioProps, VRefreshControl, type VRefreshControlProps, VSafeArea, type VSafeAreaProps, VScrollView, type VScrollViewProps, VSectionList, type VSectionListProps, VSegmentedControl, type VSegmentedControlProps, VSlider, type VSliderProps, VStatusBar, type VStatusBarProps, VSwitch, type VSwitchProps, VText, type VTextProps, VVideo, type VVideoProps, VView, type VViewProps, VWebView, type VWebViewProps, type VersionInfo, type VideoCaptureOptions, type VideoCaptureResult, type ViewStyle, type WebSocketOptions, type WebSocketStatus, type WebViewSource, clearSharedElementRegistry, createApp, createCommentNode, createNativeNode, createStyleSheet, createTextNode, getRegisteredSharedElements, getSharedElementViewId, measureViewFrame, render, resetNodeId, useAccelerometer, useAnimation, useAppState, useAppleSignIn, useAsyncStorage, useAudio, useBackHandler, useBackgroundTask, useBiometry, useBluetooth, useCalendar, useCamera, useClipboard, useColorScheme, useContacts, useDatabase, useDeviceInfo, useDimensions, useFileSystem, useGeolocation, useGoogleSignIn, useGyroscope, useHaptics, useHttp, useI18n, useIAP, useKeyboard, useLinking, useNetwork, useNotifications, useOTAUpdate, usePerformance, usePermissions, usePlatform, useSecureStorage, useShare, useSharedElementTransition, useWebSocket, vShow, validStyleProperties };
+export { type AccessibilityProps, type ActionSheetAction, type AlertButton, type AlignContent, type AlignItems, type AlignSelf, type AnyStyle, type AppStateStatus, type AudioPlayOptions, type AudioRecordOptions, type AudioRecordResult, type AuthResult, type BLECharacteristic, type BLECharacteristicChange, type BLEDevice, type BLEState, type BackgroundTaskOptions, type BackgroundTaskType, type BiometryResult, type BiometryType, type BorderStyle, type Calendar, type CalendarEvent, type CameraOptions, type CameraResult, type ColorScheme$1 as ColorScheme, type ComposedGesture, type ConnectionType, type Contact, type ContactField, type CreateContactData, type CreateEventOptions, type Dimensions, type Direction, type Display, type DropdownOption, ErrorBoundary, type ExecuteResult, type FileStat, type FlatListRenderItemInfo, type FlexDirection, type FlexWrap, type FontStyle, type FontWeight, type ForceTouchState, type GeoCoordinates, type GestureConfig, type GestureState, type HoverState, type HttpRequestConfig, type HttpResponse, type ImageStyle, type ImportantForAccessibility, type JustifyContent, type LocalNotification, type MenuItem, type MenuSection, type NativeApp, NativeBridge, type NativeNode, type NetworkState, type NotificationPayload, type OpenFileOptions, type Overflow, type PanGestureState, type PerformanceMetrics, type Permission, type PermissionStatus, type PinchGestureState, type Platform, type Position, type Product, type ProductType, type Purchase, type PushNotificationPayload, type QRCodeResult, type RadioOption, type ResizeMode, type RotateGestureState, type Row, type SaveFileOptions, type SensorData, type SensorOptions, type ShadowOffset, type ShareContent, type ShareResult, type SharedElementFrame, type SharedElementRegistration, type SocialUser, type SpringOptions, type StatusBarStyle, type StyleProp, type StyleSheet, type SwipeGestureState, type TabConfig, type TapGestureState, type TextAlign, type TextDecorationLine, type TextDecorationStyle, type TextStyle, type TextTransform, type ThemeContext, type ThemeDefinition, type TimingOptions, type TransactionContext, type TransactionState, type TransactionUpdate, type TransformValue, type UpdateInfo, type UpdateStatus, type UseGestureOptions, type UseGestureReturn, VActionSheet, type VActionSheetProps, VActivityIndicator, type VActivityIndicatorProps, VAlertDialog, type VAlertDialogProps, VButton, type VButtonProps, VCheckbox, type VCheckboxProps, VDrawer, VDrawerItem, type VDrawerItemProps, type VDrawerProps, VDrawerSection, type VDrawerSectionProps, VDropdown, type VDropdownProps, VFlatList, type VFlatListProps, VImage, type VImageProps, VInput, type VInputProps, VKeyboardAvoiding, type VKeyboardAvoidingProps, VList, type VListProps, VModal, type VModalProps, VPicker, type VPickerProps, VPressable, type VPressableProps, VProgressBar, type VProgressBarProps, VRadio, type VRadioProps, VRefreshControl, type VRefreshControlProps, VSafeArea, type VSafeAreaProps, VScrollView, type VScrollViewProps, VSectionList, type VSectionListProps, VSegmentedControl, type VSegmentedControlProps, VSlider, type VSliderProps, VStatusBar, type VStatusBarProps, VSwitch, type VSwitchProps, VTabBar, type VTabBarProps, VText, type VTextProps, VVideo, type VVideoProps, VView, type VViewProps, VWebView, type VWebViewProps, type VersionInfo, type VideoCaptureOptions, type VideoCaptureResult, type ViewStyle, type WebSocketOptions, type WebSocketStatus, type WebViewSource, type WindowInfo, builtInComponents, clearSharedElementRegistry, createApp, createCommentNode, createDynamicStyleSheet, createNativeNode, createStyleSheet, createTextNode, createTheme, getRegisteredSharedElements, getSharedElementViewId, measureViewFrame, render, resetNodeId, useAccelerometer, useAnimation, useAppState, useAppleSignIn, useAsyncStorage, useAudio, useBackHandler, useBackgroundTask, useBiometry, useBluetooth, useCalendar, useCamera, useClipboard, useColorScheme, useComposedGestures, useContacts, useDatabase, useDeviceInfo, useDimensions, useDragDrop, useFileDialog, useFileSystem, useGeolocation, useGesture, useGoogleSignIn, useGyroscope, useHaptics, useHttp, useI18n, useIAP, useKeyboard, useLinking, useMenu, useNetwork, useNotifications, useOTAUpdate, usePerformance, usePermissions, usePlatform, useSecureStorage, useShare, useSharedElementTransition, useTeleport, useWebSocket, useWindow, vModel, vShow, validStyleProperties };