react-native-wireguard-vpn-patched 1.0.22-patch.2

package/ios/WireGuardVpn.h

@@ -0,0 +1,5 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface WireGuardVpn : RCTEventEmitter <RCTBridgeModule>
+@end 

package/ios/WireGuardVpn.m

@@ -0,0 +1,294 @@
+#import "WireGuardVpn.h"
+#import <NetworkExtension/NetworkExtension.h>
+
+@implementation WireGuardVpn {
+  id _neStatusObserver;
+}
+
+RCT_EXPORT_MODULE(WireGuardVpnModule)
+
+- (NSArray<NSString *> *)supportedEvents
+{
+  return @[@"vpnStateChanged"];
+}
+
+// RN will call these when JS starts/stops listening to events.
+- (void)startObserving
+{
+  if (_neStatusObserver != nil) return;
+
+  __weak typeof(self) weakSelf = self;
+  _neStatusObserver = [[NSNotificationCenter defaultCenter]
+      addObserverForName:NEVPNStatusDidChangeNotification
+                  object:nil
+                   queue:[NSOperationQueue mainQueue]
+              usingBlock:^(NSNotification * _Nonnull note) {
+                [weakSelf emitVpnStateChanged];
+              }];
+}
+
+- (void)stopObserving
+{
+  if (_neStatusObserver == nil) return;
+  [[NSNotificationCenter defaultCenter] removeObserver:_neStatusObserver];
+  _neStatusObserver = nil;
+}
+
+- (void)emitVpnStateChanged
+{
+  if (![self hasListeners]) return;
+
+  NSString *providerBundleIdentifier = @"com.wireguardvpn.tunnel";
+  [NETunnelProviderManager loadAllFromPreferencesWithCompletionHandler:^(NSArray<NETunnelProviderManager *> * _Nullable managers, NSError * _Nullable error) {
+    if (error || managers == nil) return;
+
+    NETunnelProviderManager *manager = nil;
+    for (NETunnelProviderManager *m in managers) {
+      if (![m.protocolConfiguration isKindOfClass:[NETunnelProviderProtocol class]]) continue;
+      NETunnelProviderProtocol *p = (NETunnelProviderProtocol *)m.protocolConfiguration;
+      if ([p.providerBundleIdentifier isEqualToString:providerBundleIdentifier]) {
+        manager = m;
+        break;
+      }
+    }
+
+    if (!manager) return;
+
+    NEVPNStatus status = manager.connection.status;
+    NSString *tunnelState = [self stringFromVPNStatus:status];
+
+    NSString *simpleStatus = nil;
+    if (status == NEVPNStatusConnected) simpleStatus = @"CONNECTED";
+    else if (status == NEVPNStatusDisconnected) simpleStatus = @"DISCONNECTED";
+    else if (status == NEVPNStatusConnecting) simpleStatus = @"CONNECTING";
+    else if (status == NEVPNStatusDisconnecting) simpleStatus = @"DISCONNECTING";
+    else if (status == NEVPNStatusInvalid) simpleStatus = @"ERROR";
+    else simpleStatus = @"UNKNOWN";
+
+    NSDictionary *body = @{
+      @"isConnected": @((status == NEVPNStatusConnected) ? YES : NO),
+      @"tunnelState": tunnelState ?: @"UNKNOWN",
+      @"status": simpleStatus ?: @"UNKNOWN"
+    };
+
+    [self sendEventWithName:@"vpnStateChanged" body:body];
+  }];
+}
+
+RCT_EXPORT_METHOD(initialize:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+  [NETunnelProviderManager loadAllFromPreferencesWithCompletionHandler:^(NSArray<NETunnelProviderManager *> * _Nullable managers, NSError * _Nullable error) {
+    if (error) {
+      reject(@"INIT_ERROR", error.localizedDescription, error);
+      return;
+    }
+    
+    NETunnelProviderManager *manager = managers.firstObject ?: [[NETunnelProviderManager alloc] init];
+    manager.localizedDescription = @"WireGuard VPN";
+    manager.protocolConfiguration = [[NETunnelProviderProtocol alloc] init];
+    
+    [manager saveToPreferencesWithCompletionHandler:^(NSError * _Nullable error) {
+      if (error) {
+        reject(@"INIT_ERROR", error.localizedDescription, error);
+        return;
+      }
+      resolve(nil);
+    }];
+  }];
+}
+
+RCT_EXPORT_METHOD(connect:(NSDictionary *)config
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+  // Validate required config early for clearer errors.
+  NSString *serverAddress = config[@"serverAddress"];
+  id serverPort = config[@"serverPort"];
+  NSString *privateKey = config[@"privateKey"];
+  NSString *publicKey = config[@"publicKey"];
+  id allowedIPs = config[@"allowedIPs"];
+
+  BOOL hasRequired =
+      (serverAddress && ![serverAddress isKindOfClass:[NSNull class]]) &&
+      (privateKey && ![privateKey isKindOfClass:[NSNull class]]) &&
+      (publicKey && ![publicKey isKindOfClass:[NSNull class]]) &&
+      serverPort &&
+      (allowedIPs && [allowedIPs isKindOfClass:[NSArray class]] && [(NSArray *)allowedIPs count] > 0);
+
+  if (!hasRequired) {
+    reject(@"CONNECT_ERROR",
+           @"Missing required config: serverAddress, serverPort, privateKey, publicKey, allowedIPs (non-empty array)",
+           nil);
+    return;
+  }
+
+  [NETunnelProviderManager loadAllFromPreferencesWithCompletionHandler:^(NSArray<NETunnelProviderManager *> * _Nullable managers, NSError * _Nullable error) {
+    if (error) {
+      reject(@"CONNECT_ERROR", error.localizedDescription, error);
+      return;
+    }
+    
+    NSString *providerBundleIdentifier = @"com.wireguardvpn.tunnel";
+
+    // Pick the correct NETunnelProviderManager (do not assume firstObject).
+    NETunnelProviderManager *manager = nil;
+    for (NETunnelProviderManager *m in managers) {
+      if (![m.protocolConfiguration isKindOfClass:[NETunnelProviderProtocol class]]) {
+        continue;
+      }
+      NETunnelProviderProtocol *p = (NETunnelProviderProtocol *)m.protocolConfiguration;
+      if ([p.providerBundleIdentifier isEqualToString:providerBundleIdentifier]) {
+        manager = m;
+        break;
+      }
+    }
+    if (!manager) {
+      manager = [[NETunnelProviderManager alloc] init];
+    }
+
+    manager.enabled = YES;
+
+    NETunnelProviderProtocol *protocol = nil;
+    if ([manager.protocolConfiguration isKindOfClass:[NETunnelProviderProtocol class]]) {
+      protocol = (NETunnelProviderProtocol *)manager.protocolConfiguration;
+    } else {
+      protocol = [[NETunnelProviderProtocol alloc] init];
+    }
+
+    protocol.serverAddress = config[@"serverAddress"];
+    protocol.providerBundleIdentifier = providerBundleIdentifier;
+    
+    NSMutableDictionary *tunnelConfig = [NSMutableDictionary dictionary];
+    tunnelConfig[@"privateKey"] = config[@"privateKey"];
+    tunnelConfig[@"publicKey"] = config[@"publicKey"];
+    tunnelConfig[@"serverPort"] = config[@"serverPort"];
+    tunnelConfig[@"allowedIPs"] = config[@"allowedIPs"];
+    tunnelConfig[@"dns"] = config[@"dns"];
+    tunnelConfig[@"mtu"] = config[@"mtu"];
+    
+    protocol.providerConfiguration = tunnelConfig;
+
+    manager.protocolConfiguration = protocol;
+
+    [manager saveToPreferencesWithCompletionHandler:^(NSError * _Nullable error) {
+      if (error) {
+        reject(@"CONNECT_ERROR", error.localizedDescription, error);
+        return;
+      }
+      
+      NSError *startError;
+      [manager.connection startVPNTunnelAndReturnError:&startError];
+      
+      if (startError) {
+        reject(@"CONNECT_ERROR", startError.localizedDescription, startError);
+        return;
+      }
+      
+      resolve(nil);
+    }];
+  }];
+}
+
+RCT_EXPORT_METHOD(disconnect:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+  [NETunnelProviderManager loadAllFromPreferencesWithCompletionHandler:^(NSArray<NETunnelProviderManager *> * _Nullable managers, NSError * _Nullable error) {
+    if (error) {
+      reject(@"DISCONNECT_ERROR", error.localizedDescription, error);
+      return;
+    }
+    
+    NSString *providerBundleIdentifier = @"com.wireguardvpn.tunnel";
+    NETunnelProviderManager *manager = nil;
+    for (NETunnelProviderManager *m in managers) {
+      if (![m.protocolConfiguration isKindOfClass:[NETunnelProviderProtocol class]]) continue;
+      NETunnelProviderProtocol *p = (NETunnelProviderProtocol *)m.protocolConfiguration;
+      if ([p.providerBundleIdentifier isEqualToString:providerBundleIdentifier]) {
+        manager = m;
+        break;
+      }
+    }
+    
+    if (!manager) {
+      resolve(nil);
+      return;
+    }
+
+    [manager.connection stopVPNTunnel];
+    resolve(nil);
+  }];
+}
+
+RCT_EXPORT_METHOD(getStatus:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+  [NETunnelProviderManager loadAllFromPreferencesWithCompletionHandler:^(NSArray<NETunnelProviderManager *> * _Nullable managers, NSError * _Nullable error) {
+    if (error) {
+      reject(@"STATUS_ERROR", error.localizedDescription, error);
+      return;
+    }
+    
+    NSString *providerBundleIdentifier = @"com.wireguardvpn.tunnel";
+    NETunnelProviderManager *manager = nil;
+    for (NETunnelProviderManager *m in managers) {
+      if (![m.protocolConfiguration isKindOfClass:[NETunnelProviderProtocol class]]) continue;
+      NETunnelProviderProtocol *p = (NETunnelProviderProtocol *)m.protocolConfiguration;
+      if ([p.providerBundleIdentifier isEqualToString:providerBundleIdentifier]) {
+        manager = m;
+        break;
+      }
+    }
+
+    if (!manager) {
+      resolve(@{
+        @"isConnected": @NO,
+        @"tunnelState": @"INACTIVE",
+        @"status": @"DISCONNECTED",
+      });
+      return;
+    }
+
+    NEVPNStatus status = manager.connection.status;
+    NSString *tunnelState = [self stringFromVPNStatus:status];
+    NSString *simpleStatus = nil;
+    if (status == NEVPNStatusConnected) simpleStatus = @"CONNECTED";
+    else if (status == NEVPNStatusDisconnected) simpleStatus = @"DISCONNECTED";
+    else if (status == NEVPNStatusConnecting) simpleStatus = @"CONNECTING";
+    else if (status == NEVPNStatusDisconnecting) simpleStatus = @"DISCONNECTING";
+    else if (status == NEVPNStatusInvalid) simpleStatus = @"ERROR";
+    else simpleStatus = @"UNKNOWN";
+
+    resolve(@{
+      @"isConnected": @(status == NEVPNStatusConnected),
+      @"tunnelState": tunnelState,
+      @"status": simpleStatus
+    });
+  }];
+}
+
+RCT_EXPORT_METHOD(isSupported:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+  resolve(@YES);
+}
+
+- (NSString *)stringFromVPNStatus:(NEVPNStatus)status
+{
+  switch (status) {
+    case NEVPNStatusConnected:
+      return @"ACTIVE";
+    case NEVPNStatusConnecting:
+      return @"CONNECTING";
+    case NEVPNStatusDisconnecting:
+      return @"DISCONNECTING";
+    case NEVPNStatusDisconnected:
+      return @"INACTIVE";
+    case NEVPNStatusInvalid:
+      return @"ERROR";
+    default:
+      return @"UNKNOWN";
+  }
+}
+
+@end 

