@thelacanians/vue-native-runtime 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,1844 @@
+import * as _vue_runtime_core from '@vue/runtime-core';
+import { Directive, App, Component } from '@vue/runtime-core';
+export * from '@vue/runtime-core';
+import * as _vue_reactivity from '@vue/reactivity';
+
+interface NativeNode {
+    id: number;
+    type: string;
+    props: Record<string, any>;
+    children: NativeNode[];
+    parent: NativeNode | null;
+    isText: boolean;
+    text?: string;
+}
+/**
+ * Reset the node ID counter. Used for testing and hot reload teardown.
+ */
+declare function resetNodeId(): void;
+/**
+ * Create a NativeNode representing a native UIKit view element.
+ * The node is wrapped with markRaw() to prevent Vue's reactivity system
+ * from deeply tracking its internals, which would cause performance issues
+ * and unnecessary re-renders.
+ */
+declare function createNativeNode(type: string): NativeNode;
+/**
+ * Create a text node representing raw text content.
+ * Text nodes use the special '__TEXT__' type and carry their content
+ * in the `text` property.
+ */
+declare function createTextNode(text: string): NativeNode;
+/**
+ * Create a comment node used as a placeholder by Vue's virtual DOM.
+ * Comments are no-ops on the native side — they exist only so Vue
+ * can track insertion points for conditional/list rendering.
+ */
+declare function createCommentNode(text: string): NativeNode;
+
+/**
+ * The Vue 3 custom renderer instance for native iOS views.
+ */
+declare const render: _vue_runtime_core.RootRenderFunction<NativeNode>;
+
+/**
+ * StyleSheet utility for Vue Native.
+ *
+ * Provides a createStyleSheet helper similar to React Native's StyleSheet.create().
+ * In development mode, validates style property names against a known list.
+ * In production, skips validation for performance.
+ * The returned style object is frozen to prevent accidental mutation.
+ */
+/**
+ * Complete list of valid style property names recognized by the native layout
+ * engine (Yoga-based) and the UIKit rendering layer.
+ */
+declare const validStyleProperties: ReadonlySet<string>;
+/**
+ * A single style declaration — a flat object of style properties.
+ */
+type StyleProp = Record<string, any>;
+/**
+ * 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<{
+    [K in keyof T]: Readonly<T[K]>;
+}>;
+/**
+ * Create a style sheet object. This is the recommended way to define styles
+ * for Vue Native components.
+ *
+ * In development mode, each style property is validated against the known
+ * list of valid properties. Unknown properties will trigger a console warning.
+ *
+ * The returned object and each individual style are Object.freeze()'d to
+ * prevent accidental mutation.
+ *
+ * @example
+ * ```ts
+ * const styles = createStyleSheet({
+ *   container: {
+ *     flex: 1,
+ *     backgroundColor: '#ffffff',
+ *     padding: 16,
+ *   },
+ *   title: {
+ *     fontSize: 24,
+ *     fontWeight: 'bold',
+ *     color: '#333333',
+ *   },
+ * })
+ * ```
+ */
+declare function createStyleSheet<T extends Record<string, StyleProp>>(styles: T): StyleSheet<T>;
+
+/**
+ * VView — the fundamental container component in Vue Native.
+ *
+ * Maps to UIView on iOS. Supports flexbox layout via the native Yoga
+ * layout engine. This is the equivalent of a <div> in web development.
+ *
+ * @example
+ * ```vue
+ * <VView :style="{ flex: 1, padding: 16, backgroundColor: '#fff' }">
+ *   <VText>Hello World</VText>
+ * </VView>
+ * ```
+ */
+declare const VView: _vue_runtime_core.DefineComponent<_vue_runtime_core.ExtractPropTypes<{
+    style: ObjectConstructor;
+    testID: StringConstructor;
+    accessibilityLabel: StringConstructor;
+}>, () => _vue_runtime_core.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<{
+    style: ObjectConstructor;
+    testID: StringConstructor;
+    accessibilityLabel: StringConstructor;
+}>> & Readonly<{}>, {}, {}, {}, {}, string, _vue_runtime_core.ComponentProvideOptions, true, {}, any>;
+
+/**
+ * VText — component for displaying text content.
+ *
+ * Maps to UILabel on iOS. All text in Vue Native must be wrapped in a
+ * VText component — raw text outside of VText will not be rendered.
+ *
+ * Supports text-specific styling such as fontSize, fontWeight, color,
+ * lineHeight, letterSpacing, textAlign, and more.
+ *
+ * @example
+ * ```vue
+ * <VText :style="{ fontSize: 18, color: '#333' }" :numberOfLines="2">
+ *   Hello, Vue Native!
+ * </VText>
+ * ```
+ */
+declare const VText: _vue_runtime_core.DefineComponent<_vue_runtime_core.ExtractPropTypes<{
+    style: ObjectConstructor;
+    numberOfLines: NumberConstructor;
+    selectable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    accessibilityRole: StringConstructor;
+}>, () => _vue_runtime_core.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<{
+    style: ObjectConstructor;
+    numberOfLines: NumberConstructor;
+    selectable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    accessibilityRole: StringConstructor;
+}>> & Readonly<{}>, {
+    selectable: boolean;
+}, {}, {}, {}, string, _vue_runtime_core.ComponentProvideOptions, true, {}, any>;
+
+/**
+ * VButton — a pressable button component.
+ *
+ * Maps to a tappable UIView on iOS with built-in press animation.
+ * Provides onPress and onLongPress event handling. The activeOpacity
+ * controls how transparent the button becomes when pressed.
+ *
+ * @example
+ * ```vue
+ * <VButton
+ *   :style="{ backgroundColor: '#007AFF', padding: 12, borderRadius: 8 }"
+ *   :onPress="handleTap"
+ *   :disabled="isLoading"
+ * >
+ *   <VText :style="{ color: '#fff', textAlign: 'center' }">Tap Me</VText>
+ * </VButton>
+ * ```
+ */
+declare const VButton: _vue_runtime_core.DefineComponent<_vue_runtime_core.ExtractPropTypes<{
+    style: ObjectConstructor;
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    activeOpacity: {
+        type: NumberConstructor;
+        default: number;
+    };
+    onPress: FunctionConstructor;
+    onLongPress: FunctionConstructor;
+}>, () => _vue_runtime_core.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<{
+    style: ObjectConstructor;
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    activeOpacity: {
+        type: NumberConstructor;
+        default: number;
+    };
+    onPress: FunctionConstructor;
+    onLongPress: FunctionConstructor;
+}>> & Readonly<{}>, {
+    disabled: boolean;
+    activeOpacity: number;
+}, {}, {}, {}, string, _vue_runtime_core.ComponentProvideOptions, true, {}, any>;
+
+/**
+ * VInput — a text input component with v-model support.
+ *
+ * Maps to UITextField (single-line) or UITextView (multiline) on iOS.
+ * Implements Vue's v-model convention by accepting a `modelValue` prop
+ * and emitting `update:modelValue` on text change.
+ *
+ * The component maps `modelValue` to the native `text` prop and listens
+ * for `changetext` events from the native side to update the model.
+ *
+ * @example
+ * ```vue
+ * <VInput
+ *   v-model="username"
+ *   placeholder="Enter your name"
+ *   :style="{ borderWidth: 1, borderColor: '#ccc', padding: 8 }"
+ *   @focus="onFocus"
+ *   @blur="onBlur"
+ * />
+ * ```
+ */
+declare const VInput: _vue_runtime_core.DefineComponent<_vue_runtime_core.ExtractPropTypes<{
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    placeholder: StringConstructor;
+    secureTextEntry: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    keyboardType: {
+        type: StringConstructor;
+        default: string;
+    };
+    returnKeyType: {
+        type: StringConstructor;
+        default: string;
+    };
+    autoCapitalize: {
+        type: StringConstructor;
+        default: string;
+    };
+    autoCorrect: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    maxLength: NumberConstructor;
+    multiline: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    style: ObjectConstructor;
+}>, () => _vue_runtime_core.VNode<_vue_runtime_core.RendererNode, _vue_runtime_core.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, _vue_runtime_core.ComponentOptionsMixin, _vue_runtime_core.ComponentOptionsMixin, ("update:modelValue" | "focus" | "blur" | "submit")[], "update:modelValue" | "focus" | "blur" | "submit", _vue_runtime_core.PublicProps, Readonly<_vue_runtime_core.ExtractPropTypes<{
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    placeholder: StringConstructor;
+    secureTextEntry: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    keyboardType: {
+        type: StringConstructor;
+        default: string;
+    };
+    returnKeyType: {
+        type: StringConstructor;
+        default: string;
+    };
+    autoCapitalize: {
+        type: StringConstructor;
+        default: string;
+    };
+    autoCorrect: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    maxLength: NumberConstructor;
+    multiline: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    style: ObjectConstructor;
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+    onFocus?: ((...args: any[]) => any) | undefined;
+    onBlur?: ((...args: any[]) => any) | undefined;
+    onSubmit?: ((...args: any[]) => any) | undefined;
+}>, {
+    modelValue: string;
+    secureTextEntry: boolean;
+    keyboardType: string;
+    returnKeyType: string;
+    autoCapitalize: string;
+    autoCorrect: boolean;
+    multiline: boolean;
+}, {}, {}, {}, string, _vue_runtime_core.ComponentProvideOptions, true, {}, any>;
+
+/**
+ * VSwitch — a boolean toggle switch component.
+ *
+ * Maps to UISwitch on iOS. Supports v-model for two-way binding.
+ *
+ * @example
+ * ```vue
+ * <VSwitch v-model="notificationsEnabled" :onTintColor="'#34C759'" />
+ * ```
+ */
+declare const VSwitch: _vue_runtime_core.DefineComponent<_vue_runtime_core.ExtractPropTypes<{
+    modelValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    onTintColor: StringConstructor;
+    thumbTintColor: StringConstructor;
+    style: ObjectConstructor;
+}>, () => _vue_runtime_core.VNode<_vue_runtime_core.RendererNode, _vue_runtime_core.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, _vue_runtime_core.ComponentOptionsMixin, _vue_runtime_core.ComponentOptionsMixin, ("update:modelValue" | "change")[], "update:modelValue" | "change", _vue_runtime_core.PublicProps, Readonly<_vue_runtime_core.ExtractPropTypes<{
+    modelValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    onTintColor: StringConstructor;
+    thumbTintColor: StringConstructor;
+    style: ObjectConstructor;
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+    onChange?: ((...args: any[]) => any) | undefined;
+}>, {
+    disabled: boolean;
+    modelValue: boolean;
+}, {}, {}, {}, string, _vue_runtime_core.ComponentProvideOptions, true, {}, any>;
+
+/**
+ * VActivityIndicator — a loading spinner component.
+ *
+ * Maps to UIActivityIndicatorView on iOS.
+ * Automatically hides when not animating (configurable via hidesWhenStopped).
+ *
+ * @example
+ * ```vue
+ * <VActivityIndicator :animating="isLoading" color="#007AFF" size="large" />
+ * ```
+ */
+declare const VActivityIndicator: _vue_runtime_core.DefineComponent<_vue_runtime_core.ExtractPropTypes<{
+    animating: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    color: StringConstructor;
+    size: {
+        type: StringConstructor;
+        default: string;
+    };
+    hidesWhenStopped: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    style: ObjectConstructor;
+}>, () => _vue_runtime_core.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<{
+    animating: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    color: StringConstructor;
+    size: {
+        type: StringConstructor;
+        default: string;
+    };
+    hidesWhenStopped: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    style: ObjectConstructor;
+}>> & Readonly<{}>, {
+    size: string;
+    animating: boolean;
+    hidesWhenStopped: boolean;
+}, {}, {}, {}, string, _vue_runtime_core.ComponentProvideOptions, true, {}, any>;
+
+/**
+ * VScrollView — a scrollable container component.
+ *
+ * Maps to UIScrollView on iOS. Children are automatically added to an
+ * inner content view so Yoga can compute their natural size unconstrained
+ * by the scroll view's visible bounds.
+ *
+ * @example
+ * ```vue
+ * <VScrollView :style="{ flex: 1 }">
+ *   <VView v-for="item in items" :key="item.id" :style="styles.row">
+ *     <VText>{{ item.title }}</VText>
+ *   </VView>
+ * </VScrollView>
+ * ```
+ */
+declare const VScrollView: _vue_runtime_core.DefineComponent<_vue_runtime_core.ExtractPropTypes<{
+    horizontal: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showsVerticalScrollIndicator: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showsHorizontalScrollIndicator: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    scrollEnabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    bounces: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    pagingEnabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    contentContainerStyle: ObjectConstructor;
+    /** Whether the pull-to-refresh indicator is active */
+    refreshing: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    style: ObjectConstructor;
+}>, () => _vue_runtime_core.VNode<_vue_runtime_core.RendererNode, _vue_runtime_core.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, _vue_runtime_core.ComponentOptionsMixin, _vue_runtime_core.ComponentOptionsMixin, ("scroll" | "refresh")[], "scroll" | "refresh", _vue_runtime_core.PublicProps, Readonly<_vue_runtime_core.ExtractPropTypes<{
+    horizontal: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showsVerticalScrollIndicator: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showsHorizontalScrollIndicator: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    scrollEnabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    bounces: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    pagingEnabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    contentContainerStyle: ObjectConstructor;
+    /** Whether the pull-to-refresh indicator is active */
+    refreshing: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    style: ObjectConstructor;
+}>> & Readonly<{
+    onScroll?: ((...args: any[]) => any) | undefined;
+    onRefresh?: ((...args: any[]) => any) | undefined;
+}>, {
+    horizontal: boolean;
+    showsVerticalScrollIndicator: boolean;
+    showsHorizontalScrollIndicator: boolean;
+    scrollEnabled: boolean;
+    bounces: boolean;
+    pagingEnabled: boolean;
+    refreshing: boolean;
+}, {}, {}, {}, string, _vue_runtime_core.ComponentProvideOptions, true, {}, any>;
+
+/**
+ * VImage — the image display component in Vue Native.
+ *
+ * Maps to UIImageView on iOS. Loads images from URIs asynchronously
+ * with built-in caching. Supports various resize modes.
+ *
+ * @example
+ * ```vue
+ * <VImage
+ *   :source="{ uri: 'https://example.com/photo.jpg' }"
+ *   resizeMode="cover"
+ *   :style="{ width: 200, height: 150 }"
+ *   @load="onImageLoad"
+ *   @error="onImageError"
+ * />
+ * ```
+ */
+declare const VImage: _vue_runtime_core.DefineComponent<_vue_runtime_core.ExtractPropTypes<{
+    source: () => {
+        uri: string;
+    };
+    resizeMode: {
+        type: () => "cover" | "contain" | "stretch" | "center";
+        default: string;
+    };
+    style: ObjectConstructor;
+    testID: StringConstructor;
+    accessibilityLabel: StringConstructor;
+}>, () => _vue_runtime_core.VNode<_vue_runtime_core.RendererNode, _vue_runtime_core.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, _vue_runtime_core.ComponentOptionsMixin, _vue_runtime_core.ComponentOptionsMixin, ("load" | "error")[], "load" | "error", _vue_runtime_core.PublicProps, Readonly<_vue_runtime_core.ExtractPropTypes<{
+    source: () => {
+        uri: string;
+    };
+    resizeMode: {
+        type: () => "cover" | "contain" | "stretch" | "center";
+        default: string;
+    };
+    style: ObjectConstructor;
+    testID: StringConstructor;
+    accessibilityLabel: StringConstructor;
+}>> & Readonly<{
+    onLoad?: ((...args: any[]) => any) | undefined;
+    onError?: ((...args: any[]) => any) | undefined;
+}>, {
+    resizeMode: "cover" | "contain" | "stretch" | "center";
+}, {}, {}, {}, string, _vue_runtime_core.ComponentProvideOptions, true, {}, any>;
+
+/**
+ * VKeyboardAvoiding — a container that adjusts its bottom padding when
+ * the keyboard appears, preventing content from being obscured.
+ *
+ * Maps to a native UIView that observes keyboard notifications and
+ * automatically adjusts the Yoga bottom padding.
+ *
+ * @example
+ * ```vue
+ * <VKeyboardAvoiding :style="{ flex: 1 }">
+ *   <VInput placeholder="Type here..." />
+ * </VKeyboardAvoiding>
+ * ```
+ */
+declare const VKeyboardAvoiding: _vue_runtime_core.DefineComponent<_vue_runtime_core.ExtractPropTypes<{
+    style: ObjectConstructor;
+    testID: StringConstructor;
+}>, () => _vue_runtime_core.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<{
+    style: ObjectConstructor;
+    testID: StringConstructor;
+}>> & Readonly<{}>, {}, {}, {}, {}, string, _vue_runtime_core.ComponentProvideOptions, true, {}, any>;
+
+declare const VSafeArea: _vue_runtime_core.DefineComponent<_vue_runtime_core.ExtractPropTypes<{
+    style: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+}>, () => _vue_runtime_core.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<{
+    style: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+}>> & Readonly<{}>, {
+    style: Record<string, any>;
+}, {}, {}, {}, string, _vue_runtime_core.ComponentProvideOptions, true, {}, any>;
+
+declare const VSlider: _vue_runtime_core.DefineComponent<_vue_runtime_core.ExtractPropTypes<{
+    modelValue: {
+        type: NumberConstructor;
+        default: number;
+    };
+    min: {
+        type: NumberConstructor;
+        default: number;
+    };
+    max: {
+        type: NumberConstructor;
+        default: number;
+    };
+    style: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+}>, () => _vue_runtime_core.VNode<_vue_runtime_core.RendererNode, _vue_runtime_core.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, _vue_runtime_core.ComponentOptionsMixin, _vue_runtime_core.ComponentOptionsMixin, ("update:modelValue" | "change")[], "update:modelValue" | "change", _vue_runtime_core.PublicProps, Readonly<_vue_runtime_core.ExtractPropTypes<{
+    modelValue: {
+        type: NumberConstructor;
+        default: number;
+    };
+    min: {
+        type: NumberConstructor;
+        default: number;
+    };
+    max: {
+        type: NumberConstructor;
+        default: number;
+    };
+    style: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+    onChange?: ((...args: any[]) => any) | undefined;
+}>, {
+    style: Record<string, any>;
+    modelValue: number;
+    min: number;
+    max: number;
+}, {}, {}, {}, string, _vue_runtime_core.ComponentProvideOptions, true, {}, any>;
+
+/**
+ * VList — A virtualized list component backed by UITableView on iOS.
+ *
+ * Renders each item in `data` via the default `#item` slot.
+ * Supports thousands of items with smooth scrolling and cell recycling.
+ *
+ * @example
+ * <VList
+ *   :data="items"
+ *   :estimatedItemHeight="72"
+ *   :style="{ flex: 1 }"
+ *   @endReached="loadMore"
+ * >
+ *   <template #item="{ item, index }">
+ *     <VView :style="rowStyle">
+ *       <VText>{{ item.title }}</VText>
+ *     </VView>
+ *   </template>
+ * </VList>
+ */
+declare const VList: _vue_runtime_core.DefineComponent<_vue_runtime_core.ExtractPropTypes<{
+    /** Array of data items to render */
+    data: {
+        type: () => any[];
+        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;
+    };
+    /** Estimated height per row in points. Used before layout runs. Default: 44 */
+    estimatedItemHeight: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /** Show vertical scroll indicator. Default: true */
+    showsScrollIndicator: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Enable bounce at scroll boundaries. Default: true */
+    bounces: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Render list horizontally. Default: false */
+    horizontal: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    style: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+}>, () => _vue_runtime_core.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[];
+        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;
+    };
+    /** Estimated height per row in points. Used before layout runs. Default: 44 */
+    estimatedItemHeight: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /** Show vertical scroll indicator. Default: true */
+    showsScrollIndicator: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Enable bounce at scroll boundaries. Default: true */
+    bounces: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Render list horizontally. Default: false */
+    horizontal: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    style: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+}>> & Readonly<{
+    onScroll?: ((...args: any[]) => any) | undefined;
+    onEndReached?: ((...args: any[]) => any) | undefined;
+}>, {
+    style: Record<string, any>;
+    horizontal: boolean;
+    bounces: boolean;
+    keyExtractor: (item: any, index: number) => string;
+    estimatedItemHeight: number;
+    showsScrollIndicator: boolean;
+}, {}, {}, {}, string, _vue_runtime_core.ComponentProvideOptions, true, {}, any>;
+
+/**
+ * Window-level modal overlay component.
+ * Renders its children in a full-screen overlay on the key window.
+ *
+ * @example
+ * <VModal :visible="showModal" @dismiss="showModal = false">
+ *   <VView style="..."><VText>Hello</VText></VView>
+ * </VModal>
+ */
+declare const VModal: _vue_runtime_core.DefineComponent<_vue_runtime_core.ExtractPropTypes<{
+    visible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    style: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+}>, () => _vue_runtime_core.VNode<_vue_runtime_core.RendererNode, _vue_runtime_core.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, _vue_runtime_core.ComponentOptionsMixin, _vue_runtime_core.ComponentOptionsMixin, "dismiss"[], "dismiss", _vue_runtime_core.PublicProps, Readonly<_vue_runtime_core.ExtractPropTypes<{
+    visible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    style: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+}>> & Readonly<{
+    onDismiss?: ((...args: any[]) => any) | undefined;
+}>, {
+    style: Record<string, any>;
+    visible: boolean;
+}, {}, {}, {}, string, _vue_runtime_core.ComponentProvideOptions, true, {}, any>;
+
+interface AlertButton {
+    label: string;
+    style?: 'default' | 'cancel' | 'destructive';
+}
+/**
+ * Native alert dialog component.
+ *
+ * @example
+ * <VAlertDialog
+ *   :visible="showAlert"
+ *   title="Confirm"
+ *   message="Are you sure?"
+ *   :buttons="[{ label: 'Cancel', style: 'cancel' }, { label: 'Delete', style: 'destructive' }]"
+ *   @confirm="onConfirm"
+ *   @cancel="showAlert = false"
+ * />
+ */
+declare const VAlertDialog: _vue_runtime_core.DefineComponent<_vue_runtime_core.ExtractPropTypes<{
+    visible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+    message: {
+        type: StringConstructor;
+        default: string;
+    };
+    buttons: {
+        type: () => AlertButton[];
+        default: () => never[];
+    };
+}>, () => _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<{
+    visible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+    message: {
+        type: StringConstructor;
+        default: string;
+    };
+    buttons: {
+        type: () => AlertButton[];
+        default: () => never[];
+    };
+}>> & Readonly<{
+    onConfirm?: ((...args: any[]) => any) | undefined;
+    onCancel?: ((...args: any[]) => any) | undefined;
+    onAction?: ((...args: any[]) => any) | undefined;
+}>, {
+    visible: boolean;
+    title: string;
+    message: string;
+    buttons: AlertButton[];
+}, {}, {}, {}, string, _vue_runtime_core.ComponentProvideOptions, true, {}, any>;
+
+type StatusBarStyle = 'default' | 'light-content' | 'dark-content';
+/**
+ * Control the system status bar appearance.
+ *
+ * @example
+ * <VStatusBar bar-style="light-content" />
+ */
+declare const VStatusBar: _vue_runtime_core.DefineComponent<_vue_runtime_core.ExtractPropTypes<{
+    barStyle: {
+        type: () => StatusBarStyle;
+        default: string;
+    };
+    hidden: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    animated: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => _vue_runtime_core.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<{
+    barStyle: {
+        type: () => StatusBarStyle;
+        default: string;
+    };
+    hidden: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    animated: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    barStyle: StatusBarStyle;
+    hidden: boolean;
+    animated: boolean;
+}, {}, {}, {}, string, _vue_runtime_core.ComponentProvideOptions, true, {}, any>;
+
+interface WebViewSource {
+    uri?: string;
+    html?: string;
+}
+/**
+ * Embedded web view component backed by WKWebView.
+ *
+ * @example
+ * <VWebView :source="{ uri: 'https://example.com' }" style="flex: 1" @load="onLoad" />
+ */
+declare const VWebView: _vue_runtime_core.DefineComponent<_vue_runtime_core.ExtractPropTypes<{
+    source: {
+        type: () => WebViewSource;
+        required: true;
+    };
+    style: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    javaScriptEnabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => _vue_runtime_core.VNode<_vue_runtime_core.RendererNode, _vue_runtime_core.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, _vue_runtime_core.ComponentOptionsMixin, _vue_runtime_core.ComponentOptionsMixin, ("load" | "error" | "message")[], "load" | "error" | "message", _vue_runtime_core.PublicProps, Readonly<_vue_runtime_core.ExtractPropTypes<{
+    source: {
+        type: () => WebViewSource;
+        required: true;
+    };
+    style: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    javaScriptEnabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onLoad?: ((...args: any[]) => any) | undefined;
+    onError?: ((...args: any[]) => any) | undefined;
+    onMessage?: ((...args: any[]) => any) | undefined;
+}>, {
+    style: Record<string, any>;
+    javaScriptEnabled: boolean;
+}, {}, {}, {}, string, _vue_runtime_core.ComponentProvideOptions, true, {}, any>;
+
+/**
+ * Horizontal progress indicator bar.
+ *
+ * @example
+ * <VProgressBar :progress="0.75" progressTintColor="#007AFF" />
+ */
+declare const VProgressBar: _vue_runtime_core.DefineComponent<_vue_runtime_core.ExtractPropTypes<{
+    progress: {
+        type: NumberConstructor;
+        default: number;
+    };
+    progressTintColor: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    trackTintColor: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    animated: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    style: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+}>, () => _vue_runtime_core.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<{
+    progress: {
+        type: NumberConstructor;
+        default: number;
+    };
+    progressTintColor: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    trackTintColor: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    animated: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    style: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+}>> & Readonly<{}>, {
+    style: Record<string, any>;
+    animated: boolean;
+    progress: number;
+    progressTintColor: string;
+    trackTintColor: string;
+}, {}, {}, {}, string, _vue_runtime_core.ComponentProvideOptions, true, {}, any>;
+
+/**
+ * Date/time picker component.
+ *
+ * @example
+ * <VPicker mode="date" :value="date" @change="date = $event.value" />
+ */
+declare const VPicker: _vue_runtime_core.DefineComponent<_vue_runtime_core.ExtractPropTypes<{
+    mode: {
+        type: () => "date" | "time" | "datetime";
+        default: string;
+    };
+    value: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    minimumDate: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    maximumDate: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    minuteInterval: {
+        type: NumberConstructor;
+        default: number;
+    };
+    style: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+}>, () => _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<{
+    mode: {
+        type: () => "date" | "time" | "datetime";
+        default: string;
+    };
+    value: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    minimumDate: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    maximumDate: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    minuteInterval: {
+        type: NumberConstructor;
+        default: number;
+    };
+    style: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+}>> & Readonly<{
+    onChange?: ((...args: any[]) => any) | undefined;
+}>, {
+    style: Record<string, any>;
+    mode: "date" | "time" | "datetime";
+    value: number;
+    minimumDate: number;
+    maximumDate: number;
+    minuteInterval: number;
+}, {}, {}, {}, string, _vue_runtime_core.ComponentProvideOptions, true, {}, any>;
+
+/**
+ * Segmented control (tab strip) component.
+ *
+ * @example
+ * <VSegmentedControl
+ *   :values="['Day', 'Week', 'Month']"
+ *   :selectedIndex="0"
+ *   @change="onSegmentChange"
+ * />
+ */
+declare const VSegmentedControl: _vue_runtime_core.DefineComponent<_vue_runtime_core.ExtractPropTypes<{
+    values: {
+        type: () => string[];
+        required: true;
+    };
+    selectedIndex: {
+        type: NumberConstructor;
+        default: number;
+    };
+    tintColor: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    enabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    style: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+}>, () => _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<{
+    values: {
+        type: () => string[];
+        required: true;
+    };
+    selectedIndex: {
+        type: NumberConstructor;
+        default: number;
+    };
+    tintColor: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    enabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    style: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+}>> & Readonly<{
+    onChange?: ((...args: any[]) => any) | undefined;
+}>, {
+    style: Record<string, any>;
+    selectedIndex: number;
+    tintColor: string;
+    enabled: boolean;
+}, {}, {}, {}, string, _vue_runtime_core.ComponentProvideOptions, true, {}, any>;
+
+interface ActionSheetAction {
+    label: string;
+    style?: 'default' | 'cancel' | 'destructive';
+}
+/**
+ * Native action sheet (bottom sheet with multiple actions).
+ *
+ * @example
+ * <VActionSheet
+ *   :visible="showSheet"
+ *   title="Choose an option"
+ *   :actions="[
+ *     { label: 'Edit' },
+ *     { label: 'Delete', style: 'destructive' },
+ *     { label: 'Cancel', style: 'cancel' },
+ *   ]"
+ *   @action="onAction"
+ *   @cancel="showSheet = false"
+ * />
+ */
+declare const VActionSheet: _vue_runtime_core.DefineComponent<_vue_runtime_core.ExtractPropTypes<{
+    visible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    title: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    message: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    actions: {
+        type: () => ActionSheetAction[];
+        default: () => never[];
+    };
+}>, () => _vue_runtime_core.VNode<_vue_runtime_core.RendererNode, _vue_runtime_core.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, _vue_runtime_core.ComponentOptionsMixin, _vue_runtime_core.ComponentOptionsMixin, ("cancel" | "action")[], "cancel" | "action", _vue_runtime_core.PublicProps, Readonly<_vue_runtime_core.ExtractPropTypes<{
+    visible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    title: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    message: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    actions: {
+        type: () => ActionSheetAction[];
+        default: () => never[];
+    };
+}>> & Readonly<{
+    onCancel?: ((...args: any[]) => any) | undefined;
+    onAction?: ((...args: any[]) => any) | undefined;
+}>, {
+    visible: boolean;
+    title: string;
+    message: string;
+    actions: ActionSheetAction[];
+}, {}, {}, {}, 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>;
+
+/**
+ * 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.
+ *
+ * @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;
+    }>;
+};
+
+declare const Easing: {
+    readonly linear: "linear";
+    readonly ease: "ease";
+    readonly easeIn: "easeIn";
+    readonly easeOut: "easeOut";
+    readonly easeInOut: "easeInOut";
+};
+type EasingType = typeof Easing[keyof typeof Easing];
+interface TimingConfig {
+    duration?: number;
+    easing?: EasingType;
+    delay?: number;
+}
+interface SpringConfig {
+    tension?: number;
+    friction?: number;
+    mass?: number;
+    velocity?: number;
+    delay?: number;
+}
+interface KeyframeStep {
+    offset: number;
+    opacity?: number;
+    translateX?: number;
+    translateY?: number;
+    scale?: number;
+    scaleX?: number;
+    scaleY?: number;
+}
+interface SequenceAnimation {
+    type: 'timing' | 'spring';
+    viewId: number;
+    toStyles: Record<string, any>;
+    options: TimingConfig | SpringConfig;
+}
+type TimingOptions = TimingConfig;
+type SpringOptions = SpringConfig;
+/**
+ * Imperative animation API backed by native UIView/CALayer animations.
+ *
+ * @example
+ * const { timing, spring, keyframe, sequence, parallel } = useAnimation()
+ *
+ * // Fade in
+ * await timing(viewId, { opacity: 1 }, { duration: 300 })
+ *
+ * // Spring bounce
+ * await spring(viewId, { translateY: 0 }, { tension: 40, friction: 7 })
+ *
+ * // Keyframe flash
+ * await keyframe(viewId, [
+ *   { offset: 0, opacity: 1 },
+ *   { offset: 0.5, opacity: 0 },
+ *   { offset: 1, opacity: 1 },
+ * ], { duration: 600 })
+ *
+ * // 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 } },
+ * ])
+ */
+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?: {
+        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>;
+    Easing: {
+        readonly linear: "linear";
+        readonly ease: "ease";
+        readonly easeIn: "easeIn";
+        readonly easeOut: "easeOut";
+        readonly easeInOut: "easeInOut";
+    };
+};
+
+type ConnectionType = 'wifi' | 'cellular' | 'ethernet' | 'none' | 'unknown';
+interface NetworkState {
+    isConnected: boolean;
+    connectionType: ConnectionType;
+}
+/**
+ * Reactive network connectivity status.
+ * Subscribes to native NWPathMonitor push events.
+ *
+ * @example
+ * const { isConnected, connectionType } = useNetwork()
+ */
+declare function useNetwork(): {
+    isConnected: _vue_reactivity.Ref<boolean, boolean>;
+    connectionType: _vue_reactivity.Ref<ConnectionType, ConnectionType>;
+};
+
+type AppStateStatus = 'active' | 'inactive' | 'background' | 'unknown';
+/**
+ * Reactive app foreground/background state.
+ * Subscribes to native UIApplication lifecycle notifications.
+ *
+ * @example
+ * const { state } = useAppState()
+ * watch(state, s => { if (s === 'background') saveData() })
+ */
+declare function useAppState(): {
+    state: _vue_reactivity.Ref<AppStateStatus, AppStateStatus>;
+};
+
+/**
+ * Utilities for opening URLs and checking URL scheme support.
+ *
+ * @example
+ * const { openURL, canOpenURL } = useLinking()
+ * await openURL('https://example.com')
+ */
+declare function useLinking(): {
+    openURL: (url: string) => Promise<void>;
+    canOpenURL: (url: string) => Promise<boolean>;
+};
+
+interface ShareContent {
+    message?: string;
+    url?: string;
+}
+interface ShareResult {
+    shared: boolean;
+}
+/**
+ * Show the native share sheet.
+ *
+ * @example
+ * const { share } = useShare()
+ * await share({ message: 'Hello from Vue Native!', url: 'https://example.com' })
+ */
+declare function useShare(): {
+    share: (content: ShareContent) => Promise<ShareResult>;
+};
+
+type Permission = 'camera' | 'microphone' | 'photos' | 'location' | 'locationAlways' | 'notifications';
+type PermissionStatus = 'granted' | 'denied' | 'restricted' | 'limited' | 'notDetermined';
+/**
+ * Check and request runtime permissions.
+ *
+ * @example
+ * const { request, check } = usePermissions()
+ * const status = await request('camera')
+ * if (status === 'granted') { ... }
+ */
+declare function usePermissions(): {
+    request: (permission: Permission) => Promise<PermissionStatus>;
+    check: (permission: Permission) => Promise<PermissionStatus>;
+};
+
+interface GeoCoordinates {
+    latitude: number;
+    longitude: number;
+    altitude: number;
+    accuracy: number;
+    altitudeAccuracy: number;
+    heading: number;
+    speed: number;
+    timestamp: number;
+}
+/**
+ * GPS location access with optional continuous watching.
+ *
+ * @example
+ * const { coords, getCurrentPosition } = useGeolocation()
+ * await getCurrentPosition()
+ * console.log(coords.value?.latitude)
+ */
+declare function useGeolocation(): {
+    coords: _vue_reactivity.Ref<{
+        latitude: number;
+        longitude: number;
+        altitude: number;
+        accuracy: number;
+        altitudeAccuracy: number;
+        heading: number;
+        speed: number;
+        timestamp: number;
+    } | null, GeoCoordinates | {
+        latitude: number;
+        longitude: number;
+        altitude: number;
+        accuracy: number;
+        altitudeAccuracy: number;
+        heading: number;
+        speed: number;
+        timestamp: number;
+    } | null>;
+    error: _vue_reactivity.Ref<string | null, string | null>;
+    getCurrentPosition: () => Promise<GeoCoordinates>;
+    watchPosition: () => Promise<number>;
+    clearWatch: (id: number) => Promise<void>;
+};
+
+interface CameraOptions {
+    mediaType?: 'photo' | 'video';
+    quality?: number;
+    selectionLimit?: number;
+}
+interface CameraResult {
+    uri: string;
+    width: number;
+    height: number;
+    type: string;
+    didCancel?: boolean;
+}
+/**
+ * Launch the camera or image library.
+ *
+ * @example
+ * const { launchCamera, launchImageLibrary } = useCamera()
+ * const result = await launchImageLibrary()
+ * if (!result.didCancel) imageUri.value = result.uri
+ */
+declare function useCamera(): {
+    launchCamera: (options?: CameraOptions) => Promise<CameraResult>;
+    launchImageLibrary: (options?: CameraOptions) => Promise<CameraResult>;
+};
+
+interface LocalNotification {
+    id?: string;
+    title: string;
+    body: string;
+    delay?: number;
+    sound?: 'default' | null;
+    badge?: number;
+    data?: Record<string, any>;
+}
+interface NotificationPayload {
+    id: string;
+    title: string;
+    body: string;
+    data: Record<string, any>;
+    action?: string;
+}
+/**
+ * Local notification scheduling and permission management.
+ *
+ * @example
+ * const { requestPermission, scheduleLocal, onNotification } = useNotifications()
+ * await requestPermission()
+ * await scheduleLocal({ title: 'Reminder', body: 'Don\'t forget!', delay: 5 })
+ */
+declare function useNotifications(): {
+    isGranted: _vue_reactivity.Ref<boolean, boolean>;
+    requestPermission: () => Promise<boolean>;
+    getPermissionStatus: () => Promise<string>;
+    scheduleLocal: (notification: LocalNotification) => Promise<string>;
+    cancel: (id: string) => Promise<void>;
+    cancelAll: () => Promise<void>;
+    onNotification: (handler: (payload: NotificationPayload) => void) => () => void;
+};
+
+type BiometryType = 'faceID' | 'touchID' | 'opticID' | 'none';
+interface BiometryResult {
+    success: boolean;
+    error?: string;
+}
+/**
+ * Biometric authentication (Face ID / Touch ID).
+ *
+ * @example
+ * const { authenticate, getSupportedBiometry } = useBiometry()
+ * const type = await getSupportedBiometry() // 'faceID' | 'touchID' | 'none'
+ * const result = await authenticate('Confirm your identity')
+ */
+declare function useBiometry(): {
+    authenticate: (reason?: string) => Promise<BiometryResult>;
+    getSupportedBiometry: () => Promise<BiometryType>;
+    isAvailable: () => Promise<boolean>;
+};
+
+interface HttpRequestConfig {
+    baseURL?: string;
+    headers?: Record<string, string>;
+    timeout?: number;
+}
+interface HttpResponse<T = any> {
+    data: T;
+    status: number;
+    ok: boolean;
+    headers: Record<string, string>;
+}
+/**
+ * HTTP client composable with reactive loading/error state.
+ * Uses the native fetch polyfill under the hood.
+ *
+ * @example
+ * const http = useHttp({ baseURL: 'https://api.example.com' })
+ * const users = await http.get<User[]>('/users')
+ */
+declare function useHttp(config?: HttpRequestConfig): {
+    loading: _vue_reactivity.Ref<boolean, boolean>;
+    error: _vue_reactivity.Ref<string | null, string | null>;
+    get: <T = any>(url: string, headers?: 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, headers?: Record<string, string>) => Promise<HttpResponse<T>>;
+};
+
+type ColorScheme = 'light' | 'dark';
+/**
+ * Reactive dark mode / color scheme detection.
+ * Updates automatically when the user switches between light and dark mode.
+ *
+ * @example
+ * const { colorScheme, isDark } = useColorScheme()
+ *
+ * const bgColor = computed(() => isDark.value ? '#000' : '#FFF')
+ */
+declare function useColorScheme(): {
+    colorScheme: _vue_reactivity.Ref<ColorScheme, ColorScheme>;
+    isDark: _vue_reactivity.Ref<boolean, boolean>;
+};
+
+/**
+ * useBackHandler — intercept the hardware back button press (Android).
+ *
+ * The callback should return `true` if the back press was handled
+ * (preventing default behavior), or `false` to allow default navigation.
+ *
+ * On iOS this is a no-op since there is no hardware back button,
+ * but the event can still be dispatched programmatically.
+ *
+ * @example
+ * ```ts
+ * useBackHandler(() => {
+ *   if (hasUnsavedChanges.value) {
+ *     showDiscardDialog()
+ *     return true // prevent default back
+ *   }
+ *   return false // allow default back
+ * })
+ * ```
+ */
+declare function useBackHandler(handler: () => boolean): void;
+
+/**
+ * NativeBridge -- the communication layer between JavaScript and Swift/UIKit.
+ *
+ * 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)`.
+ *
+ * Operation format:
+ *   { op: "<name>", args: [arg0, arg1, ...] }
+ *
+ * This matches the Swift NativeBridge.processOperations() parser which
+ * extracts `operation["op"]` and `operation["args"]`.
+ *
+ * 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.
+ */
+type EventCallback = (payload: any) => void;
+declare class NativeBridgeImpl {
+    /** Pending operations waiting to be flushed to native */
+    private pendingOps;
+    /** Whether a microtask flush has been scheduled */
+    private flushScheduled;
+    /** Event handler registry: "nodeId:eventName" -> callback */
+    private eventHandlers;
+    /** Pending async callbacks from native module invocations */
+    private pendingCallbacks;
+    /** Auto-incrementing callback ID for async native module calls */
+    private nextCallbackId;
+    /** Global event listeners: eventName -> Set of callbacks */
+    private globalEventHandlers;
+    /**
+     * Enqueue an operation to be sent to the native side.
+     * If this is the first operation in the current microtask cycle,
+     * schedule a flush via queueMicrotask.
+     */
+    private enqueue;
+    /**
+     * Flush all pending operations to the native side by calling
+     * __VN_flushOperations with the JSON-serialized operation array.
+     */
+    private flush;
+    /**
+     * Force an immediate synchronous flush. Used for testing and for
+     * critical operations that must be committed before the next microtask.
+     */
+    flushSync(): void;
+    /**
+     * Return the number of pending operations. Useful for testing.
+     */
+    getPendingCount(): number;
+    /**
+     * Tell native to create a new view node.
+     * Swift handler: handleCreate(args: [nodeId, type])
+     */
+    createNode(nodeId: number, type: string): void;
+    /**
+     * Tell native to create a text node.
+     * Swift handler: handleCreateText(args: [nodeId, text])
+     */
+    createTextNode(nodeId: number, text: string): void;
+    /**
+     * Update the text content of a text node.
+     * Swift handler: handleSetText(args: [nodeId, text])
+     */
+    setText(nodeId: number, text: string): void;
+    /**
+     * Set the text content of an element node (replaces all children with text).
+     * Swift handler: handleSetElementText(args: [nodeId, text])
+     */
+    setElementText(nodeId: number, text: string): void;
+    /**
+     * Update a single property on a native view.
+     * Swift handler: handleUpdateProp(args: [nodeId, key, value])
+     */
+    updateProp(nodeId: number, key: string, value: any): void;
+    /**
+     * Update a single style property on a native view.
+     * Swift handler: handleUpdateStyle(args: [nodeId, { key: value }])
+     *
+     * 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;
+    /**
+     * Append a child node to a parent node.
+     * Swift handler: handleAppendChild(args: [parentId, childId])
+     */
+    appendChild(parentId: number, childId: number): void;
+    /**
+     * Insert a child node before a reference node within a parent.
+     * Swift handler: handleInsertBefore(args: [parentId, childId, beforeId])
+     */
+    insertBefore(parentId: number, childId: number, anchorId: number): void;
+    /**
+     * Remove a child node from its parent.
+     * Swift handler: handleRemoveChild(args: [childId])
+     * Note: Swift only needs the childId since it calls removeFromSuperview().
+     */
+    removeChild(_parentId: number, childId: number): void;
+    /**
+     * Register an event listener for a node.
+     * 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;
+    /**
+     * Remove a previously registered event listener.
+     * Swift handler: handleRemoveEventListener(args: [nodeId, eventName])
+     */
+    removeEventListener(nodeId: number, eventName: string): void;
+    /**
+     * 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;
+    /**
+     * Tell native which node ID is the root of the view tree.
+     * Swift handler: handleSetRootView(args: [nodeId])
+     */
+    setRootView(nodeId: number): void;
+    /**
+     * Invoke a native module method asynchronously. Returns a Promise that
+     * resolves when Swift/Kotlin calls __VN_resolveCallback with the matching callbackId.
+     *
+     * A 30-second timeout is applied. If the native side never responds (e.g. due to
+     * 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>;
+    /**
+     * 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;
+    /**
+     * Called from Swift via globalThis.__VN_resolveCallback when an async
+     * native module invocation completes.
+     */
+    resolveCallback(callbackId: number, result: any, error: any): void;
+    /**
+     * Register a handler for a push-based global event from native.
+     * Returns an unsubscribe function.
+     */
+    onGlobalEvent(eventName: string, handler: (payload: any) => void): () => void;
+    /**
+     * Called from Swift via globalThis.__VN_handleGlobalEvent when a push event fires.
+     */
+    handleGlobalEvent(eventName: string, payloadJSON: string): void;
+    /**
+     * Reset all internal state. Used for testing.
+     */
+    reset(): void;
+}
+/**
+ * Singleton bridge instance used by the renderer and application code.
+ */
+declare const NativeBridge: NativeBridgeImpl;
+
+/**
+ * @thelacanians/vue-native-runtime — Vue 3 custom renderer for native iOS views.
+ *
+ * This is the main entry point for the Vue Native runtime. It provides:
+ * - A createApp() function that sets up the native renderer
+ * - All Vue 3 Composition API exports (ref, reactive, computed, watch, etc.)
+ * - Built-in native components (VView, VText, VButton, VInput)
+ * - createStyleSheet() for defining native styles
+ * - NativeBridge for advanced native interop
+ */
+
+/**
+ * Extended App interface with the .start() method for mounting to native.
+ */
+interface NativeApp extends App {
+    /**
+     * Mount the application to a virtual root node and tell the native side
+     * to begin rendering. This replaces the web-style app.mount('#app').
+     *
+     * @returns The virtual root NativeNode
+     */
+    start(): NativeNode;
+}
+/**
+ * Create a Vue Native application.
+ *
+ * This is the primary entry point for creating a Vue Native app. It wraps
+ * Vue 3's createApp with native-specific setup:
+ *
+ * 1. Creates the app using the custom native renderer
+ * 2. Registers all built-in components (VView, VText, VButton, VInput)
+ * 3. Adds a `.start()` method that creates a virtual root, tells the bridge
+ *    to register it as the root view, and mounts the Vue app to it.
+ *
+ * @example
+ * ```ts
+ * import { createApp } from '@thelacanians/vue-native-runtime'
+ * import App from './App.vue'
+ *
+ * const app = createApp(App)
+ * app.start()
+ * ```
+ */
+declare function createApp(rootComponent: Component, rootProps?: Record<string, any>): NativeApp;
+
+export { type ActionSheetAction, type AlertButton, type AppStateStatus, type BiometryResult, type BiometryType, type CameraOptions, type CameraResult, type ColorScheme, type ConnectionType, type GeoCoordinates, type HttpRequestConfig, type HttpResponse, type LocalNotification, type NativeApp, NativeBridge, type NativeNode, type NetworkState, type NotificationPayload, type Permission, type PermissionStatus, type ShareContent, type ShareResult, type SpringOptions, type StatusBarStyle, type StyleProp, type StyleSheet, type TimingOptions, VActionSheet, VActivityIndicator, VAlertDialog, VButton, VImage, VInput, VKeyboardAvoiding, VList, VModal, VPicker, VProgressBar, VSafeArea, VScrollView, VSegmentedControl, VSlider, VStatusBar, VSwitch, VText, VView, VWebView, type WebViewSource, createApp, createCommentNode, createNativeNode, createStyleSheet, createTextNode, render, resetNodeId, useAnimation, useAppState, useAsyncStorage, useBackHandler, useBiometry, useCamera, useClipboard, useColorScheme, useDeviceInfo, useGeolocation, useHaptics, useHttp, useKeyboard, useLinking, useNetwork, useNotifications, usePermissions, useShare, vShow, validStyleProperties };