@thelacanians/vue-native-runtime 0.1.2 → 0.2.0

package/dist/index.cjs

@@ -21,57 +21,89 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  ErrorBoundary: () => ErrorBoundary,
   NativeBridge: () => NativeBridge,
   VActionSheet: () => VActionSheet,
   VActivityIndicator: () => VActivityIndicator,
   VAlertDialog: () => VAlertDialog,
   VButton: () => VButton,
+  VCheckbox: () => VCheckbox,
+  VDropdown: () => VDropdown,
   VImage: () => VImage,
   VInput: () => VInput,
   VKeyboardAvoiding: () => VKeyboardAvoiding,
   VList: () => VList,
   VModal: () => VModal,
   VPicker: () => VPicker,
+  VPressable: () => VPressable,
   VProgressBar: () => VProgressBar,
+  VRadio: () => VRadio,
+  VRefreshControl: () => VRefreshControl,
   VSafeArea: () => VSafeArea,
   VScrollView: () => VScrollView,
+  VSectionList: () => VSectionList,
   VSegmentedControl: () => VSegmentedControl,
   VSlider: () => VSlider,
   VStatusBar: () => VStatusBar,
   VSwitch: () => VSwitch,
   VText: () => VText,
+  VVideo: () => VVideo,
   VView: () => VView,
   VWebView: () => VWebView,
+  clearSharedElementRegistry: () => clearSharedElementRegistry,
   createApp: () => createApp,
   createCommentNode: () => createCommentNode,
   createNativeNode: () => createNativeNode,
   createStyleSheet: () => createStyleSheet,
   createTextNode: () => createTextNode,
+  getRegisteredSharedElements: () => getRegisteredSharedElements,
+  getSharedElementViewId: () => getSharedElementViewId,
+  measureViewFrame: () => measureViewFrame,
   render: () => render,
   resetNodeId: () => resetNodeId,
+  useAccelerometer: () => useAccelerometer,
   useAnimation: () => useAnimation,
   useAppState: () => useAppState,
+  useAppleSignIn: () => useAppleSignIn,
   useAsyncStorage: () => useAsyncStorage,
+  useAudio: () => useAudio,
   useBackHandler: () => useBackHandler,
+  useBackgroundTask: () => useBackgroundTask,
   useBiometry: () => useBiometry,
+  useBluetooth: () => useBluetooth,
+  useCalendar: () => useCalendar,
   useCamera: () => useCamera,
   useClipboard: () => useClipboard,
   useColorScheme: () => useColorScheme,
+  useContacts: () => useContacts,
+  useDatabase: () => useDatabase,
   useDeviceInfo: () => useDeviceInfo,
+  useDimensions: () => useDimensions,
+  useFileSystem: () => useFileSystem,
   useGeolocation: () => useGeolocation,
+  useGoogleSignIn: () => useGoogleSignIn,
+  useGyroscope: () => useGyroscope,
   useHaptics: () => useHaptics,
   useHttp: () => useHttp,
+  useI18n: () => useI18n,
+  useIAP: () => useIAP,
   useKeyboard: () => useKeyboard,
   useLinking: () => useLinking,
   useNetwork: () => useNetwork,
   useNotifications: () => useNotifications,
+  useOTAUpdate: () => useOTAUpdate,
+  usePerformance: () => usePerformance,
   usePermissions: () => usePermissions,
+  usePlatform: () => usePlatform,
+  useSecureStorage: () => useSecureStorage,
   useShare: () => useShare,
+  useSharedElementTransition: () => useSharedElementTransition,
+  useWebSocket: () => useWebSocket,
   vShow: () => vShow,
   validStyleProperties: () => validStyleProperties
 });
 module.exports = __toCommonJS(index_exports);
-var import_runtime_core32 = require("@vue/runtime-core");
+var import_runtime_core57 = require("@vue/runtime-core");
 
 // src/renderer.ts
 var import_runtime_core = require("@vue/runtime-core");
@@ -115,7 +147,7 @@ function createTextNode(text) {
   };
   return (0, import_reactivity.markRaw)(node);
 }