package/lib/index.d.ts

@@ -0,0 +1,53 @@
+export interface WireGuardConfig {
+    privateKey: string;
+    publicKey: string;
+    serverAddress: string;
+    serverPort: number;
+    /** Interface address(es), e.g. "10.64.0.1/32". If omitted, defaults to 10.64.0.1/32. Do not use 0.0.0.0/0 or ::/0 here (use allowedIPs for routing). */
+    address?: string | string[];
+    allowedIPs: string[];
+    dns?: string[];
+    mtu?: number;
+    presharedKey?: string;
+    /**
+     * Split tunneling — Android only.
+     * Package names of apps whose traffic should bypass the VPN tunnel.
+     * Example: ["com.google.android.apps.maps", "com.example.bankingapp"]
+     */
+    excludedApps?: string[];
+}
+export interface WireGuardStatus {
+    isConnected: boolean;
+    tunnelState: 'ACTIVE' | 'INACTIVE' | 'CONNECTING' | 'DISCONNECTING' | 'ERROR' | 'UNKNOWN';
+    /**
+     * Connection status as a simpler string for app UI logic.
+     * - CONNECTED when tunnel is up
+     * - DISCONNECTED when tunnel is down
+     * - CONNECTING/DISCONNECTING/ERROR/UNKNOWN for intermediate states
+     */
+    status: 'CONNECTED' | 'DISCONNECTED' | 'CONNECTING' | 'DISCONNECTING' | 'ERROR' | 'UNKNOWN';
+    error?: string;
+}
+declare const _default: {
+    /**
+     * Initialize the VPN service
+     */
+    initialize(): Promise<void>;
+    /**
+     * Connect to VPN using provided configuration
+     */
+    connect(config: WireGuardConfig): Promise<void>;
+    /**
+     * Disconnect from VPN
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Get current VPN status
+     */
+    getStatus(): Promise<WireGuardStatus>;
+    /**
+     * Check if VPN is supported on the device
+     */
+    isSupported(): Promise<boolean>;
+};
+export default _default;

