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

     1  import { importModule, Application, heap, Pointer } from "@ffi";
     2  
     3  importModule("plat/js/webext/sockets/tcpserver", (A: Application) => {
     4    const WEBEXT = typeof globalThis.browser === "undefined" ? globalThis.chrome : globalThis.browser;
     5  
     6    return {
     7      "store_AcceptErrorInfo": (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 + 10, false);
    12          A.store.Bool(ptr + 8, false);
    13          A.store.Int32(ptr + 0, 0);
    14          A.store.Bool(ptr + 9, false);
    15          A.store.Int32(ptr + 4, 0);
    16        } else {
    17          A.store.Bool(ptr + 10, true);
    18          A.store.Bool(ptr + 8, "socketId" in x ? true : false);
    19          A.store.Int32(ptr + 0, x["socketId"] === undefined ? 0 : (x["socketId"] as number));
    20          A.store.Bool(ptr + 9, "resultCode" in x ? true : false);
    21          A.store.Int32(ptr + 4, x["resultCode"] === undefined ? 0 : (x["resultCode"] as number));
    22        }
    23      },
    24      "load_AcceptErrorInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
    25        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
    26  
    27        if (A.load.Bool(ptr + 8)) {
    28          x["socketId"] = A.load.Int32(ptr + 0);
    29        } else {
    30          delete x["socketId"];
    31        }
    32        if (A.load.Bool(ptr + 9)) {
    33          x["resultCode"] = A.load.Int32(ptr + 4);
    34        } else {
    35          delete x["resultCode"];
    36        }
    37        return create === A.H.TRUE ? A.H.push(x) : ref;
    38      },
    39  
    40      "store_AcceptInfo": (ptr: Pointer, ref: heap.Ref<any>) => {
    41        const x = A.H.get<any>(ref);
    42  
    43        if (typeof x === "undefined") {
    44          A.store.Bool(ptr + 10, false);
    45          A.store.Bool(ptr + 8, false);
    46          A.store.Int32(ptr + 0, 0);
    47          A.store.Bool(ptr + 9, false);
    48          A.store.Int32(ptr + 4, 0);
    49        } else {
    50          A.store.Bool(ptr + 10, true);
    51          A.store.Bool(ptr + 8, "socketId" in x ? true : false);
    52          A.store.Int32(ptr + 0, x["socketId"] === undefined ? 0 : (x["socketId"] as number));
    53          A.store.Bool(ptr + 9, "clientSocketId" in x ? true : false);
    54          A.store.Int32(ptr + 4, x["clientSocketId"] === undefined ? 0 : (x["clientSocketId"] as number));
    55        }
    56      },
    57      "load_AcceptInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
    58        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
    59  
    60        if (A.load.Bool(ptr + 8)) {
    61          x["socketId"] = A.load.Int32(ptr + 0);
    62        } else {
    63          delete x["socketId"];
    64        }
    65        if (A.load.Bool(ptr + 9)) {
    66          x["clientSocketId"] = A.load.Int32(ptr + 4);
    67        } else {
    68          delete x["clientSocketId"];
    69        }
    70        return create === A.H.TRUE ? A.H.push(x) : ref;
    71      },
    72  
    73      "store_CreateInfo": (ptr: Pointer, ref: heap.Ref<any>) => {
    74        const x = A.H.get<any>(ref);
    75  
    76        if (typeof x === "undefined") {
    77          A.store.Bool(ptr + 5, false);
    78          A.store.Bool(ptr + 4, false);
    79          A.store.Int32(ptr + 0, 0);
    80        } else {
    81          A.store.Bool(ptr + 5, true);
    82          A.store.Bool(ptr + 4, "socketId" in x ? true : false);
    83          A.store.Int32(ptr + 0, x["socketId"] === undefined ? 0 : (x["socketId"] as number));
    84        }
    85      },
    86      "load_CreateInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
    87        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
    88  
    89        if (A.load.Bool(ptr + 4)) {
    90          x["socketId"] = A.load.Int32(ptr + 0);
    91        } else {
    92          delete x["socketId"];
    93        }
    94        return create === A.H.TRUE ? A.H.push(x) : ref;
    95      },
    96  
    97      "store_SocketInfo": (ptr: Pointer, ref: heap.Ref<any>) => {
    98        const x = A.H.get<any>(ref);
    99  
   100        if (typeof x === "undefined") {
   101          A.store.Bool(ptr + 28, false);
   102          A.store.Bool(ptr + 24, false);
   103          A.store.Int32(ptr + 0, 0);
   104          A.store.Bool(ptr + 25, false);
   105          A.store.Bool(ptr + 4, false);
   106          A.store.Ref(ptr + 8, undefined);
   107          A.store.Bool(ptr + 26, false);
   108          A.store.Bool(ptr + 12, false);
   109          A.store.Ref(ptr + 16, undefined);
   110          A.store.Bool(ptr + 27, false);
   111          A.store.Int32(ptr + 20, 0);
   112        } else {
   113          A.store.Bool(ptr + 28, true);
   114          A.store.Bool(ptr + 24, "socketId" in x ? true : false);
   115          A.store.Int32(ptr + 0, x["socketId"] === undefined ? 0 : (x["socketId"] as number));
   116          A.store.Bool(ptr + 25, "persistent" in x ? true : false);
   117          A.store.Bool(ptr + 4, x["persistent"] ? true : false);
   118          A.store.Ref(ptr + 8, x["name"]);
   119          A.store.Bool(ptr + 26, "paused" in x ? true : false);
   120          A.store.Bool(ptr + 12, x["paused"] ? true : false);
   121          A.store.Ref(ptr + 16, x["localAddress"]);
   122          A.store.Bool(ptr + 27, "localPort" in x ? true : false);
   123          A.store.Int32(ptr + 20, x["localPort"] === undefined ? 0 : (x["localPort"] as number));
   124        }
   125      },
   126      "load_SocketInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   127        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   128  
   129        if (A.load.Bool(ptr + 24)) {
   130          x["socketId"] = A.load.Int32(ptr + 0);
   131        } else {
   132          delete x["socketId"];
   133        }
   134        if (A.load.Bool(ptr + 25)) {
   135          x["persistent"] = A.load.Bool(ptr + 4);
   136        } else {
   137          delete x["persistent"];
   138        }
   139        x["name"] = A.load.Ref(ptr + 8, undefined);
   140        if (A.load.Bool(ptr + 26)) {
   141          x["paused"] = A.load.Bool(ptr + 12);
   142        } else {
   143          delete x["paused"];
   144        }
   145        x["localAddress"] = A.load.Ref(ptr + 16, undefined);
   146        if (A.load.Bool(ptr + 27)) {
   147          x["localPort"] = A.load.Int32(ptr + 20);
   148        } else {
   149          delete x["localPort"];
   150        }
   151        return create === A.H.TRUE ? A.H.push(x) : ref;
   152      },
   153  
   154      "store_SocketProperties": (ptr: Pointer, ref: heap.Ref<any>) => {
   155        const x = A.H.get<any>(ref);
   156  
   157        if (typeof x === "undefined") {
   158          A.store.Bool(ptr + 9, false);
   159          A.store.Bool(ptr + 8, false);
   160          A.store.Bool(ptr + 0, false);
   161          A.store.Ref(ptr + 4, undefined);
   162        } else {
   163          A.store.Bool(ptr + 9, true);
   164          A.store.Bool(ptr + 8, "persistent" in x ? true : false);
   165          A.store.Bool(ptr + 0, x["persistent"] ? true : false);
   166          A.store.Ref(ptr + 4, x["name"]);
   167        }
   168      },
   169      "load_SocketProperties": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   170        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   171  
   172        if (A.load.Bool(ptr + 8)) {
   173          x["persistent"] = A.load.Bool(ptr + 0);
   174        } else {
   175          delete x["persistent"];
   176        }
   177        x["name"] = A.load.Ref(ptr + 4, undefined);
   178        return create === A.H.TRUE ? A.H.push(x) : ref;
   179      },
   180      "has_Close": (): heap.Ref<boolean> => {
   181        if (WEBEXT?.sockets?.tcpServer && "close" in WEBEXT?.sockets?.tcpServer) {
   182          return A.H.TRUE;
   183        }
   184        return A.H.FALSE;
   185      },
   186      "func_Close": (fn: Pointer): void => {
   187        A.store.Ref(fn, WEBEXT.sockets.tcpServer.close);
   188      },
   189      "call_Close": (retPtr: Pointer, socketId: number, callback: heap.Ref<object>): void => {
   190        const _ret = WEBEXT.sockets.tcpServer.close(socketId, A.H.get<object>(callback));
   191      },
   192      "try_Close": (
   193        retPtr: Pointer,
   194        errPtr: Pointer,
   195        socketId: number,
   196        callback: heap.Ref<object>
   197      ): heap.Ref<boolean> => {
   198        try {
   199          const _ret = WEBEXT.sockets.tcpServer.close(socketId, A.H.get<object>(callback));
   200          return A.H.TRUE;
   201        } catch (err: any) {
   202          A.store.Ref(errPtr, err);
   203          return A.H.FALSE;
   204        }
   205      },
   206      "has_Create": (): heap.Ref<boolean> => {
   207        if (WEBEXT?.sockets?.tcpServer && "create" in WEBEXT?.sockets?.tcpServer) {
   208          return A.H.TRUE;
   209        }
   210        return A.H.FALSE;
   211      },
   212      "func_Create": (fn: Pointer): void => {
   213        A.store.Ref(fn, WEBEXT.sockets.tcpServer.create);
   214      },
   215      "call_Create": (retPtr: Pointer, properties: Pointer, callback: heap.Ref<object>): void => {
   216        const properties_ffi = {};
   217  
   218        if (A.load.Bool(properties + 8)) {
   219          properties_ffi["persistent"] = A.load.Bool(properties + 0);
   220        }
   221        properties_ffi["name"] = A.load.Ref(properties + 4, undefined);
   222  
   223        const _ret = WEBEXT.sockets.tcpServer.create(properties_ffi, A.H.get<object>(callback));
   224      },
   225      "try_Create": (
   226        retPtr: Pointer,
   227        errPtr: Pointer,
   228        properties: Pointer,
   229        callback: heap.Ref<object>
   230      ): heap.Ref<boolean> => {
   231        try {
   232          const properties_ffi = {};
   233  
   234          if (A.load.Bool(properties + 8)) {
   235            properties_ffi["persistent"] = A.load.Bool(properties + 0);
   236          }
   237          properties_ffi["name"] = A.load.Ref(properties + 4, undefined);
   238  
   239          const _ret = WEBEXT.sockets.tcpServer.create(properties_ffi, 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_Disconnect": (): heap.Ref<boolean> => {
   247        if (WEBEXT?.sockets?.tcpServer && "disconnect" in WEBEXT?.sockets?.tcpServer) {
   248          return A.H.TRUE;
   249        }
   250        return A.H.FALSE;
   251      },
   252      "func_Disconnect": (fn: Pointer): void => {
   253        A.store.Ref(fn, WEBEXT.sockets.tcpServer.disconnect);
   254      },
   255      "call_Disconnect": (retPtr: Pointer, socketId: number, callback: heap.Ref<object>): void => {
   256        const _ret = WEBEXT.sockets.tcpServer.disconnect(socketId, A.H.get<object>(callback));
   257      },
   258      "try_Disconnect": (
   259        retPtr: Pointer,
   260        errPtr: Pointer,
   261        socketId: number,
   262        callback: heap.Ref<object>
   263      ): heap.Ref<boolean> => {
   264        try {
   265          const _ret = WEBEXT.sockets.tcpServer.disconnect(socketId, A.H.get<object>(callback));
   266          return A.H.TRUE;
   267        } catch (err: any) {
   268          A.store.Ref(errPtr, err);
   269          return A.H.FALSE;
   270        }
   271      },
   272      "has_GetInfo": (): heap.Ref<boolean> => {
   273        if (WEBEXT?.sockets?.tcpServer && "getInfo" in WEBEXT?.sockets?.tcpServer) {
   274          return A.H.TRUE;
   275        }
   276        return A.H.FALSE;
   277      },
   278      "func_GetInfo": (fn: Pointer): void => {
   279        A.store.Ref(fn, WEBEXT.sockets.tcpServer.getInfo);
   280      },
   281      "call_GetInfo": (retPtr: Pointer, socketId: number, callback: heap.Ref<object>): void => {
   282        const _ret = WEBEXT.sockets.tcpServer.getInfo(socketId, A.H.get<object>(callback));
   283      },
   284      "try_GetInfo": (
   285        retPtr: Pointer,
   286        errPtr: Pointer,
   287        socketId: number,
   288        callback: heap.Ref<object>
   289      ): heap.Ref<boolean> => {
   290        try {
   291          const _ret = WEBEXT.sockets.tcpServer.getInfo(socketId, A.H.get<object>(callback));
   292          return A.H.TRUE;
   293        } catch (err: any) {
   294          A.store.Ref(errPtr, err);
   295          return A.H.FALSE;
   296        }
   297      },
   298      "has_GetSockets": (): heap.Ref<boolean> => {
   299        if (WEBEXT?.sockets?.tcpServer && "getSockets" in WEBEXT?.sockets?.tcpServer) {
   300          return A.H.TRUE;
   301        }
   302        return A.H.FALSE;
   303      },
   304      "func_GetSockets": (fn: Pointer): void => {
   305        A.store.Ref(fn, WEBEXT.sockets.tcpServer.getSockets);
   306      },
   307      "call_GetSockets": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   308        const _ret = WEBEXT.sockets.tcpServer.getSockets(A.H.get<object>(callback));
   309      },
   310      "try_GetSockets": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   311        try {
   312          const _ret = WEBEXT.sockets.tcpServer.getSockets(A.H.get<object>(callback));
   313          return A.H.TRUE;
   314        } catch (err: any) {
   315          A.store.Ref(errPtr, err);
   316          return A.H.FALSE;
   317        }
   318      },
   319      "has_Listen": (): heap.Ref<boolean> => {
   320        if (WEBEXT?.sockets?.tcpServer && "listen" in WEBEXT?.sockets?.tcpServer) {
   321          return A.H.TRUE;
   322        }
   323        return A.H.FALSE;
   324      },
   325      "func_Listen": (fn: Pointer): void => {
   326        A.store.Ref(fn, WEBEXT.sockets.tcpServer.listen);
   327      },
   328      "call_Listen": (
   329        retPtr: Pointer,
   330        socketId: number,
   331        address: heap.Ref<object>,
   332        port: number,
   333        backlog: number,
   334        callback: heap.Ref<object>
   335      ): void => {
   336        const _ret = WEBEXT.sockets.tcpServer.listen(
   337          socketId,
   338          A.H.get<object>(address),
   339          port,
   340          backlog,
   341          A.H.get<object>(callback)
   342        );
   343      },
   344      "try_Listen": (
   345        retPtr: Pointer,
   346        errPtr: Pointer,
   347        socketId: number,
   348        address: heap.Ref<object>,
   349        port: number,
   350        backlog: number,
   351        callback: heap.Ref<object>
   352      ): heap.Ref<boolean> => {
   353        try {
   354          const _ret = WEBEXT.sockets.tcpServer.listen(
   355            socketId,
   356            A.H.get<object>(address),
   357            port,
   358            backlog,
   359            A.H.get<object>(callback)
   360          );
   361          return A.H.TRUE;
   362        } catch (err: any) {
   363          A.store.Ref(errPtr, err);
   364          return A.H.FALSE;
   365        }
   366      },
   367      "has_OnAccept": (): heap.Ref<boolean> => {
   368        if (WEBEXT?.sockets?.tcpServer?.onAccept && "addListener" in WEBEXT?.sockets?.tcpServer?.onAccept) {
   369          return A.H.TRUE;
   370        }
   371        return A.H.FALSE;
   372      },
   373      "func_OnAccept": (fn: Pointer): void => {
   374        A.store.Ref(fn, WEBEXT.sockets.tcpServer.onAccept.addListener);
   375      },
   376      "call_OnAccept": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   377        const _ret = WEBEXT.sockets.tcpServer.onAccept.addListener(A.H.get<object>(callback));
   378      },
   379      "try_OnAccept": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   380        try {
   381          const _ret = WEBEXT.sockets.tcpServer.onAccept.addListener(A.H.get<object>(callback));
   382          return A.H.TRUE;
   383        } catch (err: any) {
   384          A.store.Ref(errPtr, err);
   385          return A.H.FALSE;
   386        }
   387      },
   388      "has_OffAccept": (): heap.Ref<boolean> => {
   389        if (WEBEXT?.sockets?.tcpServer?.onAccept && "removeListener" in WEBEXT?.sockets?.tcpServer?.onAccept) {
   390          return A.H.TRUE;
   391        }
   392        return A.H.FALSE;
   393      },
   394      "func_OffAccept": (fn: Pointer): void => {
   395        A.store.Ref(fn, WEBEXT.sockets.tcpServer.onAccept.removeListener);
   396      },
   397      "call_OffAccept": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   398        const _ret = WEBEXT.sockets.tcpServer.onAccept.removeListener(A.H.get<object>(callback));
   399      },
   400      "try_OffAccept": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   401        try {
   402          const _ret = WEBEXT.sockets.tcpServer.onAccept.removeListener(A.H.get<object>(callback));
   403          return A.H.TRUE;
   404        } catch (err: any) {
   405          A.store.Ref(errPtr, err);
   406          return A.H.FALSE;
   407        }
   408      },
   409      "has_HasOnAccept": (): heap.Ref<boolean> => {
   410        if (WEBEXT?.sockets?.tcpServer?.onAccept && "hasListener" in WEBEXT?.sockets?.tcpServer?.onAccept) {
   411          return A.H.TRUE;
   412        }
   413        return A.H.FALSE;
   414      },
   415      "func_HasOnAccept": (fn: Pointer): void => {
   416        A.store.Ref(fn, WEBEXT.sockets.tcpServer.onAccept.hasListener);
   417      },
   418      "call_HasOnAccept": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   419        const _ret = WEBEXT.sockets.tcpServer.onAccept.hasListener(A.H.get<object>(callback));
   420        A.store.Bool(retPtr, _ret);
   421      },
   422      "try_HasOnAccept": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   423        try {
   424          const _ret = WEBEXT.sockets.tcpServer.onAccept.hasListener(A.H.get<object>(callback));
   425          A.store.Bool(retPtr, _ret);
   426          return A.H.TRUE;
   427        } catch (err: any) {
   428          A.store.Ref(errPtr, err);
   429          return A.H.FALSE;
   430        }
   431      },
   432      "has_OnAcceptError": (): heap.Ref<boolean> => {
   433        if (WEBEXT?.sockets?.tcpServer?.onAcceptError && "addListener" in WEBEXT?.sockets?.tcpServer?.onAcceptError) {
   434          return A.H.TRUE;
   435        }
   436        return A.H.FALSE;
   437      },
   438      "func_OnAcceptError": (fn: Pointer): void => {
   439        A.store.Ref(fn, WEBEXT.sockets.tcpServer.onAcceptError.addListener);
   440      },
   441      "call_OnAcceptError": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   442        const _ret = WEBEXT.sockets.tcpServer.onAcceptError.addListener(A.H.get<object>(callback));
   443      },
   444      "try_OnAcceptError": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   445        try {
   446          const _ret = WEBEXT.sockets.tcpServer.onAcceptError.addListener(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_OffAcceptError": (): heap.Ref<boolean> => {
   454        if (WEBEXT?.sockets?.tcpServer?.onAcceptError && "removeListener" in WEBEXT?.sockets?.tcpServer?.onAcceptError) {
   455          return A.H.TRUE;
   456        }
   457        return A.H.FALSE;
   458      },
   459      "func_OffAcceptError": (fn: Pointer): void => {
   460        A.store.Ref(fn, WEBEXT.sockets.tcpServer.onAcceptError.removeListener);
   461      },
   462      "call_OffAcceptError": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   463        const _ret = WEBEXT.sockets.tcpServer.onAcceptError.removeListener(A.H.get<object>(callback));
   464      },
   465      "try_OffAcceptError": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   466        try {
   467          const _ret = WEBEXT.sockets.tcpServer.onAcceptError.removeListener(A.H.get<object>(callback));
   468          return A.H.TRUE;
   469        } catch (err: any) {
   470          A.store.Ref(errPtr, err);
   471          return A.H.FALSE;
   472        }
   473      },
   474      "has_HasOnAcceptError": (): heap.Ref<boolean> => {
   475        if (WEBEXT?.sockets?.tcpServer?.onAcceptError && "hasListener" in WEBEXT?.sockets?.tcpServer?.onAcceptError) {
   476          return A.H.TRUE;
   477        }
   478        return A.H.FALSE;
   479      },
   480      "func_HasOnAcceptError": (fn: Pointer): void => {
   481        A.store.Ref(fn, WEBEXT.sockets.tcpServer.onAcceptError.hasListener);
   482      },
   483      "call_HasOnAcceptError": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   484        const _ret = WEBEXT.sockets.tcpServer.onAcceptError.hasListener(A.H.get<object>(callback));
   485        A.store.Bool(retPtr, _ret);
   486      },
   487      "try_HasOnAcceptError": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   488        try {
   489          const _ret = WEBEXT.sockets.tcpServer.onAcceptError.hasListener(A.H.get<object>(callback));
   490          A.store.Bool(retPtr, _ret);
   491          return A.H.TRUE;
   492        } catch (err: any) {
   493          A.store.Ref(errPtr, err);
   494          return A.H.FALSE;
   495        }
   496      },
   497      "has_SetPaused": (): heap.Ref<boolean> => {
   498        if (WEBEXT?.sockets?.tcpServer && "setPaused" in WEBEXT?.sockets?.tcpServer) {
   499          return A.H.TRUE;
   500        }
   501        return A.H.FALSE;
   502      },
   503      "func_SetPaused": (fn: Pointer): void => {
   504        A.store.Ref(fn, WEBEXT.sockets.tcpServer.setPaused);
   505      },
   506      "call_SetPaused": (
   507        retPtr: Pointer,
   508        socketId: number,
   509        paused: heap.Ref<boolean>,
   510        callback: heap.Ref<object>
   511      ): void => {
   512        const _ret = WEBEXT.sockets.tcpServer.setPaused(socketId, paused === A.H.TRUE, A.H.get<object>(callback));
   513      },
   514      "try_SetPaused": (
   515        retPtr: Pointer,
   516        errPtr: Pointer,
   517        socketId: number,
   518        paused: heap.Ref<boolean>,
   519        callback: heap.Ref<object>
   520      ): heap.Ref<boolean> => {
   521        try {
   522          const _ret = WEBEXT.sockets.tcpServer.setPaused(socketId, paused === A.H.TRUE, A.H.get<object>(callback));
   523          return A.H.TRUE;
   524        } catch (err: any) {
   525          A.store.Ref(errPtr, err);
   526          return A.H.FALSE;
   527        }
   528      },
   529      "has_Update": (): heap.Ref<boolean> => {
   530        if (WEBEXT?.sockets?.tcpServer && "update" in WEBEXT?.sockets?.tcpServer) {
   531          return A.H.TRUE;
   532        }
   533        return A.H.FALSE;
   534      },
   535      "func_Update": (fn: Pointer): void => {
   536        A.store.Ref(fn, WEBEXT.sockets.tcpServer.update);
   537      },
   538      "call_Update": (retPtr: Pointer, socketId: number, properties: Pointer, callback: heap.Ref<object>): void => {
   539        const properties_ffi = {};
   540  
   541        if (A.load.Bool(properties + 8)) {
   542          properties_ffi["persistent"] = A.load.Bool(properties + 0);
   543        }
   544        properties_ffi["name"] = A.load.Ref(properties + 4, undefined);
   545  
   546        const _ret = WEBEXT.sockets.tcpServer.update(socketId, properties_ffi, A.H.get<object>(callback));
   547      },
   548      "try_Update": (
   549        retPtr: Pointer,
   550        errPtr: Pointer,
   551        socketId: number,
   552        properties: Pointer,
   553        callback: heap.Ref<object>
   554      ): heap.Ref<boolean> => {
   555        try {
   556          const properties_ffi = {};
   557  
   558          if (A.load.Bool(properties + 8)) {
   559            properties_ffi["persistent"] = A.load.Bool(properties + 0);
   560          }
   561          properties_ffi["name"] = A.load.Ref(properties + 4, undefined);
   562  
   563          const _ret = WEBEXT.sockets.tcpServer.update(socketId, properties_ffi, A.H.get<object>(callback));
   564          return A.H.TRUE;
   565        } catch (err: any) {
   566          A.store.Ref(errPtr, err);
   567          return A.H.FALSE;
   568        }
   569      },
   570    };
   571  });