-function createCommentNode(text) {
+function createCommentNode(_text) {
   const node = {
     id: getNextNodeId(),
     type: "__COMMENT__",
@@ -404,9 +436,9 @@ var NativeBridgeImpl = class {
     }
     const handlers = this.globalEventHandlers.get(eventName);
     if (handlers) {
-      handlers.forEach((h21) => {
+      handlers.forEach((h28) => {
         try {
-          h21(payload);
+          h28(payload);
         } catch (err) {
           console.error(`[VueNative] Error in global event handler "${eventName}":`, err);
         }
@@ -617,7 +649,10 @@ var VView = (0, import_runtime_core2.defineComponent)({
   props: {
     style: Object,
     testID: String,
-    accessibilityLabel: String
+    accessibilityLabel: String,
+    accessibilityRole: String,
+    accessibilityHint: String,
+    accessibilityState: Object
   },
   setup(props, { slots }) {
     return () => (0, import_runtime_core2.h)("VView", { ...props }, slots.default?.());
@@ -635,7 +670,10 @@ var VText = (0, import_runtime_core3.defineComponent)({
       type: Boolean,
       default: false
     },
-    accessibilityRole: String
+    accessibilityLabel: String,
+    accessibilityRole: String,
+    accessibilityHint: String,
+    accessibilityState: Object
   },
   setup(props, { slots }) {
     return () => (0, import_runtime_core3.h)("VText", { ...props }, slots.default?.());
@@ -657,7 +695,11 @@ var VButton = (0, import_runtime_core4.defineComponent)({
       default: 0.7
     },
     onPress: Function,
-    onLongPress: Function
+    onLongPress: Function,
+    accessibilityLabel: String,
+    accessibilityRole: String,
+    accessibilityHint: String,
+    accessibilityState: Object
   },
   setup(props, { slots }) {
     return () => (0, import_runtime_core4.h)(
@@ -707,7 +749,11 @@ var VInput = (0, import_runtime_core5.defineComponent)({
       type: Boolean,
       default: false
     },
-    style: Object
+    style: Object,
+    accessibilityLabel: String,
+    accessibilityRole: String,
+    accessibilityHint: String,
+    accessibilityState: Object
   },
   emits: ["update:modelValue", "focus", "blur", "submit"],
   setup(props, { emit }) {
@@ -735,6 +781,10 @@ var VInput = (0, import_runtime_core5.defineComponent)({
       maxLength: props.maxLength,
       multiline: props.multiline,
       style: props.style,
+      accessibilityLabel: props.accessibilityLabel,
+      accessibilityRole: props.accessibilityRole,
+      accessibilityHint: props.accessibilityHint,
+      accessibilityState: props.accessibilityState,
       onChangetext,
       onFocus,
       onBlur,
@@ -758,7 +808,11 @@ var VSwitch = (0, import_runtime_core6.defineComponent)({
     },
     onTintColor: String,
     thumbTintColor: String,
-    style: Object
+    style: Object,
+    accessibilityLabel: String,
+    accessibilityRole: String,
+    accessibilityHint: String,
+    accessibilityState: Object
   },
   emits: ["update:modelValue", "change"],
   setup(props, { emit }) {
@@ -773,6 +827,10 @@ var VSwitch = (0, import_runtime_core6.defineComponent)({
       onTintColor: props.onTintColor,
       thumbTintColor: props.thumbTintColor,
       style: props.style,
+      accessibilityLabel: props.accessibilityLabel,
+      accessibilityRole: props.accessibilityRole,
+      accessibilityHint: props.accessibilityHint,
+      accessibilityState: props.accessibilityState,
       onChange
     });
   }
@@ -845,7 +903,11 @@ var VScrollView = (0, import_runtime_core8.defineComponent)({
       type: Boolean,
       default: false
     },
-    style: Object
+    style: Object,
+    accessibilityLabel: String,
+    accessibilityRole: String,
+    accessibilityHint: String,
+    accessibilityState: Object
   },
   emits: ["scroll", "refresh"],
   setup(props, { slots, emit }) {
@@ -867,6 +929,10 @@ var VScrollView = (0, import_runtime_core8.defineComponent)({
         contentContainerStyle: props.contentContainerStyle,
         refreshing: props.refreshing,
         style: props.style,
+        accessibilityLabel: props.accessibilityLabel,
+        accessibilityRole: props.accessibilityRole,
+        accessibilityHint: props.accessibilityHint,
+        accessibilityState: props.accessibilityState,
         onScroll,
         onRefresh
       },
@@ -887,7 +953,10 @@ var VImage = (0, import_runtime_core9.defineComponent)({
     },
     style: Object,
     testID: String,
-    accessibilityLabel: String
+    accessibilityLabel: String,
+    accessibilityRole: String,
+    accessibilityHint: String,
+    accessibilityState: Object
   },
   emits: ["load", "error"],
   setup(props, { emit }) {
@@ -935,7 +1004,11 @@ var VSlider = (0, import_runtime_core12.defineComponent)({
     modelValue: { type: Number, default: 0 },
     min: { type: Number, default: 0 },
     max: { type: Number, default: 1 },
-    style: { type: Object, default: () => ({}) }
+    style: { type: Object, default: () => ({}) },
+    accessibilityLabel: String,
+    accessibilityRole: String,
+    accessibilityHint: String,
+    accessibilityState: Object
   },
   emits: ["update:modelValue", "change"],
   setup(props, { emit }) {
@@ -944,6 +1017,10 @@ var VSlider = (0, import_runtime_core12.defineComponent)({
       value: props.modelValue,
       minimumValue: props.min,
       maximumValue: props.max,
+      accessibilityLabel: props.accessibilityLabel,
+      accessibilityRole: props.accessibilityRole,
+      accessibilityHint: props.accessibilityHint,
+      accessibilityState: props.accessibilityState,
       onChange: (val) => {
         emit("update:modelValue", val);
         emit("change", val);
@@ -1230,6 +1307,352 @@ var VActionSheet = (0, import_runtime_core21.defineComponent)({
   }
 });
 
+// src/components/VRefreshControl.ts
+var import_runtime_core22 = require("@vue/runtime-core");
+var VRefreshControl = (0, import_runtime_core22.defineComponent)({
+  name: "VRefreshControl",
+  props: {
+    refreshing: {
+      type: Boolean,
+      default: false
+    },
+    onRefresh: Function,
+    tintColor: String,
+    title: String,
+    style: Object
+  },
+  setup(props) {
+    return () => (0, import_runtime_core22.h)("VRefreshControl", {
+      refreshing: props.refreshing,
+      onRefresh: props.onRefresh,
+      tintColor: props.tintColor,
+      title: props.title
+    });
+  }
+});
+
+// src/components/VPressable.ts
+var import_runtime_core23 = require("@vue/runtime-core");
+var VPressable = (0, import_runtime_core23.defineComponent)({
+  name: "VPressable",
+  props: {
+    style: Object,
+    disabled: {
+      type: Boolean,
+      default: false
+    },
+    activeOpacity: {
+      type: Number,
+      default: 0.7
+    },
+    onPress: Function,
+    onPressIn: Function,
+    onPressOut: Function,
+    onLongPress: Function,
+    accessibilityLabel: String,
+    accessibilityRole: String,
+    accessibilityHint: String,
+    accessibilityState: Object
+  },
+  setup(props, { slots }) {
+    return () => (0, import_runtime_core23.h)(
+      "VPressable",
+      {
+        ...props,
+        onPress: props.disabled ? void 0 : props.onPress,
+        onPressIn: props.disabled ? void 0 : props.onPressIn,
+        onPressOut: props.disabled ? void 0 : props.onPressOut,
+        onLongPress: props.disabled ? void 0 : props.onLongPress
+      },
+      slots.default?.()
+    );
+  }
+});
+
+// src/components/VSectionList.ts
+var import_runtime_core24 = require("@vue/runtime-core");
+var VSectionList = (0, import_runtime_core24.defineComponent)({
+  name: "VSectionList",
+  props: {
+    /** Array of section objects, each with a title and data array */
+    sections: {
+      type: Array,
+      required: true
+    },
+    /** Extract a unique key from each item. Defaults to index as string. */
+    keyExtractor: {
+      type: Function,
+      default: (_item, index) => String(index)
+    },
+    /** Estimated height per row in points. Default: 44 */
+    estimatedItemHeight: {
+      type: Number,
+      default: 44
+    },
+    /** Whether section headers stick to the top when scrolling. Default: true */
+    stickySectionHeaders: {
+      type: Boolean,
+      default: true
+    },
+    /** Show vertical scroll indicator. Default: true */
+    showsScrollIndicator: {
+      type: Boolean,
+      default: true
+    },
+    /** Enable bounce at scroll boundaries. Default: true */
+    bounces: {
+      type: Boolean,
+      default: true
+    },
+    style: {
+      type: Object,
+      default: () => ({})
+    }
+  },
+  emits: ["scroll", "endReached"],
+  setup(props, { slots, emit }) {
+    return () => {
+      const sections = props.sections ?? [];
+      const children = [];
+      if (slots.header) {
+        children.push(
+          (0, import_runtime_core24.h)("VView", { key: "__header__", style: { flexShrink: 0 } }, slots.header())
+        );
+      }
+      const totalItems = sections.reduce((sum, s) => sum + (s.data?.length ?? 0), 0);
+      if (totalItems === 0 && slots.empty) {
+        children.push(
+          (0, import_runtime_core24.h)("VView", { key: "__empty__", style: { flexShrink: 0 } }, slots.empty())
+        );
+      }
+      for (let sectionIndex = 0; sectionIndex < sections.length; sectionIndex++) {
+        const section = sections[sectionIndex];
+        if (slots.sectionHeader) {
+          children.push(
+            (0, import_runtime_core24.h)(
+              "VView",
+              {
+                key: `__section_header_${sectionIndex}__`,
+                __sectionHeader: true,
+                style: { flexShrink: 0 }
+              },
+              slots.sectionHeader({ section, index: sectionIndex })
+            )
+          );
+        }
+        const items = section.data ?? [];
+        for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+          const item = items[itemIndex];
+          children.push(
+            (0, import_runtime_core24.h)(
+              "VView",
+              {
+                key: `${sectionIndex}_${props.keyExtractor(item, itemIndex)}`,
+                style: { flexShrink: 0 }
+              },
+              slots.item?.({ item, index: itemIndex, section }) ?? []
+            )
+          );
+        }
+        if (slots.sectionFooter) {
+          children.push(
+            (0, import_runtime_core24.h)(
+              "VView",
+              {
+                key: `__section_footer_${sectionIndex}__`,
+                style: { flexShrink: 0 }
+              },
+              slots.sectionFooter({ section, index: sectionIndex })
+            )
+          );
+        }
+      }
+      if (slots.footer) {
+        children.push(
+          (0, import_runtime_core24.h)("VView", { key: "__footer__", style: { flexShrink: 0 } }, slots.footer())
+        );
+      }
+      return (0, import_runtime_core24.h)(
+        "VSectionList",
+        {
+          style: props.style,
+          estimatedItemHeight: props.estimatedItemHeight,
+          stickySectionHeaders: props.stickySectionHeaders,
+          showsScrollIndicator: props.showsScrollIndicator,
+          bounces: props.bounces,
+          onScroll: (e) => emit("scroll", e),
+          onEndReached: () => emit("endReached")
+        },
+        children
+      );
+    };
+  }
+});
+
+// src/components/VCheckbox.ts
+var import_runtime_core25 = require("@vue/runtime-core");
+var VCheckbox = (0, import_runtime_core25.defineComponent)({
+  name: "VCheckbox",
+  props: {
+    modelValue: {
+      type: Boolean,
+      default: false
+    },
+    disabled: {
+      type: Boolean,
+      default: false
+    },
+    label: {
+      type: String,
+      default: void 0
+    },
+    checkColor: String,
+    tintColor: String,
+    style: Object,
+    accessibilityLabel: String,
+    accessibilityHint: String
+  },
+  emits: ["update:modelValue", "change"],
+  setup(props, { emit }) {
+    const onChange = (payload) => {
+      const value = typeof payload === "boolean" ? payload : !!(payload?.value ?? payload);
+      emit("update:modelValue", value);
+      emit("change", value);
+    };
+    return () => (0, import_runtime_core25.h)("VCheckbox", {
+      value: props.modelValue,
+      disabled: props.disabled,
+      label: props.label,
+      checkColor: props.checkColor,
+      tintColor: props.tintColor,
+      style: props.style,
+      accessibilityLabel: props.accessibilityLabel,
+      accessibilityHint: props.accessibilityHint,
+      onChange
+    });
+  }
+});
+
+// src/components/VRadio.ts
+var import_runtime_core26 = require("@vue/runtime-core");
+var VRadio = (0, import_runtime_core26.defineComponent)({
+  name: "VRadio",
+  props: {
+    modelValue: {
+      type: String,
+      default: void 0
+    },
+    options: {
+      type: Array,
+      required: true
+    },
+    disabled: {
+      type: Boolean,
+      default: false
+    },
+    tintColor: String,
+    style: Object,
+    accessibilityLabel: String
+  },
+  emits: ["update:modelValue", "change"],
+  setup(props, { emit }) {
+    const onChange = (payload) => {
+      const value = payload?.value ?? payload;
+      emit("update:modelValue", value);
+      emit("change", value);
+    };
+    return () => (0, import_runtime_core26.h)("VRadio", {
+      selectedValue: props.modelValue,
+      options: props.options,
+      disabled: props.disabled,
+      tintColor: props.tintColor,
+      style: props.style,
+      accessibilityLabel: props.accessibilityLabel,
+      onChange
+    });
+  }
+});
+
+// src/components/VDropdown.ts
+var import_runtime_core27 = require("@vue/runtime-core");
+var VDropdown = (0, import_runtime_core27.defineComponent)({
+  name: "VDropdown",
+  props: {
+    modelValue: {
+      type: String,
+      default: void 0
+    },
+    options: {
+      type: Array,
+      required: true
+    },
+    placeholder: {
+      type: String,
+      default: "Select..."
+    },
+    disabled: {
+      type: Boolean,
+      default: false
+    },
+    tintColor: String,
+    style: Object,
+    accessibilityLabel: String
+  },
+  emits: ["update:modelValue", "change"],
+  setup(props, { emit }) {
+    const onChange = (payload) => {
+      const value = payload?.value ?? payload;
+      emit("update:modelValue", value);
+      emit("change", value);
+    };
+    return () => (0, import_runtime_core27.h)("VDropdown", {
+      selectedValue: props.modelValue,
+      options: props.options,
+      placeholder: props.placeholder,
+      disabled: props.disabled,
+      tintColor: props.tintColor,
+      style: props.style,
+      accessibilityLabel: props.accessibilityLabel,
+      onChange
+    });
+  }
+});
+
+// src/components/VVideo.ts
+var import_runtime_core28 = require("@vue/runtime-core");
+var VVideo = (0, import_runtime_core28.defineComponent)({
+  name: "VVideo",
+  props: {
+    source: Object,
+    autoplay: { type: Boolean, default: false },
+    loop: { type: Boolean, default: false },
+    muted: { type: Boolean, default: false },
+    paused: { type: Boolean, default: false },
+    controls: { type: Boolean, default: true },
+    volume: { type: Number, default: 1 },
+    resizeMode: {
+      type: String,
+      default: "cover"
+    },
+    poster: String,
+    style: Object,
+    testID: String,
+    accessibilityLabel: String
+  },
+  emits: ["ready", "play", "pause", "end", "error", "progress"],
+  setup(props, { emit }) {
+    return () => (0, import_runtime_core28.h)("VVideo", {
+      ...props,
+      onReady: (e) => emit("ready", e),
+      onPlay: () => emit("play"),
+      onPause: () => emit("pause"),
+      onEnd: () => emit("end"),
+      onError: (e) => emit("error", e),
+      onProgress: (e) => emit("progress", e)
+    });
+  }
+});
+
 // src/directives/vShow.ts
 var vShow = {
   beforeMount(el, { value }) {
@@ -1241,6 +1664,51 @@ var vShow = {
   }
 };
 
+// src/errorBoundary.ts
+var import_runtime_core29 = require("@vue/runtime-core");
+var ErrorBoundary = (0, import_runtime_core29.defineComponent)({
+  name: "ErrorBoundary",
+  props: {
+    onError: Function,
+    resetKeys: {
+      type: Array,
+      default: () => []
+    }
+  },
+  setup(props, { slots }) {
+    const error = (0, import_runtime_core29.ref)(null);
+    const errorInfo = (0, import_runtime_core29.ref)("");
+    (0, import_runtime_core29.onErrorCaptured)((err, _instance, info) => {
+      const normalizedError = err instanceof Error ? err : new Error(String(err));
+      error.value = normalizedError;
+      errorInfo.value = info;
+      if (props.onError) {
+        props.onError(normalizedError, info);
+      }
+      return false;
+    });
+    function reset() {
+      error.value = null;
+      errorInfo.value = "";
+    }
+    (0, import_runtime_core29.watch)(
+      () => props.resetKeys,
+      () => {
+        if (error.value) {
+          reset();
+        }
+      },
+      { deep: true }
+    );
+    return () => {
+      if (error.value && slots.fallback) {
+        return slots.fallback({ error: error.value, errorInfo: errorInfo.value, reset });
+      }
+      return slots.default?.();
+    };
+  }
+});
+
 // src/index.ts
 __reExport(index_exports, require("@vue/runtime-core"), module.exports);
 
@@ -1285,6 +1753,7 @@ var validStyleProperties = /* @__PURE__ */ new Set([
   "gap",
   "rowGap",
   "columnGap",
+  "direction",
   "display",
   "overflow",
   "zIndex",
@@ -1332,7 +1801,15 @@ var validStyleProperties = /* @__PURE__ */ new Set([
   "resizeMode",
   "tintColor",
   // Transform
-  "transform"
+  "transform",
+  // Accessibility
+  "accessibilityLabel",
+  "accessibilityRole",
+  "accessibilityHint",
+  "accessibilityState",
+  "accessibilityValue",
+  "accessible",
+  "importantForAccessibility"
 ]);
 function createStyleSheet(styles) {
   const isDev = typeof __DEV__ !== "undefined" ? __DEV__ : true;
@@ -1390,9 +1867,9 @@ function useAsyncStorage() {
 }
 
 // src/composables/useClipboard.ts
-var import_runtime_core22 = require("@vue/runtime-core");
+var import_runtime_core30 = require("@vue/runtime-core");
 function useClipboard() {
-  const content = (0, import_runtime_core22.ref)("");
+  const content = (0, import_runtime_core30.ref)("");
   function copy(text) {
     return NativeBridge.invokeNativeModule("Clipboard", "copy", [text]).then(() => void 0);
   }
@@ -1406,16 +1883,16 @@ function useClipboard() {
 }
 
 // src/composables/useDeviceInfo.ts
-var import_runtime_core23 = require("@vue/runtime-core");
+var import_runtime_core31 = require("@vue/runtime-core");
 function useDeviceInfo() {
-  const model = (0, import_runtime_core23.ref)("");
-  const systemVersion = (0, import_runtime_core23.ref)("");
-  const systemName = (0, import_runtime_core23.ref)("");
-  const name = (0, import_runtime_core23.ref)("");
-  const screenWidth = (0, import_runtime_core23.ref)(0);
-  const screenHeight = (0, import_runtime_core23.ref)(0);
-  const scale = (0, import_runtime_core23.ref)(1);
-  const isLoaded = (0, import_runtime_core23.ref)(false);
+  const model = (0, import_runtime_core31.ref)("");
+  const systemVersion = (0, import_runtime_core31.ref)("");
+  const systemName = (0, import_runtime_core31.ref)("");
+  const name = (0, import_runtime_core31.ref)("");
+  const screenWidth = (0, import_runtime_core31.ref)(0);
+  const screenHeight = (0, import_runtime_core31.ref)(0);
+  const scale = (0, import_runtime_core31.ref)(1);
+  const isLoaded = (0, import_runtime_core31.ref)(false);
   async function fetchInfo() {
     const info = await NativeBridge.invokeNativeModule("DeviceInfo", "getInfo", []);
     model.value = info.model ?? "";
@@ -1427,7 +1904,7 @@ function useDeviceInfo() {
     scale.value = info.scale ?? 1;
     isLoaded.value = true;
   }
-  (0, import_runtime_core23.onMounted)(() => {
+  (0, import_runtime_core31.onMounted)(() => {
     fetchInfo();
   });
   return {
@@ -1444,10 +1921,10 @@ function useDeviceInfo() {
 }
 
 // src/composables/useKeyboard.ts
-var import_runtime_core24 = require("@vue/runtime-core");
+var import_runtime_core32 = require("@vue/runtime-core");
 function useKeyboard() {
-  const isVisible = (0, import_runtime_core24.ref)(false);
-  const height = (0, import_runtime_core24.ref)(0);
+  const isVisible = (0, import_runtime_core32.ref)(false);
+  const height = (0, import_runtime_core32.ref)(0);
   function dismiss() {
     return NativeBridge.invokeNativeModule("Keyboard", "dismiss", []).then(() => void 0);
   }
@@ -1511,10 +1988,10 @@ function useAnimation() {
 }
 
 // src/composables/useNetwork.ts
-var import_runtime_core25 = require("@vue/runtime-core");
+var import_runtime_core33 = require("@vue/runtime-core");
 function useNetwork() {
-  const isConnected = (0, import_runtime_core25.ref)(true);
-  const connectionType = (0, import_runtime_core25.ref)("unknown");
+  const isConnected = (0, import_runtime_core33.ref)(true);
+  const connectionType = (0, import_runtime_core33.ref)("unknown");
   NativeBridge.invokeNativeModule("Network", "getStatus").then((status) => {
     isConnected.value = status.isConnected;
     connectionType.value = status.connectionType;
@@ -1524,14 +2001,14 @@ function useNetwork() {
     isConnected.value = payload.isConnected;
     connectionType.value = payload.connectionType;
   });
-  (0, import_runtime_core25.onUnmounted)(unsubscribe);
+  (0, import_runtime_core33.onUnmounted)(unsubscribe);
   return { isConnected, connectionType };
 }
 
 // src/composables/useAppState.ts
-var import_runtime_core26 = require("@vue/runtime-core");
+var import_runtime_core34 = require("@vue/runtime-core");
 function useAppState() {
-  const state = (0, import_runtime_core26.ref)("active");
+  const state = (0, import_runtime_core34.ref)("active");
   NativeBridge.invokeNativeModule("AppState", "getState").then((s) => {
     state.value = s;
   }).catch(() => {
@@ -1539,7 +2016,7 @@ function useAppState() {
   const unsubscribe = NativeBridge.onGlobalEvent("appState:change", (payload) => {
     state.value = payload.state;
   });
-  (0, import_runtime_core26.onUnmounted)(unsubscribe);
+  (0, import_runtime_core34.onUnmounted)(unsubscribe);
   return { state };
 }
 
@@ -1574,10 +2051,10 @@ function usePermissions() {
 }
 
 // src/composables/useGeolocation.ts
-var import_runtime_core27 = require("@vue/runtime-core");
+var import_runtime_core35 = require("@vue/runtime-core");
 function useGeolocation() {
-  const coords = (0, import_runtime_core27.ref)(null);
-  const error = (0, import_runtime_core27.ref)(null);
+  const coords = (0, import_runtime_core35.ref)(null);
+  const error = (0, import_runtime_core35.ref)(null);
   let watchId = null;
   async function getCurrentPosition() {
     const result = await NativeBridge.invokeNativeModule("Geolocation", "getCurrentPosition");
@@ -1590,7 +2067,7 @@ function useGeolocation() {
     const unsubscribe = NativeBridge.onGlobalEvent("location:update", (payload) => {
       coords.value = payload;
     });
-    (0, import_runtime_core27.onUnmounted)(() => {
+    (0, import_runtime_core35.onUnmounted)(() => {
       unsubscribe();
       if (watchId !== null) clearWatch(watchId);
     });
@@ -1604,20 +2081,43 @@ function useGeolocation() {
 }
 
 // src/composables/useCamera.ts
+var import_runtime_core36 = require("@vue/runtime-core");
 function useCamera() {
+  const qrCleanups = [];
   async function launchCamera(options = {}) {
     return NativeBridge.invokeNativeModule("Camera", "launchCamera", [options]);
   }
   async function launchImageLibrary(options = {}) {
     return NativeBridge.invokeNativeModule("Camera", "launchImageLibrary", [options]);
   }
-  return { launchCamera, launchImageLibrary };
-}
-
-// src/composables/useNotifications.ts
-var import_runtime_core28 = require("@vue/runtime-core");
+  async function captureVideo(options = {}) {
+    return NativeBridge.invokeNativeModule("Camera", "captureVideo", [options]);
+  }
+  async function scanQRCode() {
+    return NativeBridge.invokeNativeModule("Camera", "scanQRCode");
+  }
+  async function stopQRScan() {
+    return NativeBridge.invokeNativeModule("Camera", "stopQRScan");
+  }
+  function onQRCodeDetected(callback) {
+    const unsubscribe = NativeBridge.onGlobalEvent("camera:qrDetected", callback);
+    qrCleanups.push(unsubscribe);
+    return unsubscribe;
+  }
+  (0, import_runtime_core36.onUnmounted)(() => {
+    NativeBridge.invokeNativeModule("Camera", "stopQRScan").catch(() => {
+    });
+    qrCleanups.forEach((fn) => fn());
+    qrCleanups.length = 0;
+  });
+  return { launchCamera, launchImageLibrary, captureVideo, scanQRCode, stopQRScan, onQRCodeDetected };
+}
+
+// src/composables/useNotifications.ts
+var import_runtime_core37 = require("@vue/runtime-core");
 function useNotifications() {
-  const isGranted = (0, import_runtime_core28.ref)(false);
+  const isGranted = (0, import_runtime_core37.ref)(false);
+  const pushToken = (0, import_runtime_core37.ref)(null);
   async function requestPermission() {
     const granted = await NativeBridge.invokeNativeModule("Notifications", "requestPermission");
     isGranted.value = granted;
@@ -1637,10 +2137,44 @@ function useNotifications() {
   }
   function onNotification(handler) {
     const unsubscribe = NativeBridge.onGlobalEvent("notification:received", handler);
-    (0, import_runtime_core28.onUnmounted)(unsubscribe);
+    (0, import_runtime_core37.onUnmounted)(unsubscribe);
+    return unsubscribe;
+  }
+  async function registerForPush() {
+    await NativeBridge.invokeNativeModule("Notifications", "registerForPush");
+  }
+  async function getToken() {
+    return NativeBridge.invokeNativeModule("Notifications", "getToken");
+  }
+  function onPushToken(handler) {
+    const unsubscribe = NativeBridge.onGlobalEvent("push:token", (payload) => {
+      pushToken.value = payload.token;
+      handler(payload.token);
+    });
+    (0, import_runtime_core37.onUnmounted)(unsubscribe);
+    return unsubscribe;
+  }
+  function onPushReceived(handler) {
+    const unsubscribe = NativeBridge.onGlobalEvent("push:received", handler);
+    (0, import_runtime_core37.onUnmounted)(unsubscribe);
     return unsubscribe;
   }
-  return { isGranted, requestPermission, getPermissionStatus, scheduleLocal, cancel, cancelAll, onNotification };
+  return {
+    // Local
+    isGranted,
+    requestPermission,
+    getPermissionStatus,
+    scheduleLocal,
+    cancel,
+    cancelAll,
+    onNotification,
+    // Push
+    pushToken,
+    registerForPush,
+    getToken,
+    onPushToken,
+    onPushReceived
+  };
 }
 
 // src/composables/useBiometry.ts
@@ -1658,10 +2192,18 @@ function useBiometry() {
 }
 
 // src/composables/useHttp.ts
-var import_runtime_core29 = require("@vue/runtime-core");
+var import_runtime_core38 = require("@vue/runtime-core");
 function useHttp(config = {}) {
-  const loading = (0, import_runtime_core29.ref)(false);
-  const error = (0, import_runtime_core29.ref)(null);
+  if (config.pins && Object.keys(config.pins).length > 0) {
+    const configurePins = globalThis.__VN_configurePins;
+    if (typeof configurePins === "function") {
+      configurePins(JSON.stringify(config.pins));
+    } else {
+      NativeBridge.invokeNativeModule("Http", "configurePins", [config.pins]);
+    }
+  }
+  const loading = (0, import_runtime_core38.ref)(false);
+  const error = (0, import_runtime_core38.ref)(null);
   async function request(method, url, options = {}) {
     const fullUrl = config.baseURL ? `${config.baseURL}${url}` : url;
     loading.value = true;
@@ -1707,10 +2249,10 @@ function useHttp(config = {}) {
 }
 
 // src/composables/useColorScheme.ts
-var import_runtime_core30 = require("@vue/runtime-core");
+var import_runtime_core39 = require("@vue/runtime-core");
 function useColorScheme() {
-  const colorScheme = (0, import_runtime_core30.ref)("light");
-  const isDark = (0, import_runtime_core30.ref)(false);
+  const colorScheme = (0, import_runtime_core39.ref)("light");
+  const isDark = (0, import_runtime_core39.ref)(false);
   const unsubscribe = NativeBridge.onGlobalEvent(
     "colorScheme:change",
     (payload) => {
@@ -1718,23 +2260,1067 @@ function useColorScheme() {
       isDark.value = payload.colorScheme === "dark";
     }
   );
-  (0, import_runtime_core30.onUnmounted)(unsubscribe);
+  (0, import_runtime_core39.onUnmounted)(unsubscribe);
   return { colorScheme, isDark };
 }
 
 // src/composables/useBackHandler.ts
-var import_runtime_core31 = require("@vue/runtime-core");
+var import_runtime_core40 = require("@vue/runtime-core");
 function useBackHandler(handler) {
   let unsubscribe = null;
-  (0, import_runtime_core31.onMounted)(() => {
+  (0, import_runtime_core40.onMounted)(() => {
     unsubscribe = NativeBridge.onGlobalEvent("hardware:backPress", () => {
       handler();
     });
   });
-  (0, import_runtime_core31.onUnmounted)(() => {
+  (0, import_runtime_core40.onUnmounted)(() => {
+    unsubscribe?.();
+    unsubscribe = null;
+  });
+}
+
+// src/composables/useSecureStorage.ts
+function useSecureStorage() {
+  function getItem(key) {
+    return NativeBridge.invokeNativeModule("SecureStorage", "get", [key]);
+  }
+  function setItem(key, value) {
+    return NativeBridge.invokeNativeModule("SecureStorage", "set", [key, value]).then(() => void 0);
+  }
+  function removeItem(key) {
+    return NativeBridge.invokeNativeModule("SecureStorage", "remove", [key]).then(() => void 0);
+  }
+  function clear() {
+    return NativeBridge.invokeNativeModule("SecureStorage", "clear", []).then(() => void 0);
+  }
+  return { getItem, setItem, removeItem, clear };
+}
+
+// src/composables/useI18n.ts
+var import_runtime_core41 = require("@vue/runtime-core");
+function useI18n() {
+  const isRTL = (0, import_runtime_core41.ref)(false);
+  const locale = (0, import_runtime_core41.ref)("en");
+  (0, import_runtime_core41.onMounted)(async () => {
+    try {
+      const info = await NativeBridge.invokeNativeModule("DeviceInfo", "getDeviceInfo", []);
+      locale.value = info?.locale || "en";
+      isRTL.value = ["ar", "he", "fa", "ur"].some((l) => locale.value.startsWith(l));
+    } catch {
+    }
+  });
+  return { isRTL, locale };
+}
+
+// src/composables/usePlatform.ts
+function usePlatform() {
+  const platform = typeof __PLATFORM__ !== "undefined" ? __PLATFORM__ : "ios";
+  const isIOS = platform === "ios";
+  const isAndroid = platform === "android";
+  return { platform, isIOS, isAndroid };
+}
+
+// src/composables/useDimensions.ts
+var import_runtime_core42 = require("@vue/runtime-core");
+function useDimensions() {
+  const width = (0, import_runtime_core42.ref)(0);
+  const height = (0, import_runtime_core42.ref)(0);
+  const scale = (0, import_runtime_core42.ref)(1);
+  (0, import_runtime_core42.onMounted)(async () => {
+    try {
+      const info = await NativeBridge.invokeNativeModule("DeviceInfo", "getInfo", []);
+      width.value = info?.screenWidth || 0;
+      height.value = info?.screenHeight || 0;
+      scale.value = info?.scale || 1;
+    } catch {
+    }
+  });
+  const cleanup = NativeBridge.onGlobalEvent("dimensionsChange", (payload) => {
+    if (payload.width != null) width.value = payload.width;
+    if (payload.height != null) height.value = payload.height;
+    if (payload.scale != null) scale.value = payload.scale;
+  });
+  (0, import_runtime_core42.onUnmounted)(cleanup);
+  return { width, height, scale };
+}
+
+// src/composables/useWebSocket.ts
+var import_runtime_core43 = require("@vue/runtime-core");
+var connectionCounter = 0;
+function useWebSocket(url, options = {}) {
+  const {
+    autoConnect = true,
+    autoReconnect = false,
+    maxReconnectAttempts = 3,
+    reconnectInterval = 1e3
+  } = options;
+  const connectionId = `ws_${++connectionCounter}_${Date.now()}`;
+  const status = (0, import_runtime_core43.ref)("CLOSED");
+  const lastMessage = (0, import_runtime_core43.ref)(null);
+  const error = (0, import_runtime_core43.ref)(null);
+  let reconnectAttempts = 0;
+  let reconnectTimer = null;
+  const unsubscribers = [];
+  unsubscribers.push(
+    NativeBridge.onGlobalEvent("websocket:open", (payload) => {
+      if (payload.connectionId !== connectionId) return;
+      status.value = "OPEN";
+      error.value = null;
+      reconnectAttempts = 0;
+    })
+  );
+  unsubscribers.push(
+    NativeBridge.onGlobalEvent("websocket:message", (payload) => {
+      if (payload.connectionId !== connectionId) return;
+      lastMessage.value = payload.data;
+    })
+  );
+  unsubscribers.push(
+    NativeBridge.onGlobalEvent("websocket:close", (payload) => {
+      if (payload.connectionId !== connectionId) return;
+      status.value = "CLOSED";
+      if (autoReconnect && reconnectAttempts < maxReconnectAttempts && payload.code !== 1e3) {
+        reconnectAttempts++;
+        reconnectTimer = setTimeout(() => {
+          open();
+        }, reconnectInterval);
+      }
+    })
+  );
+  unsubscribers.push(
+    NativeBridge.onGlobalEvent("websocket:error", (payload) => {
+      if (payload.connectionId !== connectionId) return;
+      error.value = payload.message;
+    })
+  );
+  function open() {
+    if (status.value === "OPEN" || status.value === "CONNECTING") return;
+    status.value = "CONNECTING";
+    error.value = null;
+    NativeBridge.invokeNativeModule("WebSocket", "connect", [url, connectionId]).catch((err) => {
+      status.value = "CLOSED";
+      error.value = err.message;
+    });
+  }
+  function send(data) {
+    if (status.value !== "OPEN") return;
+    const message = typeof data === "string" ? data : JSON.stringify(data);
+    NativeBridge.invokeNativeModule("WebSocket", "send", [connectionId, message]).catch((err) => {
+      error.value = err.message;
+    });
+  }
+  function close(code, reason) {
+    if (status.value === "CLOSED" || status.value === "CLOSING") return;
+    status.value = "CLOSING";
+    if (reconnectTimer) {
+      clearTimeout(reconnectTimer);
+      reconnectTimer = null;
+    }
+    reconnectAttempts = maxReconnectAttempts;
+    NativeBridge.invokeNativeModule("WebSocket", "close", [connectionId, code ?? 1e3, reason ?? ""]).catch(() => {
+      status.value = "CLOSED";
+    });
+  }
+  if (autoConnect) {
+    open();
+  }
+  (0, import_runtime_core43.onUnmounted)(() => {
+    if (reconnectTimer) {
+      clearTimeout(reconnectTimer);
+    }
+    if (status.value === "OPEN" || status.value === "CONNECTING") {
+      reconnectAttempts = maxReconnectAttempts;
+      NativeBridge.invokeNativeModule("WebSocket", "close", [connectionId, 1e3, ""]).catch(() => {
+      });
+    }
+    unsubscribers.forEach((unsub) => unsub());
+  });
+  return { status, lastMessage, error, send, close, open };
+}
+
+// src/composables/useFileSystem.ts
+function useFileSystem() {
+  function readFile(path, encoding) {
+    return NativeBridge.invokeNativeModule("FileSystem", "readFile", [path, encoding ?? "utf8"]);
+  }
+  function writeFile(path, content, encoding) {
+    return NativeBridge.invokeNativeModule("FileSystem", "writeFile", [path, content, encoding ?? "utf8"]).then(() => void 0);
+  }
+  function deleteFile(path) {
+    return NativeBridge.invokeNativeModule("FileSystem", "deleteFile", [path]).then(() => void 0);
+  }
+  function exists(path) {
+    return NativeBridge.invokeNativeModule("FileSystem", "exists", [path]);
+  }
+  function listDirectory(path) {
+    return NativeBridge.invokeNativeModule("FileSystem", "listDirectory", [path]);
+  }
+  function downloadFile(url, destPath) {
+    return NativeBridge.invokeNativeModule("FileSystem", "downloadFile", [url, destPath]);
+  }
+  function getDocumentsPath() {
+    return NativeBridge.invokeNativeModule("FileSystem", "getDocumentsPath", []);
+  }
+  function getCachesPath() {
+    return NativeBridge.invokeNativeModule("FileSystem", "getCachesPath", []);
+  }
+  function stat(path) {
+    return NativeBridge.invokeNativeModule("FileSystem", "stat", [path]);
+  }
+  function mkdir(path) {
+    return NativeBridge.invokeNativeModule("FileSystem", "mkdir", [path]).then(() => void 0);
+  }
+  function copyFile(srcPath, destPath) {
+    return NativeBridge.invokeNativeModule("FileSystem", "copyFile", [srcPath, destPath]).then(() => void 0);
+  }
+  function moveFile(srcPath, destPath) {
+    return NativeBridge.invokeNativeModule("FileSystem", "moveFile", [srcPath, destPath]).then(() => void 0);
+  }
+  return {
+    readFile,
+    writeFile,
+    deleteFile,
+    exists,
+    listDirectory,
+    downloadFile,
+    getDocumentsPath,
+    getCachesPath,
+    stat,
+    mkdir,
+    copyFile,
+    moveFile
+  };
+}
+
+// src/composables/useSensors.ts
+var import_runtime_core44 = require("@vue/runtime-core");
+function useAccelerometer(options = {}) {
+  const x = (0, import_runtime_core44.ref)(0);
+  const y = (0, import_runtime_core44.ref)(0);
+  const z = (0, import_runtime_core44.ref)(0);
+  const isAvailable = (0, import_runtime_core44.ref)(false);
+  let running = false;
+  let unsubscribe = null;
+  NativeBridge.invokeNativeModule("Sensors", "isAvailable", ["accelerometer"]).then((result) => {
+    isAvailable.value = result.available;
+  }).catch(() => {
+  });
+  function start() {
+    if (running) return;
+    running = true;
+    unsubscribe = NativeBridge.onGlobalEvent("sensor:accelerometer", (payload) => {
+      x.value = payload.x;
+      y.value = payload.y;
+      z.value = payload.z;
+    });
+    NativeBridge.invokeNativeModule("Sensors", "startAccelerometer", [
+      options.interval ?? 100
+    ]).catch(() => {
+    });
+  }
+  function stop() {
+    if (!running) return;
+    running = false;
+    unsubscribe?.();
+    unsubscribe = null;
+    NativeBridge.invokeNativeModule("Sensors", "stopAccelerometer").catch(() => {
+    });
+  }
+  (0, import_runtime_core44.onUnmounted)(() => {
+    stop();
+  });
+  return { x, y, z, isAvailable, start, stop };
+}
+function useGyroscope(options = {}) {
+  const x = (0, import_runtime_core44.ref)(0);
+  const y = (0, import_runtime_core44.ref)(0);
+  const z = (0, import_runtime_core44.ref)(0);
+  const isAvailable = (0, import_runtime_core44.ref)(false);
+  let running = false;
+  let unsubscribe = null;
+  NativeBridge.invokeNativeModule("Sensors", "isAvailable", ["gyroscope"]).then((result) => {
+    isAvailable.value = result.available;
+  }).catch(() => {
+  });
+  function start() {
+    if (running) return;
+    running = true;
+    unsubscribe = NativeBridge.onGlobalEvent("sensor:gyroscope", (payload) => {
+      x.value = payload.x;
+      y.value = payload.y;
+      z.value = payload.z;
+    });
+    NativeBridge.invokeNativeModule("Sensors", "startGyroscope", [
+      options.interval ?? 100
+    ]).catch(() => {
+    });
+  }
+  function stop() {
+    if (!running) return;
+    running = false;
     unsubscribe?.();
     unsubscribe = null;
+    NativeBridge.invokeNativeModule("Sensors", "stopGyroscope").catch(() => {
+    });
+  }
+  (0, import_runtime_core44.onUnmounted)(() => {
+    stop();
+  });
+  return { x, y, z, isAvailable, start, stop };
+}
+
+// src/composables/useAudio.ts
+var import_runtime_core45 = require("@vue/runtime-core");
+function useAudio() {
+  const duration = (0, import_runtime_core45.ref)(0);
+  const position = (0, import_runtime_core45.ref)(0);
+  const isPlaying = (0, import_runtime_core45.ref)(false);
+  const isRecording = (0, import_runtime_core45.ref)(false);
+  const error = (0, import_runtime_core45.ref)(null);
+  const unsubProgress = NativeBridge.onGlobalEvent("audio:progress", (payload) => {
+    position.value = payload.currentTime ?? 0;
+    duration.value = payload.duration ?? 0;
+  });
+  const unsubComplete = NativeBridge.onGlobalEvent("audio:complete", () => {
+    isPlaying.value = false;
+    position.value = 0;
+  });
+  const unsubError = NativeBridge.onGlobalEvent("audio:error", (payload) => {
+    error.value = payload.message ?? "Unknown audio error";
+    isPlaying.value = false;
+  });
+  (0, import_runtime_core45.onUnmounted)(() => {
+    unsubProgress();
+    unsubComplete();
+    unsubError();
+    NativeBridge.invokeNativeModule("Audio", "stop", []).catch(() => {
+    });
+    if (isRecording.value) {
+      NativeBridge.invokeNativeModule("Audio", "stopRecording", []).catch(() => {
+      });
+    }
+  });
+  async function play(uri, options = {}) {
+    error.value = null;
+    const result = await NativeBridge.invokeNativeModule("Audio", "play", [uri, options]);
+    if (result?.duration != null) {
+      duration.value = result.duration;
+    }
+    isPlaying.value = true;
+  }
+  async function pause() {
+    await NativeBridge.invokeNativeModule("Audio", "pause", []);
+    isPlaying.value = false;
+  }
+  async function resume() {
+    await NativeBridge.invokeNativeModule("Audio", "resume", []);
+    isPlaying.value = true;
+  }
+  async function stop() {
+    await NativeBridge.invokeNativeModule("Audio", "stop", []);
+    isPlaying.value = false;
+    position.value = 0;
+    duration.value = 0;
+  }
+  async function seek(positionSec) {
+    await NativeBridge.invokeNativeModule("Audio", "seek", [positionSec]);
+  }
+  async function setVolume(volume) {
+    await NativeBridge.invokeNativeModule("Audio", "setVolume", [volume]);
+  }
+  async function startRecording(options = {}) {
+    error.value = null;
+    const result = await NativeBridge.invokeNativeModule("Audio", "startRecording", [options]);
+    isRecording.value = true;
+    return result?.uri ?? "";
+  }
+  async function stopRecording() {
+    const result = await NativeBridge.invokeNativeModule("Audio", "stopRecording", []);
+    isRecording.value = false;
+    return { uri: result?.uri ?? "", duration: result?.duration ?? 0 };
+  }
+  async function pauseRecording() {
+    await NativeBridge.invokeNativeModule("Audio", "pauseRecording", []);
+  }
+  async function resumeRecording() {
+    await NativeBridge.invokeNativeModule("Audio", "resumeRecording", []);
+  }
+  return {
+    // Playback
+    play,
+    pause,
+    resume,
+    stop,
+    seek,
+    setVolume,
+    // Recording
+    startRecording,
+    stopRecording,
+    pauseRecording,
+    resumeRecording,
+    // Reactive state
+    duration,
+    position,
+    isPlaying,
+    isRecording,
+    error
+  };
+}
+
+// src/composables/useDatabase.ts
+var import_runtime_core46 = require("@vue/runtime-core");
+function useDatabase(name = "default") {
+  const isOpen = (0, import_runtime_core46.ref)(false);
+  let opened = false;
+  async function ensureOpen() {
+    if (opened) return;
+    await NativeBridge.invokeNativeModule("Database", "open", [name]);
+    opened = true;
+    isOpen.value = true;
+  }
+  async function execute(sql, params) {
+    await ensureOpen();
+    return NativeBridge.invokeNativeModule("Database", "execute", [name, sql, params ?? []]);
+  }
+  async function query(sql, params) {
+    await ensureOpen();
+    return NativeBridge.invokeNativeModule("Database", "query", [name, sql, params ?? []]);
+  }
+  async function transaction(callback) {
+    await ensureOpen();
+    const statements = [];
+    const ctx = {
+      execute: async (sql, params) => {
+        statements.push({ sql, params: params ?? [] });
+        return { rowsAffected: 0 };
+      },
+      query: async (sql, params) => {
+        if (statements.length > 0) {
+          await NativeBridge.invokeNativeModule("Database", "executeTransaction", [name, statements.splice(0)]);
+        }
+        return NativeBridge.invokeNativeModule("Database", "query", [name, sql, params ?? []]);
+      }
+    };
+    await callback(ctx);
+    if (statements.length > 0) {
+      await NativeBridge.invokeNativeModule("Database", "executeTransaction", [name, statements]);
+    }
+  }
+  async function close() {
+    if (!opened) return;
+    await NativeBridge.invokeNativeModule("Database", "close", [name]);
+    opened = false;
+    isOpen.value = false;
+  }
+  (0, import_runtime_core46.onUnmounted)(() => {
+    if (opened) {
+      NativeBridge.invokeNativeModule("Database", "close", [name]).catch(() => {
+      });
+      opened = false;
+      isOpen.value = false;
+    }
+  });
+  return { execute, query, transaction, close, isOpen };
+}
+
+// src/composables/usePerformance.ts
+var import_runtime_core47 = require("@vue/runtime-core");
+function usePerformance() {
+  const isProfiling = (0, import_runtime_core47.ref)(false);
+  const fps = (0, import_runtime_core47.ref)(0);
+  const memoryMB = (0, import_runtime_core47.ref)(0);
+  const bridgeOps = (0, import_runtime_core47.ref)(0);
+  let unsubscribe = null;
+  function handleMetrics(payload) {
+    fps.value = payload.fps ?? 0;
+    memoryMB.value = payload.memoryMB ?? 0;
+    bridgeOps.value = payload.bridgeOps ?? 0;
+  }
+  async function startProfiling() {
+    if (isProfiling.value) return;
+    unsubscribe = NativeBridge.onGlobalEvent("perf:metrics", handleMetrics);
+    await NativeBridge.invokeNativeModule("Performance", "startProfiling", []);
+    isProfiling.value = true;
+  }
+  async function stopProfiling() {
+    if (!isProfiling.value) return;
+    await NativeBridge.invokeNativeModule("Performance", "stopProfiling", []);
+    isProfiling.value = false;
+    if (unsubscribe) {
+      unsubscribe();
+      unsubscribe = null;
+    }
+  }
+  async function getMetrics() {
+    return NativeBridge.invokeNativeModule("Performance", "getMetrics", []);
+  }
+  (0, import_runtime_core47.onUnmounted)(() => {
+    if (isProfiling.value) {
+      NativeBridge.invokeNativeModule("Performance", "stopProfiling", []).catch(() => {
+      });
+      isProfiling.value = false;
+    }
+    if (unsubscribe) {
+      unsubscribe();
+      unsubscribe = null;
+    }
+  });
+  return {
+    startProfiling,
+    stopProfiling,
+    getMetrics,
+    isProfiling,
+    fps,
+    memoryMB,
+    bridgeOps
+  };
+}
+
+// src/composables/useSharedElementTransition.ts
+var import_runtime_core48 = require("@vue/runtime-core");
+var sharedElementRegistry = /* @__PURE__ */ new Map();
+function useSharedElementTransition(elementId) {
+  const viewId = (0, import_runtime_core48.ref)(null);
+  function register(nativeViewId) {
+    viewId.value = nativeViewId;
+    sharedElementRegistry.set(elementId, nativeViewId);
+  }
+  function unregister() {
+    viewId.value = null;
+    sharedElementRegistry.delete(elementId);
+  }
+  (0, import_runtime_core48.onUnmounted)(() => {
+    unregister();
+  });
+  return {
+    id: elementId,
+    viewId,
+    register,
+    unregister
+  };
+}
+async function measureViewFrame(nativeViewId) {
+  return NativeBridge.invokeNativeModule("Animation", "measureView", [nativeViewId]);
+}
+function getSharedElementViewId(elementId) {
+  return sharedElementRegistry.get(elementId);
+}
+function getRegisteredSharedElements() {
+  return Array.from(sharedElementRegistry.keys());
+}
+function clearSharedElementRegistry() {
+  sharedElementRegistry.clear();
+}
+
+// src/composables/useIAP.ts
+var import_runtime_core49 = require("@vue/runtime-core");
+function useIAP() {
+  const products = (0, import_runtime_core49.ref)([]);
+  const isReady = (0, import_runtime_core49.ref)(false);
+  const error = (0, import_runtime_core49.ref)(null);
+  const cleanups = [];
+  const unsubscribe = NativeBridge.onGlobalEvent("iap:transactionUpdate", (payload) => {
+    if (payload.state === "failed" && payload.error) {
+      error.value = payload.error;
+    }
+  });
+  cleanups.push(unsubscribe);
+  NativeBridge.invokeNativeModule("IAP", "initialize").then(() => {
+    isReady.value = true;
+  }).catch((err) => {
+    error.value = String(err);
+  });
+  async function getProducts(skus) {
+    error.value = null;
+    try {
+      const result = await NativeBridge.invokeNativeModule("IAP", "getProducts", [skus]);
+      const productList = result;
+      products.value = productList;
+      return productList;
+    } catch (err) {
+      error.value = String(err);
+      return [];
+    }
+  }
+  async function purchase(sku) {
+    error.value = null;
+    try {
+      return await NativeBridge.invokeNativeModule("IAP", "purchase", [sku]);
+    } catch (err) {
+      error.value = String(err);
+      return null;
+    }
+  }
+  async function restorePurchases() {
+    error.value = null;
+    try {
+      return await NativeBridge.invokeNativeModule("IAP", "restorePurchases");
+    } catch (err) {
+      error.value = String(err);
+      return [];
+    }
+  }
+  async function getActiveSubscriptions() {
+    error.value = null;
+    try {
+      return await NativeBridge.invokeNativeModule("IAP", "getActiveSubscriptions");
+    } catch (err) {
+      error.value = String(err);
+      return [];
+    }
+  }
+  function onTransactionUpdate(callback) {
+    const unsub = NativeBridge.onGlobalEvent("iap:transactionUpdate", callback);
+    cleanups.push(unsub);
+    return unsub;
+  }
+  (0, import_runtime_core49.onUnmounted)(() => {
+    cleanups.forEach((fn) => fn());
+    cleanups.length = 0;
+  });
+  return {
+    products,
+    isReady,
+    error,
+    getProducts,
+    purchase,
+    restorePurchases,
+    getActiveSubscriptions,
+    onTransactionUpdate
+  };
+}
+
+// src/composables/useAppleSignIn.ts
+var import_runtime_core50 = require("@vue/runtime-core");
+function useAppleSignIn() {
+  const user = (0, import_runtime_core50.ref)(null);
+  const isAuthenticated = (0, import_runtime_core50.ref)(false);
+  const error = (0, import_runtime_core50.ref)(null);
+  const cleanups = [];
+  const unsubscribe = NativeBridge.onGlobalEvent("auth:appleCredentialRevoked", () => {
+    user.value = null;
+    isAuthenticated.value = false;
+  });
+  cleanups.push(unsubscribe);
+  NativeBridge.invokeNativeModule("SocialAuth", "getCurrentUser", ["apple"]).then((result) => {
+    if (result && result.userId) {
+      user.value = { ...result, provider: "apple" };
+      isAuthenticated.value = true;
+    }
+  }).catch(() => {
+  });
+  async function signIn() {
+    error.value = null;
+    try {
+      const result = await NativeBridge.invokeNativeModule("SocialAuth", "signInWithApple");
+      const socialUser = { ...result, provider: "apple" };
+      user.value = socialUser;
+      isAuthenticated.value = true;
+      return { success: true, user: socialUser };
+    } catch (err) {
+      const message = String(err);
+      error.value = message;
+      return { success: false, error: message };
+    }
+  }
+  async function signOut() {
+    error.value = null;
+    try {
+      await NativeBridge.invokeNativeModule("SocialAuth", "signOut", ["apple"]);
+      user.value = null;
+      isAuthenticated.value = false;
+    } catch (err) {
+      error.value = String(err);
+    }
+  }
+  (0, import_runtime_core50.onUnmounted)(() => {
+    cleanups.forEach((fn) => fn());
+    cleanups.length = 0;
+  });
+  return { signIn, signOut, user, isAuthenticated, error };
+}
+
+// src/composables/useGoogleSignIn.ts
+var import_runtime_core51 = require("@vue/runtime-core");
+function useGoogleSignIn(clientId) {
+  const user = (0, import_runtime_core51.ref)(null);
+  const isAuthenticated = (0, import_runtime_core51.ref)(false);
+  const error = (0, import_runtime_core51.ref)(null);
+  const cleanups = [];
+  NativeBridge.invokeNativeModule("SocialAuth", "getCurrentUser", ["google"]).then((result) => {
+    if (result && result.userId) {
+      user.value = { ...result, provider: "google" };
+      isAuthenticated.value = true;
+    }
+  }).catch(() => {
+  });
+  async function signIn() {
+    error.value = null;
+    try {
+      const result = await NativeBridge.invokeNativeModule("SocialAuth", "signInWithGoogle", [clientId]);
+      const socialUser = { ...result, provider: "google" };
+      user.value = socialUser;
+      isAuthenticated.value = true;
+      return { success: true, user: socialUser };
+    } catch (err) {
+      const message = String(err);
+      error.value = message;
+      return { success: false, error: message };
+    }
+  }
+  async function signOut() {
+    error.value = null;
+    try {
+      await NativeBridge.invokeNativeModule("SocialAuth", "signOut", ["google"]);
+      user.value = null;
+      isAuthenticated.value = false;
+    } catch (err) {
+      error.value = String(err);
+    }
+  }
+  (0, import_runtime_core51.onUnmounted)(() => {
+    cleanups.forEach((fn) => fn());
+    cleanups.length = 0;
+  });
+  return { signIn, signOut, user, isAuthenticated, error };
+}
+
+// src/composables/useBackgroundTask.ts
+var import_runtime_core52 = require("@vue/runtime-core");
+function useBackgroundTask() {
+  const taskHandlers = /* @__PURE__ */ new Map();
+  const defaultHandler = (0, import_runtime_core52.ref)(null);
+  const unsubscribe = NativeBridge.onGlobalEvent("background:taskExecute", (payload) => {
+    const handler = taskHandlers.get(payload.taskId) || defaultHandler.value;
+    if (handler) {
+      handler(payload.taskId);
+    }
+  });
+  (0, import_runtime_core52.onUnmounted)(unsubscribe);
+  function registerTask(taskId) {
+    return NativeBridge.invokeNativeModule("BackgroundTask", "registerTask", [taskId]).then(() => void 0);
+  }
+  function scheduleTask(taskId, options = {}) {
+    const type = options.type ?? "refresh";
+    return NativeBridge.invokeNativeModule("BackgroundTask", "scheduleTask", [taskId, type, {
+      earliestBeginDate: options.earliestBeginDate,
+      requiresNetworkConnectivity: options.requiresNetworkConnectivity,
+      requiresExternalPower: options.requiresExternalPower,
+      interval: options.interval
+    }]).then(() => void 0);
+  }
+  function cancelTask(taskId) {
+    return NativeBridge.invokeNativeModule("BackgroundTask", "cancelTask", [taskId]).then(() => void 0);
+  }
+  function cancelAllTasks() {
+    return NativeBridge.invokeNativeModule("BackgroundTask", "cancelAllTasks", []).then(() => void 0);
+  }
+  function completeTask(taskId, success = true) {
+    return NativeBridge.invokeNativeModule("BackgroundTask", "completeTask", [taskId, success]).then(() => void 0);
+  }
+  function onTaskExecute(handler, taskId) {
+    if (taskId) {
+      taskHandlers.set(taskId, handler);
+      return () => {
+        taskHandlers.delete(taskId);
+      };
+    } else {
+      defaultHandler.value = handler;
+      return () => {
+        defaultHandler.value = null;
+      };
+    }
+  }
+  return { registerTask, scheduleTask, cancelTask, cancelAllTasks, completeTask, onTaskExecute };
+}
+
+// src/composables/useOTAUpdate.ts
+var import_runtime_core53 = require("@vue/runtime-core");
+function useOTAUpdate(serverUrl) {
+  const currentVersion = (0, import_runtime_core53.ref)("embedded");
+  const availableVersion = (0, import_runtime_core53.ref)(null);
+  const downloadProgress = (0, import_runtime_core53.ref)(0);
+  const isChecking = (0, import_runtime_core53.ref)(false);
+  const isDownloading = (0, import_runtime_core53.ref)(false);
+  const status = (0, import_runtime_core53.ref)("idle");
+  const error = (0, import_runtime_core53.ref)(null);
+  let lastUpdateInfo = null;
+  const unsubscribe = NativeBridge.onGlobalEvent("ota:downloadProgress", (payload) => {
+    downloadProgress.value = payload.progress;
   });
+  (0, import_runtime_core53.onUnmounted)(unsubscribe);
+  NativeBridge.invokeNativeModule("OTA", "getCurrentVersion", []).then((info) => {
+    currentVersion.value = info.version;
+  }).catch(() => {
+  });
+  async function checkForUpdate() {
+    isChecking.value = true;
+    status.value = "checking";
+    error.value = null;
+    try {
+      const info = await NativeBridge.invokeNativeModule("OTA", "checkForUpdate", [serverUrl]);
+      lastUpdateInfo = info;
+      if (info.updateAvailable) {
+        availableVersion.value = info.version;
+      } else {
+        availableVersion.value = null;
+      }
+      status.value = info.updateAvailable ? "idle" : "idle";
+      return info;
+    } catch (err) {
+      error.value = err?.message || String(err);
+      status.value = "error";
+      throw err;
+    } finally {
+      isChecking.value = false;
+    }
+  }
+  async function downloadUpdate(url, hash) {
+    const downloadUrl = url || lastUpdateInfo?.downloadUrl;
+    const expectedHash = hash || lastUpdateInfo?.hash;
+    if (!downloadUrl) {
+      const msg = "No download URL. Call checkForUpdate() first or provide a URL.";
+      error.value = msg;
+      status.value = "error";
+      throw new Error(msg);
+    }
+    isDownloading.value = true;
+    downloadProgress.value = 0;
+    status.value = "downloading";
+    error.value = null;
+    try {
+      await NativeBridge.invokeNativeModule("OTA", "downloadUpdate", [downloadUrl, expectedHash || ""]);
+      status.value = "ready";
+    } catch (err) {
+      error.value = err?.message || String(err);
+      status.value = "error";
+      throw err;
+    } finally {
+      isDownloading.value = false;
+    }
+  }
+  async function applyUpdate() {
+    error.value = null;
+    try {
+      await NativeBridge.invokeNativeModule("OTA", "applyUpdate", []);
+      const info = await NativeBridge.invokeNativeModule("OTA", "getCurrentVersion", []);
+      currentVersion.value = info.version;
+      availableVersion.value = null;
+      status.value = "idle";
+    } catch (err) {
+      error.value = err?.message || String(err);
+      status.value = "error";
+      throw err;
+    }
+  }
+  async function rollback() {
+    error.value = null;
+    try {
+      await NativeBridge.invokeNativeModule("OTA", "rollback", []);
+      const info = await NativeBridge.invokeNativeModule("OTA", "getCurrentVersion", []);
+      currentVersion.value = info.version;
+      status.value = "idle";
+    } catch (err) {
+      error.value = err?.message || String(err);
+      status.value = "error";
+      throw err;
+    }
+  }
+  async function getCurrentVersion() {
+    const info = await NativeBridge.invokeNativeModule("OTA", "getCurrentVersion", []);
+    currentVersion.value = info.version;
+    return info;
+  }
+  return {
+    checkForUpdate,
+    downloadUpdate,
+    applyUpdate,
+    rollback,
+    getCurrentVersion,
+    currentVersion,
+    availableVersion,
+    downloadProgress,
+    isChecking,
+    isDownloading,
+    status,
+    error
+  };
+}
+
+// src/composables/useBluetooth.ts
+var import_runtime_core54 = require("@vue/runtime-core");
+function useBluetooth() {
+  const devices = (0, import_runtime_core54.ref)([]);
+  const connectedDevice = (0, import_runtime_core54.ref)(null);
+  const isScanning = (0, import_runtime_core54.ref)(false);
+  const isAvailable = (0, import_runtime_core54.ref)(false);
+  const error = (0, import_runtime_core54.ref)(null);
+  const cleanups = [];
+  NativeBridge.invokeNativeModule("Bluetooth", "getState").then((state) => {
+    isAvailable.value = state === "poweredOn";
+  }).catch(() => {
+    isAvailable.value = false;
+  });
+  const unsubState = NativeBridge.onGlobalEvent("ble:stateChanged", (payload) => {
+    isAvailable.value = payload.state === "poweredOn";
+  });
+  cleanups.push(unsubState);
+  const unsubFound = NativeBridge.onGlobalEvent("ble:deviceFound", (payload) => {
+    const existing = devices.value.findIndex((d) => d.id === payload.id);
+    if (existing >= 0) {
+      devices.value[existing] = payload;
+    } else {
+      devices.value = [...devices.value, payload];
+    }
+  });
+  cleanups.push(unsubFound);
+  const unsubConnected = NativeBridge.onGlobalEvent("ble:connected", (payload) => {
+    connectedDevice.value = payload;
+  });
+  cleanups.push(unsubConnected);
+  const unsubDisconnected = NativeBridge.onGlobalEvent("ble:disconnected", () => {
+    connectedDevice.value = null;
+  });
+  cleanups.push(unsubDisconnected);
+  const unsubError = NativeBridge.onGlobalEvent("ble:error", (payload) => {
+    error.value = payload.message;
+  });
+  cleanups.push(unsubError);
+  async function scan(serviceUUIDs) {
+    devices.value = [];
+    isScanning.value = true;
+    error.value = null;
+    try {
+      await NativeBridge.invokeNativeModule("Bluetooth", "startScan", [serviceUUIDs]);
+    } catch (e) {
+      error.value = e?.message || String(e);
+      isScanning.value = false;
+    }
+  }
+  async function stopScan() {
+    await NativeBridge.invokeNativeModule("Bluetooth", "stopScan");
+    isScanning.value = false;
+  }
+  async function connect(deviceId) {
+    error.value = null;
+    const result = await NativeBridge.invokeNativeModule("Bluetooth", "connect", [deviceId]);
+    return result;
+  }
+  async function disconnect(deviceId) {
+    await NativeBridge.invokeNativeModule("Bluetooth", "disconnect", [deviceId]);
+    connectedDevice.value = null;
+  }
+  async function read(deviceId, serviceUUID, charUUID) {
+    return NativeBridge.invokeNativeModule("Bluetooth", "readCharacteristic", [deviceId, serviceUUID, charUUID]);
+  }
+  async function write(deviceId, serviceUUID, charUUID, data) {
+    return NativeBridge.invokeNativeModule("Bluetooth", "writeCharacteristic", [deviceId, serviceUUID, charUUID, data]);
+  }
+  async function subscribe(deviceId, serviceUUID, charUUID, callback) {
+    await NativeBridge.invokeNativeModule("Bluetooth", "subscribeToCharacteristic", [deviceId, serviceUUID, charUUID]);
+    const unsubscribe = NativeBridge.onGlobalEvent("ble:characteristicChanged", (payload) => {
+      if (payload.deviceId === deviceId && payload.serviceUUID === serviceUUID && payload.characteristicUUID === charUUID) {
+        callback(payload);
+      }
+    });
+    cleanups.push(unsubscribe);
+    return async () => {
+      unsubscribe();
+      await NativeBridge.invokeNativeModule("Bluetooth", "unsubscribeFromCharacteristic", [
+        deviceId,
+        serviceUUID,
+        charUUID
+      ]);
+    };
+  }
+  (0, import_runtime_core54.onUnmounted)(() => {
+    if (isScanning.value) {
+      NativeBridge.invokeNativeModule("Bluetooth", "stopScan").catch(() => {
+      });
+    }
+    cleanups.forEach((fn) => fn());
+    cleanups.length = 0;
+  });
+  return {
+    scan,
+    stopScan,
+    connect,
+    disconnect,
+    read,
+    write,
+    subscribe,
+    devices,
+    connectedDevice,
+    isScanning,
+    isAvailable,
+    error
+  };
+}
+
+// src/composables/useCalendar.ts
+var import_runtime_core55 = require("@vue/runtime-core");
+function useCalendar() {
+  const hasAccess = (0, import_runtime_core55.ref)(false);
+  const error = (0, import_runtime_core55.ref)(null);
+  async function requestAccess() {
+    try {
+      const result = await NativeBridge.invokeNativeModule("Calendar", "requestAccess");
+      hasAccess.value = result.granted;
+      return result.granted;
+    } catch (e) {
+      error.value = e?.message || String(e);
+      return false;
+    }
+  }
+  async function getEvents(startDate, endDate) {
+    return NativeBridge.invokeNativeModule("Calendar", "getEvents", [startDate, endDate]);
+  }
+  async function createEvent(options) {
+    return NativeBridge.invokeNativeModule("Calendar", "createEvent", [
+      options.title,
+      options.startDate,
+      options.endDate,
+      options.notes,
+      options.calendarId
+    ]);
+  }
+  async function deleteEvent(eventId) {
+    return NativeBridge.invokeNativeModule("Calendar", "deleteEvent", [eventId]);
+  }
+  async function getCalendars() {
+    return NativeBridge.invokeNativeModule("Calendar", "getCalendars");
+  }
+  return { requestAccess, getEvents, createEvent, deleteEvent, getCalendars, hasAccess, error };
+}
+
+// src/composables/useContacts.ts
+var import_runtime_core56 = require("@vue/runtime-core");
+function useContacts() {
+  const hasAccess = (0, import_runtime_core56.ref)(false);
+  const error = (0, import_runtime_core56.ref)(null);
+  async function requestAccess() {
+    try {
+      const result = await NativeBridge.invokeNativeModule("Contacts", "requestAccess");
+      hasAccess.value = result.granted;
+      return result.granted;
+    } catch (e) {
+      error.value = e?.message || String(e);
+      return false;
+    }
+  }
+  async function getContacts(query) {
+    return NativeBridge.invokeNativeModule("Contacts", "getContacts", [query]);
+  }
+  async function getContact(id) {
+    return NativeBridge.invokeNativeModule("Contacts", "getContact", [id]);
+  }
+  async function createContact(data) {
+    return NativeBridge.invokeNativeModule("Contacts", "createContact", [data]);
+  }
+  async function deleteContact(id) {
+    return NativeBridge.invokeNativeModule("Contacts", "deleteContact", [id]);
+  }
+  return { requestAccess, getContacts, getContact, createContact, deleteContact, hasAccess, error };
 }
 
 // src/index.ts
@@ -1760,6 +3346,15 @@ function createApp(rootComponent, rootProps) {
   app.component("VPicker", VPicker);
   app.component("VSegmentedControl", VSegmentedControl);
   app.component("VActionSheet", VActionSheet);
+  app.component("VRefreshControl", VRefreshControl);
+  app.component("VPressable", VPressable);
+  app.component("VSectionList", VSectionList);
+  app.component("VCheckbox", VCheckbox);
+  app.component("VRadio", VRadio);
+  app.component("VDropdown", VDropdown);
+  app.component("VVideo", VVideo);
+  app.component("ErrorBoundary", ErrorBoundary);
+  app.component("VErrorBoundary", ErrorBoundary);
   app.directive("show", vShow);
   app.config.errorHandler = (err, instance, info) => {
     const error = err instanceof Error ? err : new Error(String(err));
@@ -1777,7 +3372,7 @@ function createApp(rootComponent, rootProps) {
     }
   };
   if (typeof __DEV__ !== "undefined" && __DEV__) {
-    app.config.warnHandler = (msg, instance, trace) => {
+    app.config.warnHandler = (msg, instance, _trace) => {
       const componentName = instance?.$options?.name || instance?.$.type?.name || "Anonymous";
       console.warn(`[VueNative] Warning in ${componentName}: ${msg}`);
     };
@@ -1786,7 +3381,7 @@ function createApp(rootComponent, rootProps) {
     const root = createNativeNode("__ROOT__");
     NativeBridge.createNode(root.id, "__ROOT__");
     NativeBridge.setRootView(root.id);
-    const vnode = (0, import_runtime_core32.createVNode)(rootComponent, rootProps);
+    const vnode = (0, import_runtime_core57.createVNode)(rootComponent, rootProps);
     vnode.appContext = app._context;
     render(vnode, root);
     return root;
@@ -1795,52 +3390,84 @@ function createApp(rootComponent, rootProps) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ErrorBoundary,
   NativeBridge,
   VActionSheet,
   VActivityIndicator,
   VAlertDialog,
   VButton,
+  VCheckbox,
+  VDropdown,
   VImage,
   VInput,
   VKeyboardAvoiding,
   VList,
   VModal,
   VPicker,
+  VPressable,
   VProgressBar,
+  VRadio,
+  VRefreshControl,
   VSafeArea,
   VScrollView,
+  VSectionList,
   VSegmentedControl,
   VSlider,
   VStatusBar,
   VSwitch,
   VText,
+  VVideo,
   VView,
   VWebView,
+  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,
   ...require("@vue/runtime-core")