package/lib/index.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_native_1 = require("react-native");
+const LINKING_ERROR = `The package 'react-native-wireguard-vpn-patched' doesn't seem to be linked. Make sure: \n\n` +
+    react_native_1.Platform.select({ ios: "- You have run 'pod install'\n", default: '' }) +
+    '- You rebuilt the app after installing the package\n' +
+    '- You are not using Expo Go\n';
+const WireGuardVpnModule = react_native_1.NativeModules.WireGuardVpnModule
+    ? react_native_1.NativeModules.WireGuardVpnModule
+    : new Proxy({}, {
+        get() {
+            throw new Error(LINKING_ERROR);
+        },
+    });
+exports.default = {
+    /**
+     * Initialize the VPN service
+     */
+    initialize() {
+        return WireGuardVpnModule.initialize();
+    },
+    /**
+     * Connect to VPN using provided configuration
+     */
+    connect(config) {
+        return WireGuardVpnModule.connect(config);
+    },
+    /**
+     * Disconnect from VPN
+     */
+    disconnect() {
+        return WireGuardVpnModule.disconnect();
+    },
+    /**
+     * Get current VPN status
+     */
+    getStatus() {
+        return WireGuardVpnModule.getStatus();
+    },
+    /**
+     * Check if VPN is supported on the device
+     */
+    isSupported() {
+        return WireGuardVpnModule.isSupported();
+    },
+};

