github.com/primecitizens/pcz/std@v0.2.1/plat/js/webext/vpnprovider/bindings/ffi_bindings.ts (about)

     1  import { importModule, Application, heap, Pointer } from "@ffi";
     2  
     3  importModule("plat/js/webext/vpnprovider", (A: Application) => {
     4    const WEBEXT = typeof globalThis.browser === "undefined" ? globalThis.chrome : globalThis.browser;
     5  
     6    return {
     7      "store_Parameters": (ptr: Pointer, ref: heap.Ref<any>) => {
     8        const x = A.H.get<any>(ref);
     9  
    10        if (typeof x === "undefined") {
    11          A.store.Bool(ptr + 32, false);
    12          A.store.Ref(ptr + 0, undefined);
    13          A.store.Ref(ptr + 4, undefined);
    14          A.store.Ref(ptr + 8, undefined);
    15          A.store.Ref(ptr + 12, undefined);
    16          A.store.Ref(ptr + 16, undefined);
    17          A.store.Ref(ptr + 20, undefined);
    18          A.store.Ref(ptr + 24, undefined);
    19          A.store.Ref(ptr + 28, undefined);
    20        } else {
    21          A.store.Bool(ptr + 32, true);
    22          A.store.Ref(ptr + 0, x["address"]);
    23          A.store.Ref(ptr + 4, x["broadcastAddress"]);
    24          A.store.Ref(ptr + 8, x["mtu"]);
    25          A.store.Ref(ptr + 12, x["exclusionList"]);
    26          A.store.Ref(ptr + 16, x["inclusionList"]);
    27          A.store.Ref(ptr + 20, x["domainSearch"]);
    28          A.store.Ref(ptr + 24, x["dnsServers"]);
    29          A.store.Ref(ptr + 28, x["reconnect"]);
    30        }
    31      },
    32      "load_Parameters": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
    33        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
    34  
    35        x["address"] = A.load.Ref(ptr + 0, undefined);
    36        x["broadcastAddress"] = A.load.Ref(ptr + 4, undefined);
    37        x["mtu"] = A.load.Ref(ptr + 8, undefined);
    38        x["exclusionList"] = A.load.Ref(ptr + 12, undefined);
    39        x["inclusionList"] = A.load.Ref(ptr + 16, undefined);
    40        x["domainSearch"] = A.load.Ref(ptr + 20, undefined);
    41        x["dnsServers"] = A.load.Ref(ptr + 24, undefined);
    42        x["reconnect"] = A.load.Ref(ptr + 28, undefined);
    43        return create === A.H.TRUE ? A.H.push(x) : ref;
    44      },
    45      "constof_PlatformMessage": (ref: heap.Ref<string>): number => {
    46        const idx = [
    47          "connected",
    48          "disconnected",
    49          "error",
    50          "linkDown",
    51          "linkUp",
    52          "linkChanged",
    53          "suspend",
    54          "resume",
    55        ].indexOf(A.H.get(ref));
    56        return idx < 0 ? 0 : idx + 1;
    57      },
    58      "constof_UIEvent": (ref: heap.Ref<string>): number => {
    59        const idx = ["showAddDialog", "showConfigureDialog"].indexOf(A.H.get(ref));
    60        return idx < 0 ? 0 : idx + 1;
    61      },
    62      "constof_VpnConnectionState": (ref: heap.Ref<string>): number => {
    63        const idx = ["connected", "failure"].indexOf(A.H.get(ref));
    64        return idx < 0 ? 0 : idx + 1;
    65      },
    66      "has_CreateConfig": (): heap.Ref<boolean> => {
    67        if (WEBEXT?.vpnProvider && "createConfig" in WEBEXT?.vpnProvider) {
    68          return A.H.TRUE;
    69        }
    70        return A.H.FALSE;
    71      },
    72      "func_CreateConfig": (fn: Pointer): void => {
    73        A.store.Ref(fn, WEBEXT.vpnProvider.createConfig);
    74      },
    75      "call_CreateConfig": (retPtr: Pointer, name: heap.Ref<object>): void => {
    76        const _ret = WEBEXT.vpnProvider.createConfig(A.H.get<object>(name));
    77        A.store.Ref(retPtr, _ret);
    78      },
    79      "try_CreateConfig": (retPtr: Pointer, errPtr: Pointer, name: heap.Ref<object>): heap.Ref<boolean> => {
    80        try {
    81          const _ret = WEBEXT.vpnProvider.createConfig(A.H.get<object>(name));
    82          A.store.Ref(retPtr, _ret);
    83          return A.H.TRUE;
    84        } catch (err: any) {
    85          A.store.Ref(errPtr, err);
    86          return A.H.FALSE;
    87        }
    88      },
    89      "has_DestroyConfig": (): heap.Ref<boolean> => {
    90        if (WEBEXT?.vpnProvider && "destroyConfig" in WEBEXT?.vpnProvider) {
    91          return A.H.TRUE;
    92        }
    93        return A.H.FALSE;
    94      },
    95      "func_DestroyConfig": (fn: Pointer): void => {
    96        A.store.Ref(fn, WEBEXT.vpnProvider.destroyConfig);
    97      },
    98      "call_DestroyConfig": (retPtr: Pointer, id: heap.Ref<object>): void => {
    99        const _ret = WEBEXT.vpnProvider.destroyConfig(A.H.get<object>(id));
   100        A.store.Ref(retPtr, _ret);
   101      },
   102      "try_DestroyConfig": (retPtr: Pointer, errPtr: Pointer, id: heap.Ref<object>): heap.Ref<boolean> => {
   103        try {
   104          const _ret = WEBEXT.vpnProvider.destroyConfig(A.H.get<object>(id));
   105          A.store.Ref(retPtr, _ret);
   106          return A.H.TRUE;
   107        } catch (err: any) {
   108          A.store.Ref(errPtr, err);
   109          return A.H.FALSE;
   110        }
   111      },
   112      "has_NotifyConnectionStateChanged": (): heap.Ref<boolean> => {
   113        if (WEBEXT?.vpnProvider && "notifyConnectionStateChanged" in WEBEXT?.vpnProvider) {
   114          return A.H.TRUE;
   115        }
   116        return A.H.FALSE;
   117      },
   118      "func_NotifyConnectionStateChanged": (fn: Pointer): void => {
   119        A.store.Ref(fn, WEBEXT.vpnProvider.notifyConnectionStateChanged);
   120      },
   121      "call_NotifyConnectionStateChanged": (retPtr: Pointer, state: number): void => {
   122        const _ret = WEBEXT.vpnProvider.notifyConnectionStateChanged(
   123          state > 0 && state <= 2 ? ["connected", "failure"][state - 1] : undefined
   124        );
   125        A.store.Ref(retPtr, _ret);
   126      },
   127      "try_NotifyConnectionStateChanged": (retPtr: Pointer, errPtr: Pointer, state: number): heap.Ref<boolean> => {
   128        try {
   129          const _ret = WEBEXT.vpnProvider.notifyConnectionStateChanged(
   130            state > 0 && state <= 2 ? ["connected", "failure"][state - 1] : undefined
   131          );
   132          A.store.Ref(retPtr, _ret);
   133          return A.H.TRUE;
   134        } catch (err: any) {
   135          A.store.Ref(errPtr, err);
   136          return A.H.FALSE;
   137        }
   138      },
   139      "has_OnConfigCreated": (): heap.Ref<boolean> => {
   140        if (WEBEXT?.vpnProvider?.onConfigCreated && "addListener" in WEBEXT?.vpnProvider?.onConfigCreated) {
   141          return A.H.TRUE;
   142        }
   143        return A.H.FALSE;
   144      },
   145      "func_OnConfigCreated": (fn: Pointer): void => {
   146        A.store.Ref(fn, WEBEXT.vpnProvider.onConfigCreated.addListener);
   147      },
   148      "call_OnConfigCreated": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   149        const _ret = WEBEXT.vpnProvider.onConfigCreated.addListener(A.H.get<object>(callback));
   150      },
   151      "try_OnConfigCreated": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   152        try {
   153          const _ret = WEBEXT.vpnProvider.onConfigCreated.addListener(A.H.get<object>(callback));
   154          return A.H.TRUE;
   155        } catch (err: any) {
   156          A.store.Ref(errPtr, err);
   157          return A.H.FALSE;
   158        }
   159      },
   160      "has_OffConfigCreated": (): heap.Ref<boolean> => {
   161        if (WEBEXT?.vpnProvider?.onConfigCreated && "removeListener" in WEBEXT?.vpnProvider?.onConfigCreated) {
   162          return A.H.TRUE;
   163        }
   164        return A.H.FALSE;
   165      },
   166      "func_OffConfigCreated": (fn: Pointer): void => {
   167        A.store.Ref(fn, WEBEXT.vpnProvider.onConfigCreated.removeListener);
   168      },
   169      "call_OffConfigCreated": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   170        const _ret = WEBEXT.vpnProvider.onConfigCreated.removeListener(A.H.get<object>(callback));
   171      },
   172      "try_OffConfigCreated": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   173        try {
   174          const _ret = WEBEXT.vpnProvider.onConfigCreated.removeListener(A.H.get<object>(callback));
   175          return A.H.TRUE;
   176        } catch (err: any) {
   177          A.store.Ref(errPtr, err);
   178          return A.H.FALSE;
   179        }
   180      },
   181      "has_HasOnConfigCreated": (): heap.Ref<boolean> => {
   182        if (WEBEXT?.vpnProvider?.onConfigCreated && "hasListener" in WEBEXT?.vpnProvider?.onConfigCreated) {
   183          return A.H.TRUE;
   184        }
   185        return A.H.FALSE;
   186      },
   187      "func_HasOnConfigCreated": (fn: Pointer): void => {
   188        A.store.Ref(fn, WEBEXT.vpnProvider.onConfigCreated.hasListener);
   189      },
   190      "call_HasOnConfigCreated": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   191        const _ret = WEBEXT.vpnProvider.onConfigCreated.hasListener(A.H.get<object>(callback));
   192        A.store.Bool(retPtr, _ret);
   193      },
   194      "try_HasOnConfigCreated": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   195        try {
   196          const _ret = WEBEXT.vpnProvider.onConfigCreated.hasListener(A.H.get<object>(callback));
   197          A.store.Bool(retPtr, _ret);
   198          return A.H.TRUE;
   199        } catch (err: any) {
   200          A.store.Ref(errPtr, err);
   201          return A.H.FALSE;
   202        }
   203      },
   204      "has_OnConfigRemoved": (): heap.Ref<boolean> => {
   205        if (WEBEXT?.vpnProvider?.onConfigRemoved && "addListener" in WEBEXT?.vpnProvider?.onConfigRemoved) {
   206          return A.H.TRUE;
   207        }
   208        return A.H.FALSE;
   209      },
   210      "func_OnConfigRemoved": (fn: Pointer): void => {
   211        A.store.Ref(fn, WEBEXT.vpnProvider.onConfigRemoved.addListener);
   212      },
   213      "call_OnConfigRemoved": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   214        const _ret = WEBEXT.vpnProvider.onConfigRemoved.addListener(A.H.get<object>(callback));
   215      },
   216      "try_OnConfigRemoved": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   217        try {
   218          const _ret = WEBEXT.vpnProvider.onConfigRemoved.addListener(A.H.get<object>(callback));
   219          return A.H.TRUE;
   220        } catch (err: any) {
   221          A.store.Ref(errPtr, err);
   222          return A.H.FALSE;
   223        }
   224      },
   225      "has_OffConfigRemoved": (): heap.Ref<boolean> => {
   226        if (WEBEXT?.vpnProvider?.onConfigRemoved && "removeListener" in WEBEXT?.vpnProvider?.onConfigRemoved) {
   227          return A.H.TRUE;
   228        }
   229        return A.H.FALSE;
   230      },
   231      "func_OffConfigRemoved": (fn: Pointer): void => {
   232        A.store.Ref(fn, WEBEXT.vpnProvider.onConfigRemoved.removeListener);
   233      },
   234      "call_OffConfigRemoved": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   235        const _ret = WEBEXT.vpnProvider.onConfigRemoved.removeListener(A.H.get<object>(callback));
   236      },
   237      "try_OffConfigRemoved": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   238        try {
   239          const _ret = WEBEXT.vpnProvider.onConfigRemoved.removeListener(A.H.get<object>(callback));
   240          return A.H.TRUE;
   241        } catch (err: any) {
   242          A.store.Ref(errPtr, err);
   243          return A.H.FALSE;
   244        }
   245      },
   246      "has_HasOnConfigRemoved": (): heap.Ref<boolean> => {
   247        if (WEBEXT?.vpnProvider?.onConfigRemoved && "hasListener" in WEBEXT?.vpnProvider?.onConfigRemoved) {
   248          return A.H.TRUE;
   249        }
   250        return A.H.FALSE;
   251      },
   252      "func_HasOnConfigRemoved": (fn: Pointer): void => {
   253        A.store.Ref(fn, WEBEXT.vpnProvider.onConfigRemoved.hasListener);
   254      },
   255      "call_HasOnConfigRemoved": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   256        const _ret = WEBEXT.vpnProvider.onConfigRemoved.hasListener(A.H.get<object>(callback));
   257        A.store.Bool(retPtr, _ret);
   258      },
   259      "try_HasOnConfigRemoved": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   260        try {
   261          const _ret = WEBEXT.vpnProvider.onConfigRemoved.hasListener(A.H.get<object>(callback));
   262          A.store.Bool(retPtr, _ret);
   263          return A.H.TRUE;
   264        } catch (err: any) {
   265          A.store.Ref(errPtr, err);
   266          return A.H.FALSE;
   267        }
   268      },
   269      "has_OnPacketReceived": (): heap.Ref<boolean> => {
   270        if (WEBEXT?.vpnProvider?.onPacketReceived && "addListener" in WEBEXT?.vpnProvider?.onPacketReceived) {
   271          return A.H.TRUE;
   272        }
   273        return A.H.FALSE;
   274      },
   275      "func_OnPacketReceived": (fn: Pointer): void => {
   276        A.store.Ref(fn, WEBEXT.vpnProvider.onPacketReceived.addListener);
   277      },
   278      "call_OnPacketReceived": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   279        const _ret = WEBEXT.vpnProvider.onPacketReceived.addListener(A.H.get<object>(callback));
   280      },
   281      "try_OnPacketReceived": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   282        try {
   283          const _ret = WEBEXT.vpnProvider.onPacketReceived.addListener(A.H.get<object>(callback));
   284          return A.H.TRUE;
   285        } catch (err: any) {
   286          A.store.Ref(errPtr, err);
   287          return A.H.FALSE;
   288        }
   289      },
   290      "has_OffPacketReceived": (): heap.Ref<boolean> => {
   291        if (WEBEXT?.vpnProvider?.onPacketReceived && "removeListener" in WEBEXT?.vpnProvider?.onPacketReceived) {
   292          return A.H.TRUE;
   293        }
   294        return A.H.FALSE;
   295      },
   296      "func_OffPacketReceived": (fn: Pointer): void => {
   297        A.store.Ref(fn, WEBEXT.vpnProvider.onPacketReceived.removeListener);
   298      },
   299      "call_OffPacketReceived": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   300        const _ret = WEBEXT.vpnProvider.onPacketReceived.removeListener(A.H.get<object>(callback));
   301      },
   302      "try_OffPacketReceived": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   303        try {
   304          const _ret = WEBEXT.vpnProvider.onPacketReceived.removeListener(A.H.get<object>(callback));
   305          return A.H.TRUE;
   306        } catch (err: any) {
   307          A.store.Ref(errPtr, err);
   308          return A.H.FALSE;
   309        }
   310      },
   311      "has_HasOnPacketReceived": (): heap.Ref<boolean> => {
   312        if (WEBEXT?.vpnProvider?.onPacketReceived && "hasListener" in WEBEXT?.vpnProvider?.onPacketReceived) {
   313          return A.H.TRUE;
   314        }
   315        return A.H.FALSE;
   316      },
   317      "func_HasOnPacketReceived": (fn: Pointer): void => {
   318        A.store.Ref(fn, WEBEXT.vpnProvider.onPacketReceived.hasListener);
   319      },
   320      "call_HasOnPacketReceived": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   321        const _ret = WEBEXT.vpnProvider.onPacketReceived.hasListener(A.H.get<object>(callback));
   322        A.store.Bool(retPtr, _ret);
   323      },
   324      "try_HasOnPacketReceived": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   325        try {
   326          const _ret = WEBEXT.vpnProvider.onPacketReceived.hasListener(A.H.get<object>(callback));
   327          A.store.Bool(retPtr, _ret);
   328          return A.H.TRUE;
   329        } catch (err: any) {
   330          A.store.Ref(errPtr, err);
   331          return A.H.FALSE;
   332        }
   333      },
   334      "has_OnPlatformMessage": (): heap.Ref<boolean> => {
   335        if (WEBEXT?.vpnProvider?.onPlatformMessage && "addListener" in WEBEXT?.vpnProvider?.onPlatformMessage) {
   336          return A.H.TRUE;
   337        }
   338        return A.H.FALSE;
   339      },
   340      "func_OnPlatformMessage": (fn: Pointer): void => {
   341        A.store.Ref(fn, WEBEXT.vpnProvider.onPlatformMessage.addListener);
   342      },
   343      "call_OnPlatformMessage": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   344        const _ret = WEBEXT.vpnProvider.onPlatformMessage.addListener(A.H.get<object>(callback));
   345      },
   346      "try_OnPlatformMessage": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   347        try {
   348          const _ret = WEBEXT.vpnProvider.onPlatformMessage.addListener(A.H.get<object>(callback));
   349          return A.H.TRUE;
   350        } catch (err: any) {
   351          A.store.Ref(errPtr, err);
   352          return A.H.FALSE;
   353        }
   354      },
   355      "has_OffPlatformMessage": (): heap.Ref<boolean> => {
   356        if (WEBEXT?.vpnProvider?.onPlatformMessage && "removeListener" in WEBEXT?.vpnProvider?.onPlatformMessage) {
   357          return A.H.TRUE;
   358        }
   359        return A.H.FALSE;
   360      },
   361      "func_OffPlatformMessage": (fn: Pointer): void => {
   362        A.store.Ref(fn, WEBEXT.vpnProvider.onPlatformMessage.removeListener);
   363      },
   364      "call_OffPlatformMessage": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   365        const _ret = WEBEXT.vpnProvider.onPlatformMessage.removeListener(A.H.get<object>(callback));
   366      },
   367      "try_OffPlatformMessage": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   368        try {
   369          const _ret = WEBEXT.vpnProvider.onPlatformMessage.removeListener(A.H.get<object>(callback));
   370          return A.H.TRUE;
   371        } catch (err: any) {
   372          A.store.Ref(errPtr, err);
   373          return A.H.FALSE;
   374        }
   375      },
   376      "has_HasOnPlatformMessage": (): heap.Ref<boolean> => {
   377        if (WEBEXT?.vpnProvider?.onPlatformMessage && "hasListener" in WEBEXT?.vpnProvider?.onPlatformMessage) {
   378          return A.H.TRUE;
   379        }
   380        return A.H.FALSE;
   381      },
   382      "func_HasOnPlatformMessage": (fn: Pointer): void => {
   383        A.store.Ref(fn, WEBEXT.vpnProvider.onPlatformMessage.hasListener);
   384      },
   385      "call_HasOnPlatformMessage": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   386        const _ret = WEBEXT.vpnProvider.onPlatformMessage.hasListener(A.H.get<object>(callback));
   387        A.store.Bool(retPtr, _ret);
   388      },
   389      "try_HasOnPlatformMessage": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   390        try {
   391          const _ret = WEBEXT.vpnProvider.onPlatformMessage.hasListener(A.H.get<object>(callback));
   392          A.store.Bool(retPtr, _ret);
   393          return A.H.TRUE;
   394        } catch (err: any) {
   395          A.store.Ref(errPtr, err);
   396          return A.H.FALSE;
   397        }
   398      },
   399      "has_OnUIEvent": (): heap.Ref<boolean> => {
   400        if (WEBEXT?.vpnProvider?.onUIEvent && "addListener" in WEBEXT?.vpnProvider?.onUIEvent) {
   401          return A.H.TRUE;
   402        }
   403        return A.H.FALSE;
   404      },
   405      "func_OnUIEvent": (fn: Pointer): void => {
   406        A.store.Ref(fn, WEBEXT.vpnProvider.onUIEvent.addListener);
   407      },
   408      "call_OnUIEvent": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   409        const _ret = WEBEXT.vpnProvider.onUIEvent.addListener(A.H.get<object>(callback));
   410      },
   411      "try_OnUIEvent": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   412        try {
   413          const _ret = WEBEXT.vpnProvider.onUIEvent.addListener(A.H.get<object>(callback));
   414          return A.H.TRUE;
   415        } catch (err: any) {
   416          A.store.Ref(errPtr, err);
   417          return A.H.FALSE;
   418        }
   419      },
   420      "has_OffUIEvent": (): heap.Ref<boolean> => {
   421        if (WEBEXT?.vpnProvider?.onUIEvent && "removeListener" in WEBEXT?.vpnProvider?.onUIEvent) {
   422          return A.H.TRUE;
   423        }
   424        return A.H.FALSE;
   425      },
   426      "func_OffUIEvent": (fn: Pointer): void => {
   427        A.store.Ref(fn, WEBEXT.vpnProvider.onUIEvent.removeListener);
   428      },
   429      "call_OffUIEvent": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   430        const _ret = WEBEXT.vpnProvider.onUIEvent.removeListener(A.H.get<object>(callback));
   431      },
   432      "try_OffUIEvent": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   433        try {
   434          const _ret = WEBEXT.vpnProvider.onUIEvent.removeListener(A.H.get<object>(callback));
   435          return A.H.TRUE;
   436        } catch (err: any) {
   437          A.store.Ref(errPtr, err);
   438          return A.H.FALSE;
   439        }
   440      },
   441      "has_HasOnUIEvent": (): heap.Ref<boolean> => {
   442        if (WEBEXT?.vpnProvider?.onUIEvent && "hasListener" in WEBEXT?.vpnProvider?.onUIEvent) {
   443          return A.H.TRUE;
   444        }
   445        return A.H.FALSE;
   446      },
   447      "func_HasOnUIEvent": (fn: Pointer): void => {
   448        A.store.Ref(fn, WEBEXT.vpnProvider.onUIEvent.hasListener);
   449      },
   450      "call_HasOnUIEvent": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   451        const _ret = WEBEXT.vpnProvider.onUIEvent.hasListener(A.H.get<object>(callback));
   452        A.store.Bool(retPtr, _ret);
   453      },
   454      "try_HasOnUIEvent": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   455        try {
   456          const _ret = WEBEXT.vpnProvider.onUIEvent.hasListener(A.H.get<object>(callback));
   457          A.store.Bool(retPtr, _ret);
   458          return A.H.TRUE;
   459        } catch (err: any) {
   460          A.store.Ref(errPtr, err);
   461          return A.H.FALSE;
   462        }
   463      },
   464      "has_SendPacket": (): heap.Ref<boolean> => {
   465        if (WEBEXT?.vpnProvider && "sendPacket" in WEBEXT?.vpnProvider) {
   466          return A.H.TRUE;
   467        }
   468        return A.H.FALSE;
   469      },
   470      "func_SendPacket": (fn: Pointer): void => {
   471        A.store.Ref(fn, WEBEXT.vpnProvider.sendPacket);
   472      },
   473      "call_SendPacket": (retPtr: Pointer, data: heap.Ref<object>): void => {
   474        const _ret = WEBEXT.vpnProvider.sendPacket(A.H.get<object>(data));
   475        A.store.Ref(retPtr, _ret);
   476      },
   477      "try_SendPacket": (retPtr: Pointer, errPtr: Pointer, data: heap.Ref<object>): heap.Ref<boolean> => {
   478        try {
   479          const _ret = WEBEXT.vpnProvider.sendPacket(A.H.get<object>(data));
   480          A.store.Ref(retPtr, _ret);
   481          return A.H.TRUE;
   482        } catch (err: any) {
   483          A.store.Ref(errPtr, err);
   484          return A.H.FALSE;
   485        }
   486      },
   487      "has_SetParameters": (): heap.Ref<boolean> => {
   488        if (WEBEXT?.vpnProvider && "setParameters" in WEBEXT?.vpnProvider) {
   489          return A.H.TRUE;
   490        }
   491        return A.H.FALSE;
   492      },
   493      "func_SetParameters": (fn: Pointer): void => {
   494        A.store.Ref(fn, WEBEXT.vpnProvider.setParameters);
   495      },
   496      "call_SetParameters": (retPtr: Pointer, parameters: Pointer): void => {
   497        const parameters_ffi = {};
   498  
   499        parameters_ffi["address"] = A.load.Ref(parameters + 0, undefined);
   500        parameters_ffi["broadcastAddress"] = A.load.Ref(parameters + 4, undefined);
   501        parameters_ffi["mtu"] = A.load.Ref(parameters + 8, undefined);
   502        parameters_ffi["exclusionList"] = A.load.Ref(parameters + 12, undefined);
   503        parameters_ffi["inclusionList"] = A.load.Ref(parameters + 16, undefined);
   504        parameters_ffi["domainSearch"] = A.load.Ref(parameters + 20, undefined);
   505        parameters_ffi["dnsServers"] = A.load.Ref(parameters + 24, undefined);
   506        parameters_ffi["reconnect"] = A.load.Ref(parameters + 28, undefined);
   507  
   508        const _ret = WEBEXT.vpnProvider.setParameters(parameters_ffi);
   509        A.store.Ref(retPtr, _ret);
   510      },
   511      "try_SetParameters": (retPtr: Pointer, errPtr: Pointer, parameters: Pointer): heap.Ref<boolean> => {
   512        try {
   513          const parameters_ffi = {};
   514  
   515          parameters_ffi["address"] = A.load.Ref(parameters + 0, undefined);
   516          parameters_ffi["broadcastAddress"] = A.load.Ref(parameters + 4, undefined);
   517          parameters_ffi["mtu"] = A.load.Ref(parameters + 8, undefined);
   518          parameters_ffi["exclusionList"] = A.load.Ref(parameters + 12, undefined);
   519          parameters_ffi["inclusionList"] = A.load.Ref(parameters + 16, undefined);
   520          parameters_ffi["domainSearch"] = A.load.Ref(parameters + 20, undefined);
   521          parameters_ffi["dnsServers"] = A.load.Ref(parameters + 24, undefined);
   522          parameters_ffi["reconnect"] = A.load.Ref(parameters + 28, undefined);
   523  
   524          const _ret = WEBEXT.vpnProvider.setParameters(parameters_ffi);
   525          A.store.Ref(retPtr, _ret);
   526          return A.H.TRUE;
   527        } catch (err: any) {
   528          A.store.Ref(errPtr, err);
   529          return A.H.FALSE;
   530        }
   531      },
   532    };
   533  });