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

     1  import { importModule, Application, heap, Pointer } from "@ffi";
     2  
     3  importModule("plat/js/webext/sockets/tcp", (A: Application) => {
     4    const WEBEXT = typeof globalThis.browser === "undefined" ? globalThis.chrome : globalThis.browser;
     5  
     6    return {
     7      "store_CreateInfo": (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 + 5, false);
    12          A.store.Bool(ptr + 4, false);
    13          A.store.Int32(ptr + 0, 0);
    14        } else {
    15          A.store.Bool(ptr + 5, true);
    16          A.store.Bool(ptr + 4, "socketId" in x ? true : false);
    17          A.store.Int32(ptr + 0, x["socketId"] === undefined ? 0 : (x["socketId"] as number));
    18        }
    19      },
    20      "load_CreateInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
    21        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
    22  
    23        if (A.load.Bool(ptr + 4)) {
    24          x["socketId"] = A.load.Int32(ptr + 0);
    25        } else {
    26          delete x["socketId"];
    27        }
    28        return create === A.H.TRUE ? A.H.push(x) : ref;
    29      },
    30      "constof_DnsQueryType": (ref: heap.Ref<string>): number => {
    31        const idx = ["any", "ipv4", "ipv6"].indexOf(A.H.get(ref));
    32        return idx < 0 ? 0 : idx + 1;
    33      },
    34  
    35      "store_SocketInfo": (ptr: Pointer, ref: heap.Ref<any>) => {
    36        const x = A.H.get<any>(ref);
    37  
    38        if (typeof x === "undefined") {
    39          A.store.Bool(ptr + 43, false);
    40          A.store.Bool(ptr + 36, false);
    41          A.store.Int32(ptr + 0, 0);
    42          A.store.Bool(ptr + 37, false);
    43          A.store.Bool(ptr + 4, false);
    44          A.store.Ref(ptr + 8, undefined);
    45          A.store.Bool(ptr + 38, false);
    46          A.store.Int32(ptr + 12, 0);
    47          A.store.Bool(ptr + 39, false);
    48          A.store.Bool(ptr + 16, false);
    49          A.store.Bool(ptr + 40, false);
    50          A.store.Bool(ptr + 17, false);
    51          A.store.Ref(ptr + 20, undefined);
    52          A.store.Bool(ptr + 41, false);
    53          A.store.Int32(ptr + 24, 0);
    54          A.store.Ref(ptr + 28, undefined);
    55          A.store.Bool(ptr + 42, false);
    56          A.store.Int32(ptr + 32, 0);
    57        } else {
    58          A.store.Bool(ptr + 43, true);
    59          A.store.Bool(ptr + 36, "socketId" in x ? true : false);
    60          A.store.Int32(ptr + 0, x["socketId"] === undefined ? 0 : (x["socketId"] as number));
    61          A.store.Bool(ptr + 37, "persistent" in x ? true : false);
    62          A.store.Bool(ptr + 4, x["persistent"] ? true : false);
    63          A.store.Ref(ptr + 8, x["name"]);
    64          A.store.Bool(ptr + 38, "bufferSize" in x ? true : false);
    65          A.store.Int32(ptr + 12, x["bufferSize"] === undefined ? 0 : (x["bufferSize"] as number));
    66          A.store.Bool(ptr + 39, "paused" in x ? true : false);
    67          A.store.Bool(ptr + 16, x["paused"] ? true : false);
    68          A.store.Bool(ptr + 40, "connected" in x ? true : false);
    69          A.store.Bool(ptr + 17, x["connected"] ? true : false);
    70          A.store.Ref(ptr + 20, x["localAddress"]);
    71          A.store.Bool(ptr + 41, "localPort" in x ? true : false);
    72          A.store.Int32(ptr + 24, x["localPort"] === undefined ? 0 : (x["localPort"] as number));
    73          A.store.Ref(ptr + 28, x["peerAddress"]);
    74          A.store.Bool(ptr + 42, "peerPort" in x ? true : false);
    75          A.store.Int32(ptr + 32, x["peerPort"] === undefined ? 0 : (x["peerPort"] as number));
    76        }
    77      },
    78      "load_SocketInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
    79        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
    80  
    81        if (A.load.Bool(ptr + 36)) {
    82          x["socketId"] = A.load.Int32(ptr + 0);
    83        } else {
    84          delete x["socketId"];
    85        }
    86        if (A.load.Bool(ptr + 37)) {
    87          x["persistent"] = A.load.Bool(ptr + 4);
    88        } else {
    89          delete x["persistent"];
    90        }
    91        x["name"] = A.load.Ref(ptr + 8, undefined);
    92        if (A.load.Bool(ptr + 38)) {
    93          x["bufferSize"] = A.load.Int32(ptr + 12);
    94        } else {
    95          delete x["bufferSize"];
    96        }
    97        if (A.load.Bool(ptr + 39)) {
    98          x["paused"] = A.load.Bool(ptr + 16);
    99        } else {
   100          delete x["paused"];
   101        }
   102        if (A.load.Bool(ptr + 40)) {
   103          x["connected"] = A.load.Bool(ptr + 17);
   104        } else {
   105          delete x["connected"];
   106        }
   107        x["localAddress"] = A.load.Ref(ptr + 20, undefined);
   108        if (A.load.Bool(ptr + 41)) {
   109          x["localPort"] = A.load.Int32(ptr + 24);
   110        } else {
   111          delete x["localPort"];
   112        }
   113        x["peerAddress"] = A.load.Ref(ptr + 28, undefined);
   114        if (A.load.Bool(ptr + 42)) {
   115          x["peerPort"] = A.load.Int32(ptr + 32);
   116        } else {
   117          delete x["peerPort"];
   118        }
   119        return create === A.H.TRUE ? A.H.push(x) : ref;
   120      },
   121  
   122      "store_ReceiveErrorInfo": (ptr: Pointer, ref: heap.Ref<any>) => {
   123        const x = A.H.get<any>(ref);
   124  
   125        if (typeof x === "undefined") {
   126          A.store.Bool(ptr + 10, false);
   127          A.store.Bool(ptr + 8, false);
   128          A.store.Int32(ptr + 0, 0);
   129          A.store.Bool(ptr + 9, false);
   130          A.store.Int32(ptr + 4, 0);
   131        } else {
   132          A.store.Bool(ptr + 10, true);
   133          A.store.Bool(ptr + 8, "socketId" in x ? true : false);
   134          A.store.Int32(ptr + 0, x["socketId"] === undefined ? 0 : (x["socketId"] as number));
   135          A.store.Bool(ptr + 9, "resultCode" in x ? true : false);
   136          A.store.Int32(ptr + 4, x["resultCode"] === undefined ? 0 : (x["resultCode"] as number));
   137        }
   138      },
   139      "load_ReceiveErrorInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   140        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   141  
   142        if (A.load.Bool(ptr + 8)) {
   143          x["socketId"] = A.load.Int32(ptr + 0);
   144        } else {
   145          delete x["socketId"];
   146        }
   147        if (A.load.Bool(ptr + 9)) {
   148          x["resultCode"] = A.load.Int32(ptr + 4);
   149        } else {
   150          delete x["resultCode"];
   151        }
   152        return create === A.H.TRUE ? A.H.push(x) : ref;
   153      },
   154  
   155      "store_ReceiveInfo": (ptr: Pointer, ref: heap.Ref<any>) => {
   156        const x = A.H.get<any>(ref);
   157  
   158        if (typeof x === "undefined") {
   159          A.store.Bool(ptr + 9, false);
   160          A.store.Bool(ptr + 8, false);
   161          A.store.Int32(ptr + 0, 0);
   162          A.store.Ref(ptr + 4, undefined);
   163        } else {
   164          A.store.Bool(ptr + 9, true);
   165          A.store.Bool(ptr + 8, "socketId" in x ? true : false);
   166          A.store.Int32(ptr + 0, x["socketId"] === undefined ? 0 : (x["socketId"] as number));
   167          A.store.Ref(ptr + 4, x["data"]);
   168        }
   169      },
   170      "load_ReceiveInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   171        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   172  
   173        if (A.load.Bool(ptr + 8)) {
   174          x["socketId"] = A.load.Int32(ptr + 0);
   175        } else {
   176          delete x["socketId"];
   177        }
   178        x["data"] = A.load.Ref(ptr + 4, undefined);
   179        return create === A.H.TRUE ? A.H.push(x) : ref;
   180      },
   181  
   182      "store_TLSVersionConstraints": (ptr: Pointer, ref: heap.Ref<any>) => {
   183        const x = A.H.get<any>(ref);
   184  
   185        if (typeof x === "undefined") {
   186          A.store.Bool(ptr + 8, false);
   187          A.store.Ref(ptr + 0, undefined);
   188          A.store.Ref(ptr + 4, undefined);
   189        } else {
   190          A.store.Bool(ptr + 8, true);
   191          A.store.Ref(ptr + 0, x["min"]);
   192          A.store.Ref(ptr + 4, x["max"]);
   193        }
   194      },
   195      "load_TLSVersionConstraints": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   196        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   197  
   198        x["min"] = A.load.Ref(ptr + 0, undefined);
   199        x["max"] = A.load.Ref(ptr + 4, undefined);
   200        return create === A.H.TRUE ? A.H.push(x) : ref;
   201      },
   202  
   203      "store_SecureOptions": (ptr: Pointer, ref: heap.Ref<any>) => {
   204        const x = A.H.get<any>(ref);
   205  
   206        if (typeof x === "undefined") {
   207          A.store.Bool(ptr + 9, false);
   208  
   209          A.store.Bool(ptr + 0 + 8, false);
   210          A.store.Ref(ptr + 0 + 0, undefined);
   211          A.store.Ref(ptr + 0 + 4, undefined);
   212        } else {
   213          A.store.Bool(ptr + 9, true);
   214  
   215          if (typeof x["tlsVersion"] === "undefined") {
   216            A.store.Bool(ptr + 0 + 8, false);
   217            A.store.Ref(ptr + 0 + 0, undefined);
   218            A.store.Ref(ptr + 0 + 4, undefined);
   219          } else {
   220            A.store.Bool(ptr + 0 + 8, true);
   221            A.store.Ref(ptr + 0 + 0, x["tlsVersion"]["min"]);
   222            A.store.Ref(ptr + 0 + 4, x["tlsVersion"]["max"]);
   223          }
   224        }
   225      },
   226      "load_SecureOptions": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   227        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   228  
   229        if (A.load.Bool(ptr + 0 + 8)) {
   230          x["tlsVersion"] = {};
   231          x["tlsVersion"]["min"] = A.load.Ref(ptr + 0 + 0, undefined);
   232          x["tlsVersion"]["max"] = A.load.Ref(ptr + 0 + 4, undefined);
   233        } else {
   234          delete x["tlsVersion"];
   235        }
   236        return create === A.H.TRUE ? A.H.push(x) : ref;
   237      },
   238  
   239      "store_SendInfo": (ptr: Pointer, ref: heap.Ref<any>) => {
   240        const x = A.H.get<any>(ref);
   241  
   242        if (typeof x === "undefined") {
   243          A.store.Bool(ptr + 10, false);
   244          A.store.Bool(ptr + 8, false);
   245          A.store.Int32(ptr + 0, 0);
   246          A.store.Bool(ptr + 9, false);
   247          A.store.Int32(ptr + 4, 0);
   248        } else {
   249          A.store.Bool(ptr + 10, true);
   250          A.store.Bool(ptr + 8, "resultCode" in x ? true : false);
   251          A.store.Int32(ptr + 0, x["resultCode"] === undefined ? 0 : (x["resultCode"] as number));
   252          A.store.Bool(ptr + 9, "bytesSent" in x ? true : false);
   253          A.store.Int32(ptr + 4, x["bytesSent"] === undefined ? 0 : (x["bytesSent"] as number));
   254        }
   255      },
   256      "load_SendInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   257        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   258  
   259        if (A.load.Bool(ptr + 8)) {
   260          x["resultCode"] = A.load.Int32(ptr + 0);
   261        } else {
   262          delete x["resultCode"];
   263        }
   264        if (A.load.Bool(ptr + 9)) {
   265          x["bytesSent"] = A.load.Int32(ptr + 4);
   266        } else {
   267          delete x["bytesSent"];
   268        }
   269        return create === A.H.TRUE ? A.H.push(x) : ref;
   270      },
   271  
   272      "store_SocketProperties": (ptr: Pointer, ref: heap.Ref<any>) => {
   273        const x = A.H.get<any>(ref);
   274  
   275        if (typeof x === "undefined") {
   276          A.store.Bool(ptr + 14, false);
   277          A.store.Bool(ptr + 12, false);
   278          A.store.Bool(ptr + 0, false);
   279          A.store.Ref(ptr + 4, undefined);
   280          A.store.Bool(ptr + 13, false);
   281          A.store.Int32(ptr + 8, 0);
   282        } else {
   283          A.store.Bool(ptr + 14, true);
   284          A.store.Bool(ptr + 12, "persistent" in x ? true : false);
   285          A.store.Bool(ptr + 0, x["persistent"] ? true : false);
   286          A.store.Ref(ptr + 4, x["name"]);
   287          A.store.Bool(ptr + 13, "bufferSize" in x ? true : false);
   288          A.store.Int32(ptr + 8, x["bufferSize"] === undefined ? 0 : (x["bufferSize"] as number));
   289        }
   290      },
   291      "load_SocketProperties": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   292        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   293  
   294        if (A.load.Bool(ptr + 12)) {
   295          x["persistent"] = A.load.Bool(ptr + 0);
   296        } else {
   297          delete x["persistent"];
   298        }
   299        x["name"] = A.load.Ref(ptr + 4, undefined);
   300        if (A.load.Bool(ptr + 13)) {
   301          x["bufferSize"] = A.load.Int32(ptr + 8);
   302        } else {
   303          delete x["bufferSize"];
   304        }
   305        return create === A.H.TRUE ? A.H.push(x) : ref;
   306      },
   307      "has_Close": (): heap.Ref<boolean> => {
   308        if (WEBEXT?.sockets?.tcp && "close" in WEBEXT?.sockets?.tcp) {
   309          return A.H.TRUE;
   310        }
   311        return A.H.FALSE;
   312      },
   313      "func_Close": (fn: Pointer): void => {
   314        A.store.Ref(fn, WEBEXT.sockets.tcp.close);
   315      },
   316      "call_Close": (retPtr: Pointer, socketId: number, callback: heap.Ref<object>): void => {
   317        const _ret = WEBEXT.sockets.tcp.close(socketId, A.H.get<object>(callback));
   318      },
   319      "try_Close": (
   320        retPtr: Pointer,
   321        errPtr: Pointer,
   322        socketId: number,
   323        callback: heap.Ref<object>
   324      ): heap.Ref<boolean> => {
   325        try {
   326          const _ret = WEBEXT.sockets.tcp.close(socketId, A.H.get<object>(callback));
   327          return A.H.TRUE;
   328        } catch (err: any) {
   329          A.store.Ref(errPtr, err);
   330          return A.H.FALSE;
   331        }
   332      },
   333      "has_Connect": (): heap.Ref<boolean> => {
   334        if (WEBEXT?.sockets?.tcp && "connect" in WEBEXT?.sockets?.tcp) {
   335          return A.H.TRUE;
   336        }
   337        return A.H.FALSE;
   338      },
   339      "func_Connect": (fn: Pointer): void => {
   340        A.store.Ref(fn, WEBEXT.sockets.tcp.connect);
   341      },
   342      "call_Connect": (
   343        retPtr: Pointer,
   344        socketId: number,
   345        peerAddress: heap.Ref<object>,
   346        peerPort: number,
   347        dnsQueryType: number,
   348        callback: heap.Ref<object>
   349      ): void => {
   350        const _ret = WEBEXT.sockets.tcp.connect(
   351          socketId,
   352          A.H.get<object>(peerAddress),
   353          peerPort,
   354          dnsQueryType > 0 && dnsQueryType <= 3 ? ["any", "ipv4", "ipv6"][dnsQueryType - 1] : undefined,
   355          A.H.get<object>(callback)
   356        );
   357      },
   358      "try_Connect": (
   359        retPtr: Pointer,
   360        errPtr: Pointer,
   361        socketId: number,
   362        peerAddress: heap.Ref<object>,
   363        peerPort: number,
   364        dnsQueryType: number,
   365        callback: heap.Ref<object>
   366      ): heap.Ref<boolean> => {
   367        try {
   368          const _ret = WEBEXT.sockets.tcp.connect(
   369            socketId,
   370            A.H.get<object>(peerAddress),
   371            peerPort,
   372            dnsQueryType > 0 && dnsQueryType <= 3 ? ["any", "ipv4", "ipv6"][dnsQueryType - 1] : undefined,
   373            A.H.get<object>(callback)
   374          );
   375          return A.H.TRUE;
   376        } catch (err: any) {
   377          A.store.Ref(errPtr, err);
   378          return A.H.FALSE;
   379        }
   380      },
   381      "has_Create": (): heap.Ref<boolean> => {
   382        if (WEBEXT?.sockets?.tcp && "create" in WEBEXT?.sockets?.tcp) {
   383          return A.H.TRUE;
   384        }
   385        return A.H.FALSE;
   386      },
   387      "func_Create": (fn: Pointer): void => {
   388        A.store.Ref(fn, WEBEXT.sockets.tcp.create);
   389      },
   390      "call_Create": (retPtr: Pointer, properties: Pointer, callback: heap.Ref<object>): void => {
   391        const properties_ffi = {};
   392  
   393        if (A.load.Bool(properties + 12)) {
   394          properties_ffi["persistent"] = A.load.Bool(properties + 0);
   395        }
   396        properties_ffi["name"] = A.load.Ref(properties + 4, undefined);
   397        if (A.load.Bool(properties + 13)) {
   398          properties_ffi["bufferSize"] = A.load.Int32(properties + 8);
   399        }
   400  
   401        const _ret = WEBEXT.sockets.tcp.create(properties_ffi, A.H.get<object>(callback));
   402      },
   403      "try_Create": (
   404        retPtr: Pointer,
   405        errPtr: Pointer,
   406        properties: Pointer,
   407        callback: heap.Ref<object>
   408      ): heap.Ref<boolean> => {
   409        try {
   410          const properties_ffi = {};
   411  
   412          if (A.load.Bool(properties + 12)) {
   413            properties_ffi["persistent"] = A.load.Bool(properties + 0);
   414          }
   415          properties_ffi["name"] = A.load.Ref(properties + 4, undefined);
   416          if (A.load.Bool(properties + 13)) {
   417            properties_ffi["bufferSize"] = A.load.Int32(properties + 8);
   418          }
   419  
   420          const _ret = WEBEXT.sockets.tcp.create(properties_ffi, A.H.get<object>(callback));
   421          return A.H.TRUE;
   422        } catch (err: any) {
   423          A.store.Ref(errPtr, err);
   424          return A.H.FALSE;
   425        }
   426      },
   427      "has_Disconnect": (): heap.Ref<boolean> => {
   428        if (WEBEXT?.sockets?.tcp && "disconnect" in WEBEXT?.sockets?.tcp) {
   429          return A.H.TRUE;
   430        }
   431        return A.H.FALSE;
   432      },
   433      "func_Disconnect": (fn: Pointer): void => {
   434        A.store.Ref(fn, WEBEXT.sockets.tcp.disconnect);
   435      },
   436      "call_Disconnect": (retPtr: Pointer, socketId: number, callback: heap.Ref<object>): void => {
   437        const _ret = WEBEXT.sockets.tcp.disconnect(socketId, A.H.get<object>(callback));
   438      },
   439      "try_Disconnect": (
   440        retPtr: Pointer,
   441        errPtr: Pointer,
   442        socketId: number,
   443        callback: heap.Ref<object>
   444      ): heap.Ref<boolean> => {
   445        try {
   446          const _ret = WEBEXT.sockets.tcp.disconnect(socketId, A.H.get<object>(callback));
   447          return A.H.TRUE;
   448        } catch (err: any) {
   449          A.store.Ref(errPtr, err);
   450          return A.H.FALSE;
   451        }
   452      },
   453      "has_GetInfo": (): heap.Ref<boolean> => {
   454        if (WEBEXT?.sockets?.tcp && "getInfo" in WEBEXT?.sockets?.tcp) {
   455          return A.H.TRUE;
   456        }
   457        return A.H.FALSE;
   458      },
   459      "func_GetInfo": (fn: Pointer): void => {
   460        A.store.Ref(fn, WEBEXT.sockets.tcp.getInfo);
   461      },
   462      "call_GetInfo": (retPtr: Pointer, socketId: number, callback: heap.Ref<object>): void => {
   463        const _ret = WEBEXT.sockets.tcp.getInfo(socketId, A.H.get<object>(callback));
   464      },
   465      "try_GetInfo": (
   466        retPtr: Pointer,
   467        errPtr: Pointer,
   468        socketId: number,
   469        callback: heap.Ref<object>
   470      ): heap.Ref<boolean> => {
   471        try {
   472          const _ret = WEBEXT.sockets.tcp.getInfo(socketId, A.H.get<object>(callback));
   473          return A.H.TRUE;
   474        } catch (err: any) {
   475          A.store.Ref(errPtr, err);
   476          return A.H.FALSE;
   477        }
   478      },
   479      "has_GetSockets": (): heap.Ref<boolean> => {
   480        if (WEBEXT?.sockets?.tcp && "getSockets" in WEBEXT?.sockets?.tcp) {
   481          return A.H.TRUE;
   482        }
   483        return A.H.FALSE;
   484      },
   485      "func_GetSockets": (fn: Pointer): void => {
   486        A.store.Ref(fn, WEBEXT.sockets.tcp.getSockets);
   487      },
   488      "call_GetSockets": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   489        const _ret = WEBEXT.sockets.tcp.getSockets(A.H.get<object>(callback));
   490      },
   491      "try_GetSockets": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   492        try {
   493          const _ret = WEBEXT.sockets.tcp.getSockets(A.H.get<object>(callback));
   494          return A.H.TRUE;
   495        } catch (err: any) {
   496          A.store.Ref(errPtr, err);
   497          return A.H.FALSE;
   498        }
   499      },
   500      "has_OnReceive": (): heap.Ref<boolean> => {
   501        if (WEBEXT?.sockets?.tcp?.onReceive && "addListener" in WEBEXT?.sockets?.tcp?.onReceive) {
   502          return A.H.TRUE;
   503        }
   504        return A.H.FALSE;
   505      },
   506      "func_OnReceive": (fn: Pointer): void => {
   507        A.store.Ref(fn, WEBEXT.sockets.tcp.onReceive.addListener);
   508      },
   509      "call_OnReceive": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   510        const _ret = WEBEXT.sockets.tcp.onReceive.addListener(A.H.get<object>(callback));
   511      },
   512      "try_OnReceive": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   513        try {
   514          const _ret = WEBEXT.sockets.tcp.onReceive.addListener(A.H.get<object>(callback));
   515          return A.H.TRUE;
   516        } catch (err: any) {
   517          A.store.Ref(errPtr, err);
   518          return A.H.FALSE;
   519        }
   520      },
   521      "has_OffReceive": (): heap.Ref<boolean> => {
   522        if (WEBEXT?.sockets?.tcp?.onReceive && "removeListener" in WEBEXT?.sockets?.tcp?.onReceive) {
   523          return A.H.TRUE;
   524        }
   525        return A.H.FALSE;
   526      },
   527      "func_OffReceive": (fn: Pointer): void => {
   528        A.store.Ref(fn, WEBEXT.sockets.tcp.onReceive.removeListener);
   529      },
   530      "call_OffReceive": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   531        const _ret = WEBEXT.sockets.tcp.onReceive.removeListener(A.H.get<object>(callback));
   532      },
   533      "try_OffReceive": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   534        try {
   535          const _ret = WEBEXT.sockets.tcp.onReceive.removeListener(A.H.get<object>(callback));
   536          return A.H.TRUE;
   537        } catch (err: any) {
   538          A.store.Ref(errPtr, err);
   539          return A.H.FALSE;
   540        }
   541      },
   542      "has_HasOnReceive": (): heap.Ref<boolean> => {
   543        if (WEBEXT?.sockets?.tcp?.onReceive && "hasListener" in WEBEXT?.sockets?.tcp?.onReceive) {
   544          return A.H.TRUE;
   545        }
   546        return A.H.FALSE;
   547      },
   548      "func_HasOnReceive": (fn: Pointer): void => {
   549        A.store.Ref(fn, WEBEXT.sockets.tcp.onReceive.hasListener);
   550      },
   551      "call_HasOnReceive": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   552        const _ret = WEBEXT.sockets.tcp.onReceive.hasListener(A.H.get<object>(callback));
   553        A.store.Bool(retPtr, _ret);
   554      },
   555      "try_HasOnReceive": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   556        try {
   557          const _ret = WEBEXT.sockets.tcp.onReceive.hasListener(A.H.get<object>(callback));
   558          A.store.Bool(retPtr, _ret);
   559          return A.H.TRUE;
   560        } catch (err: any) {
   561          A.store.Ref(errPtr, err);
   562          return A.H.FALSE;
   563        }
   564      },
   565      "has_OnReceiveError": (): heap.Ref<boolean> => {
   566        if (WEBEXT?.sockets?.tcp?.onReceiveError && "addListener" in WEBEXT?.sockets?.tcp?.onReceiveError) {
   567          return A.H.TRUE;
   568        }
   569        return A.H.FALSE;
   570      },
   571      "func_OnReceiveError": (fn: Pointer): void => {
   572        A.store.Ref(fn, WEBEXT.sockets.tcp.onReceiveError.addListener);
   573      },
   574      "call_OnReceiveError": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   575        const _ret = WEBEXT.sockets.tcp.onReceiveError.addListener(A.H.get<object>(callback));
   576      },
   577      "try_OnReceiveError": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   578        try {
   579          const _ret = WEBEXT.sockets.tcp.onReceiveError.addListener(A.H.get<object>(callback));
   580          return A.H.TRUE;
   581        } catch (err: any) {
   582          A.store.Ref(errPtr, err);
   583          return A.H.FALSE;
   584        }
   585      },
   586      "has_OffReceiveError": (): heap.Ref<boolean> => {
   587        if (WEBEXT?.sockets?.tcp?.onReceiveError && "removeListener" in WEBEXT?.sockets?.tcp?.onReceiveError) {
   588          return A.H.TRUE;
   589        }
   590        return A.H.FALSE;
   591      },
   592      "func_OffReceiveError": (fn: Pointer): void => {
   593        A.store.Ref(fn, WEBEXT.sockets.tcp.onReceiveError.removeListener);
   594      },
   595      "call_OffReceiveError": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   596        const _ret = WEBEXT.sockets.tcp.onReceiveError.removeListener(A.H.get<object>(callback));
   597      },
   598      "try_OffReceiveError": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   599        try {
   600          const _ret = WEBEXT.sockets.tcp.onReceiveError.removeListener(A.H.get<object>(callback));
   601          return A.H.TRUE;
   602        } catch (err: any) {
   603          A.store.Ref(errPtr, err);
   604          return A.H.FALSE;
   605        }
   606      },
   607      "has_HasOnReceiveError": (): heap.Ref<boolean> => {
   608        if (WEBEXT?.sockets?.tcp?.onReceiveError && "hasListener" in WEBEXT?.sockets?.tcp?.onReceiveError) {
   609          return A.H.TRUE;
   610        }
   611        return A.H.FALSE;
   612      },
   613      "func_HasOnReceiveError": (fn: Pointer): void => {
   614        A.store.Ref(fn, WEBEXT.sockets.tcp.onReceiveError.hasListener);
   615      },
   616      "call_HasOnReceiveError": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   617        const _ret = WEBEXT.sockets.tcp.onReceiveError.hasListener(A.H.get<object>(callback));
   618        A.store.Bool(retPtr, _ret);
   619      },
   620      "try_HasOnReceiveError": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   621        try {
   622          const _ret = WEBEXT.sockets.tcp.onReceiveError.hasListener(A.H.get<object>(callback));
   623          A.store.Bool(retPtr, _ret);
   624          return A.H.TRUE;
   625        } catch (err: any) {
   626          A.store.Ref(errPtr, err);
   627          return A.H.FALSE;
   628        }
   629      },
   630      "has_Secure": (): heap.Ref<boolean> => {
   631        if (WEBEXT?.sockets?.tcp && "secure" in WEBEXT?.sockets?.tcp) {
   632          return A.H.TRUE;
   633        }
   634        return A.H.FALSE;
   635      },
   636      "func_Secure": (fn: Pointer): void => {
   637        A.store.Ref(fn, WEBEXT.sockets.tcp.secure);
   638      },
   639      "call_Secure": (retPtr: Pointer, socketId: number, options: Pointer, callback: heap.Ref<object>): void => {
   640        const options_ffi = {};
   641  
   642        if (A.load.Bool(options + 0 + 8)) {
   643          options_ffi["tlsVersion"] = {};
   644          options_ffi["tlsVersion"]["min"] = A.load.Ref(options + 0 + 0, undefined);
   645          options_ffi["tlsVersion"]["max"] = A.load.Ref(options + 0 + 4, undefined);
   646        }
   647  
   648        const _ret = WEBEXT.sockets.tcp.secure(socketId, options_ffi, A.H.get<object>(callback));
   649      },
   650      "try_Secure": (
   651        retPtr: Pointer,
   652        errPtr: Pointer,
   653        socketId: number,
   654        options: Pointer,
   655        callback: heap.Ref<object>
   656      ): heap.Ref<boolean> => {
   657        try {
   658          const options_ffi = {};
   659  
   660          if (A.load.Bool(options + 0 + 8)) {
   661            options_ffi["tlsVersion"] = {};
   662            options_ffi["tlsVersion"]["min"] = A.load.Ref(options + 0 + 0, undefined);
   663            options_ffi["tlsVersion"]["max"] = A.load.Ref(options + 0 + 4, undefined);
   664          }
   665  
   666          const _ret = WEBEXT.sockets.tcp.secure(socketId, options_ffi, A.H.get<object>(callback));
   667          return A.H.TRUE;
   668        } catch (err: any) {
   669          A.store.Ref(errPtr, err);
   670          return A.H.FALSE;
   671        }
   672      },
   673      "has_Send": (): heap.Ref<boolean> => {
   674        if (WEBEXT?.sockets?.tcp && "send" in WEBEXT?.sockets?.tcp) {
   675          return A.H.TRUE;
   676        }
   677        return A.H.FALSE;
   678      },
   679      "func_Send": (fn: Pointer): void => {
   680        A.store.Ref(fn, WEBEXT.sockets.tcp.send);
   681      },
   682      "call_Send": (retPtr: Pointer, socketId: number, data: heap.Ref<object>, callback: heap.Ref<object>): void => {
   683        const _ret = WEBEXT.sockets.tcp.send(socketId, A.H.get<object>(data), A.H.get<object>(callback));
   684      },
   685      "try_Send": (
   686        retPtr: Pointer,
   687        errPtr: Pointer,
   688        socketId: number,
   689        data: heap.Ref<object>,
   690        callback: heap.Ref<object>
   691      ): heap.Ref<boolean> => {
   692        try {
   693          const _ret = WEBEXT.sockets.tcp.send(socketId, A.H.get<object>(data), A.H.get<object>(callback));
   694          return A.H.TRUE;
   695        } catch (err: any) {
   696          A.store.Ref(errPtr, err);
   697          return A.H.FALSE;
   698        }
   699      },
   700      "has_SetKeepAlive": (): heap.Ref<boolean> => {
   701        if (WEBEXT?.sockets?.tcp && "setKeepAlive" in WEBEXT?.sockets?.tcp) {
   702          return A.H.TRUE;
   703        }
   704        return A.H.FALSE;
   705      },
   706      "func_SetKeepAlive": (fn: Pointer): void => {
   707        A.store.Ref(fn, WEBEXT.sockets.tcp.setKeepAlive);
   708      },
   709      "call_SetKeepAlive": (
   710        retPtr: Pointer,
   711        socketId: number,
   712        enable: heap.Ref<boolean>,
   713        delay: number,
   714        callback: heap.Ref<object>
   715      ): void => {
   716        const _ret = WEBEXT.sockets.tcp.setKeepAlive(socketId, enable === A.H.TRUE, delay, A.H.get<object>(callback));
   717      },
   718      "try_SetKeepAlive": (
   719        retPtr: Pointer,
   720        errPtr: Pointer,
   721        socketId: number,
   722        enable: heap.Ref<boolean>,
   723        delay: number,
   724        callback: heap.Ref<object>
   725      ): heap.Ref<boolean> => {
   726        try {
   727          const _ret = WEBEXT.sockets.tcp.setKeepAlive(socketId, enable === A.H.TRUE, delay, A.H.get<object>(callback));
   728          return A.H.TRUE;
   729        } catch (err: any) {
   730          A.store.Ref(errPtr, err);
   731          return A.H.FALSE;
   732        }
   733      },
   734      "has_SetNoDelay": (): heap.Ref<boolean> => {
   735        if (WEBEXT?.sockets?.tcp && "setNoDelay" in WEBEXT?.sockets?.tcp) {
   736          return A.H.TRUE;
   737        }
   738        return A.H.FALSE;
   739      },
   740      "func_SetNoDelay": (fn: Pointer): void => {
   741        A.store.Ref(fn, WEBEXT.sockets.tcp.setNoDelay);
   742      },
   743      "call_SetNoDelay": (
   744        retPtr: Pointer,
   745        socketId: number,
   746        noDelay: heap.Ref<boolean>,
   747        callback: heap.Ref<object>
   748      ): void => {
   749        const _ret = WEBEXT.sockets.tcp.setNoDelay(socketId, noDelay === A.H.TRUE, A.H.get<object>(callback));
   750      },
   751      "try_SetNoDelay": (
   752        retPtr: Pointer,
   753        errPtr: Pointer,
   754        socketId: number,
   755        noDelay: heap.Ref<boolean>,
   756        callback: heap.Ref<object>
   757      ): heap.Ref<boolean> => {
   758        try {
   759          const _ret = WEBEXT.sockets.tcp.setNoDelay(socketId, noDelay === A.H.TRUE, A.H.get<object>(callback));
   760          return A.H.TRUE;
   761        } catch (err: any) {
   762          A.store.Ref(errPtr, err);
   763          return A.H.FALSE;
   764        }
   765      },
   766      "has_SetPaused": (): heap.Ref<boolean> => {
   767        if (WEBEXT?.sockets?.tcp && "setPaused" in WEBEXT?.sockets?.tcp) {
   768          return A.H.TRUE;
   769        }
   770        return A.H.FALSE;
   771      },
   772      "func_SetPaused": (fn: Pointer): void => {
   773        A.store.Ref(fn, WEBEXT.sockets.tcp.setPaused);
   774      },
   775      "call_SetPaused": (
   776        retPtr: Pointer,
   777        socketId: number,
   778        paused: heap.Ref<boolean>,
   779        callback: heap.Ref<object>
   780      ): void => {
   781        const _ret = WEBEXT.sockets.tcp.setPaused(socketId, paused === A.H.TRUE, A.H.get<object>(callback));
   782      },
   783      "try_SetPaused": (
   784        retPtr: Pointer,
   785        errPtr: Pointer,
   786        socketId: number,
   787        paused: heap.Ref<boolean>,
   788        callback: heap.Ref<object>
   789      ): heap.Ref<boolean> => {
   790        try {
   791          const _ret = WEBEXT.sockets.tcp.setPaused(socketId, paused === A.H.TRUE, A.H.get<object>(callback));
   792          return A.H.TRUE;
   793        } catch (err: any) {
   794          A.store.Ref(errPtr, err);
   795          return A.H.FALSE;
   796        }
   797      },
   798      "has_Update": (): heap.Ref<boolean> => {
   799        if (WEBEXT?.sockets?.tcp && "update" in WEBEXT?.sockets?.tcp) {
   800          return A.H.TRUE;
   801        }
   802        return A.H.FALSE;
   803      },
   804      "func_Update": (fn: Pointer): void => {
   805        A.store.Ref(fn, WEBEXT.sockets.tcp.update);
   806      },
   807      "call_Update": (retPtr: Pointer, socketId: number, properties: Pointer, callback: heap.Ref<object>): void => {
   808        const properties_ffi = {};
   809  
   810        if (A.load.Bool(properties + 12)) {
   811          properties_ffi["persistent"] = A.load.Bool(properties + 0);
   812        }
   813        properties_ffi["name"] = A.load.Ref(properties + 4, undefined);
   814        if (A.load.Bool(properties + 13)) {
   815          properties_ffi["bufferSize"] = A.load.Int32(properties + 8);
   816        }
   817  
   818        const _ret = WEBEXT.sockets.tcp.update(socketId, properties_ffi, A.H.get<object>(callback));
   819      },
   820      "try_Update": (
   821        retPtr: Pointer,
   822        errPtr: Pointer,
   823        socketId: number,
   824        properties: Pointer,
   825        callback: heap.Ref<object>
   826      ): heap.Ref<boolean> => {
   827        try {
   828          const properties_ffi = {};
   829  
   830          if (A.load.Bool(properties + 12)) {
   831            properties_ffi["persistent"] = A.load.Bool(properties + 0);
   832          }
   833          properties_ffi["name"] = A.load.Ref(properties + 4, undefined);
   834          if (A.load.Bool(properties + 13)) {
   835            properties_ffi["bufferSize"] = A.load.Int32(properties + 8);
   836          }
   837  
   838          const _ret = WEBEXT.sockets.tcp.update(socketId, properties_ffi, A.H.get<object>(callback));
   839          return A.H.TRUE;
   840        } catch (err: any) {
   841          A.store.Ref(errPtr, err);
   842          return A.H.FALSE;
   843        }
   844      },
   845    };
   846  });