package/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;AAAA,+CAAuD;AAEvD,MAAM,aAAa,GACjB,qFAAqF;IACrF,uBAAQ,CAAC,MAAM,CAAC,EAAE,GAAG,EAAE,gCAAgC,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC;IACvE,sDAAsD;IACtD,+BAA+B,CAAC;AAElC,MAAM,kBAAkB,GAAG,4BAAa,CAAC,kBAAkB;IACzD,CAAC,CAAC,4BAAa,CAAC,kBAAkB;IAClC,CAAC,CAAC,IAAI,KAAK,CACP,EAAE,EACF;QACE,GAAG;YACD,MAAM,IAAI,KAAK,CAAC,aAAa,CAAC,CAAC;QACjC,CAAC;KACF,CACF,CAAC;AAwCN,kBAAe;IACb;;OAEG;IACH,UAAU;QACR,OAAO,kBAAkB,CAAC,UAAU,EAAE,CAAC;IACzC,CAAC;IAED;;OAEG;IACH,OAAO,CAAC,MAAuB;QAC7B,OAAO,kBAAkB,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAC5C,CAAC;IAED;;OAEG;IACH,UAAU;QACR,OAAO,kBAAkB,CAAC,UAAU,EAAE,CAAC;IACzC,CAAC;IAED;;OAEG;IACH,SAAS;QACP,OAAO,kBAAkB,CAAC,SAAS,EAAE,CAAC;IACxC,CAAC;IAED;;OAEG;IACH,WAAW;QACT,OAAO,kBAAkB,CAAC,WAAW,EAAE,CAAC;IAC1C,CAAC;CACF,CAAC"}

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "react-native-wireguard-vpn-patched",
+  "version": "1.0.22-patch.2",
+  "description": "Production-ready React Native WireGuard VPN module with Android VPN permission handling and split tunneling support. Forked from react-native-wireguard-vpn v1.0.22.",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "files": [
+    "src",
+    "lib",
+    "android/build.gradle",
+    "android/src",
+    "ios",
+    "plugin",
+    "app.plugin.js",
+    "react-native-wireguard-vpn-patched.podspec"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepare": "npm run build"
+  },
+  "keywords": [
+    "react-native",
+    "wireguard",
+    "vpn",
+    "android",
+    "ios",
+    "split-tunneling",
+    "kill-switch",
+    "tunnel",
+    "wireguard-vpn"
+  ],
+  "author": {
+    "name": "Abdul Ahad",
+    "email": "ahad06074@gmail.com",
+    "url": "https://github.com/AbdulAHAD968"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AbdulAHAD968/react-native-wireguard-vpn-patched.git"
+  },
+  "bugs": {
+    "url": "https://github.com/AbdulAHAD968/react-native-wireguard-vpn-patched/issues"
+  },
+  "homepage": "https://github.com/AbdulAHAD968/react-native-wireguard-vpn-patched#readme",
+  "peerDependencies": {
+    "react": ">=18.2.0",
+    "react-native": ">=0.72.0"
+  },
+  "devDependencies": {
+    "@types/react": "^18.0.0",
+    "react": "18.2.0",
+    "react-native": "0.72.17",
+    "typescript": "^5.0.0"
+  }
+}

