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

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