package/plugin/withWireGuardVpn.js

@@ -0,0 +1,105 @@
+// Expo config plugin that updates iOS Info.plist + entitlements for Network Extension.
+// This does NOT create the Packet Tunnel extension target; that still must be created in Xcode.
+
+const getConfigPlugins = () => {
+  // Prefer expo's re-export first, but support older setups.
+  try {
+    return require('expo/config-plugins');
+  } catch (e) {
+    return require('@expo/config-plugins');
+  }
+};
+
+const configPlugins = getConfigPlugins();
+const { withInfoPlist, withEntitlementsPlist, withAndroidManifest } = configPlugins;
+
+/**
+ * @type {(config: import('@expo/config-plugins').ConfigPluginProps) => any}
+ */
+function withWireGuardVpn(config) {
+  // 1) iOS Info.plist
+  config = withInfoPlist(config, (cfg) => {
+    cfg.modResults.NSLocalNetworkUsageDescription =
+      cfg.modResults.NSLocalNetworkUsageDescription ||
+      'This app requires access to network features for VPN functionality';
+
+    const existingModes = cfg.modResults.UIBackgroundModes;
+    const modes = Array.isArray(existingModes) ? existingModes.slice() : [];
+
+    if (!modes.includes('network-authentication')) modes.push('network-authentication');
+    if (!modes.includes('network')) modes.push('network');
+
+    cfg.modResults.UIBackgroundModes = modes;
+    return cfg;
+  });
+
+  // 2) iOS entitlements (.entitlements plist)
+  config = withEntitlementsPlist(config, (cfg) => {
+    const entitlements = cfg.modResults || {};
+    const key = 'com.apple.developer.networking.networkextension';
+
+    const current = entitlements[key];
+    const values = Array.isArray(current)
+      ? current.slice()
+      : current
+        ? [current]
+        : [];
+
+    // This entitlement is required for NEPacketTunnelProvider.
+    // If your app/provisioning already contains it, this won't duplicate values.
+    if (!values.includes('packet-tunnel-provider')) values.push('packet-tunnel-provider');
+
+    entitlements[key] = values;
+    cfg.modResults = entitlements;
+    return cfg;
+  });
+
+  // 3) Android: ensure required VPN permissions exist in the app manifest.
+  // RN autolinking usually merges the library manifest automatically, but for Expo/prebuild
+  // we add them defensively to prevent "missing permission" issues.
+  config = withAndroidManifest(config, (cfg) => {
+    const manifest = cfg.modResults.manifest;
+    if (!manifest) return cfg;
+
+    const perms = Array.isArray(manifest['uses-permission'])
+      ? manifest['uses-permission']
+      : [];
+
+    const ensurePermission = (name) => {
+      const exists = perms.some(
+        (p) => p && p.$ && p.$['android:name'] && p.$['android:name'] === name
+      );
+      if (!exists) {
+        perms.push({ $: { 'android:name': name } });
+      }
+    };
+
+    ensurePermission('android.permission.INTERNET');
+    ensurePermission('android.permission.FOREGROUND_SERVICE');
+    ensurePermission('android.permission.BIND_VPN_SERVICE');
+
+    manifest['uses-permission'] = perms;
+
+    // networkSecurityConfig reference: only set if it doesn't exist yet.
+    try {
+      const application = Array.isArray(manifest.application)
+        ? manifest.application[0]
+        : manifest.application;
+      if (application && application.$) {
+        const existing = application.$['android:networkSecurityConfig'];
+        if (!existing) {
+          application.$['android:networkSecurityConfig'] = '@xml/network_security_config';
+        }
+      }
+    } catch (e) {
+      // ignore; manifest structure can vary across Expo/RN versions
+    }
+
+    return cfg;
+  });
+
+  return config;
+}
+
+module.exports = withWireGuardVpn;
+

package/react-native-wireguard-vpn-patched.podspec

@@ -0,0 +1,21 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name         = "react-native-wireguard-vpn-patched"
+  s.version      = package['version']
+  s.summary      = package['description']
+  s.description  = package['description']
+  s.homepage     = package['homepage']
+  s.license      = package['license']
+  s.authors      = package['author']
+  s.platforms    = { :ios => "12.0" }
+  git_url        = package['repository']['url'].to_s.gsub(/^git\+/, '').gsub(/\.git$/, '')
+  s.source       = { :git => git_url, :tag => "v#{s.version}" }
+  s.source_files = "ios/**/*.{h,m,mm}"
+  s.requires_arc = true
+  s.dependency "React-Core"
+  s.frameworks   = "NetworkExtension"
+  s.pod_target_xcconfig = { 'DEFINES_MODULE' => 'YES' }
+end

package/src/index.d.ts

@@ -0,0 +1,41 @@
+declare module 'react-native-wireguard-vpn' {
+  export interface WireGuardConfig {
+    privateKey: string;
+    publicKey: string;
+    serverAddress: string;
+    serverPort: number;
+    /** Interface address(es), e.g. "10.64.0.1/32". Optional; defaults to 10.64.0.1/32. Do not use 0.0.0.0/0 or ::/0 here. */
+    address?: string | string[];
+    allowedIPs: string[];
+    dns?: string[];
+    mtu?: number;
+    presharedKey?: string;
+  }
+
+  export interface WireGuardStatus {
+    isConnected: boolean;
+    tunnelState:
+      | 'ACTIVE'
+      | 'INACTIVE'
+      | 'CONNECTING'
+      | 'DISCONNECTING'
+      | 'ERROR'
+      | 'UNKNOWN';
+    status:
+      | 'CONNECTED'
+      | 'DISCONNECTED'
+      | 'CONNECTING'
+      | 'DISCONNECTING'
+      | 'ERROR'
+      | 'UNKNOWN';
+    error?: string;
+  }
+
+  export const WireGuardVpnModule: {
+    initialize(): Promise<void>;
+    connect(config: WireGuardConfig): Promise<void>;
+    disconnect(): Promise<void>;
+    getStatus(): Promise<WireGuardStatus>;
+    isSupported(): Promise<boolean>;
+  };
+}