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

     1  import { importModule, Application, heap, Pointer } from "@ffi";
     2  
     3  importModule("plat/js/webext/action", (A: Application) => {
     4    const WEBEXT = typeof globalThis.browser === "undefined" ? globalThis.chrome : globalThis.browser;
     5  
     6    return {
     7      "store_OpenPopupOptions": (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 + 9, false);
    12          A.store.Bool(ptr + 8, false);
    13          A.store.Int64(ptr + 0, 0);
    14        } else {
    15          A.store.Bool(ptr + 9, true);
    16          A.store.Bool(ptr + 8, "windowId" in x ? true : false);
    17          A.store.Int64(ptr + 0, x["windowId"] === undefined ? 0 : (x["windowId"] as number));
    18        }
    19      },
    20      "load_OpenPopupOptions": (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 + 8)) {
    24          x["windowId"] = A.load.Int64(ptr + 0);
    25        } else {
    26          delete x["windowId"];
    27        }
    28        return create === A.H.TRUE ? A.H.push(x) : ref;
    29      },
    30  
    31      "store_SetBadgeBackgroundColorArgDetails": (ptr: Pointer, ref: heap.Ref<any>) => {
    32        const x = A.H.get<any>(ref);
    33  
    34        if (typeof x === "undefined") {
    35          A.store.Bool(ptr + 17, false);
    36          A.store.Ref(ptr + 0, undefined);
    37          A.store.Bool(ptr + 16, false);
    38          A.store.Int64(ptr + 8, 0);
    39        } else {
    40          A.store.Bool(ptr + 17, true);
    41          A.store.Ref(ptr + 0, x["color"]);
    42          A.store.Bool(ptr + 16, "tabId" in x ? true : false);
    43          A.store.Int64(ptr + 8, x["tabId"] === undefined ? 0 : (x["tabId"] as number));
    44        }
    45      },
    46      "load_SetBadgeBackgroundColorArgDetails": (
    47        ptr: Pointer,
    48        create: heap.Ref<boolean>,
    49        ref: heap.Ref<any>
    50      ): heap.Ref<any> => {
    51        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
    52  
    53        x["color"] = A.load.Ref(ptr + 0, undefined);
    54        if (A.load.Bool(ptr + 16)) {
    55          x["tabId"] = A.load.Int64(ptr + 8);
    56        } else {
    57          delete x["tabId"];
    58        }
    59        return create === A.H.TRUE ? A.H.push(x) : ref;
    60      },
    61  
    62      "store_SetBadgeTextArgDetails": (ptr: Pointer, ref: heap.Ref<any>) => {
    63        const x = A.H.get<any>(ref);
    64  
    65        if (typeof x === "undefined") {
    66          A.store.Bool(ptr + 13, false);
    67          A.store.Bool(ptr + 12, false);
    68          A.store.Int64(ptr + 0, 0);
    69          A.store.Ref(ptr + 8, undefined);
    70        } else {
    71          A.store.Bool(ptr + 13, true);
    72          A.store.Bool(ptr + 12, "tabId" in x ? true : false);
    73          A.store.Int64(ptr + 0, x["tabId"] === undefined ? 0 : (x["tabId"] as number));
    74          A.store.Ref(ptr + 8, x["text"]);
    75        }
    76      },
    77      "load_SetBadgeTextArgDetails": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
    78        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
    79  
    80        if (A.load.Bool(ptr + 12)) {
    81          x["tabId"] = A.load.Int64(ptr + 0);
    82        } else {
    83          delete x["tabId"];
    84        }
    85        x["text"] = A.load.Ref(ptr + 8, undefined);
    86        return create === A.H.TRUE ? A.H.push(x) : ref;
    87      },
    88  
    89      "store_SetBadgeTextColorArgDetails": (ptr: Pointer, ref: heap.Ref<any>) => {
    90        const x = A.H.get<any>(ref);
    91  
    92        if (typeof x === "undefined") {
    93          A.store.Bool(ptr + 17, false);
    94          A.store.Ref(ptr + 0, undefined);
    95          A.store.Bool(ptr + 16, false);
    96          A.store.Int64(ptr + 8, 0);
    97        } else {
    98          A.store.Bool(ptr + 17, true);
    99          A.store.Ref(ptr + 0, x["color"]);
   100          A.store.Bool(ptr + 16, "tabId" in x ? true : false);
   101          A.store.Int64(ptr + 8, x["tabId"] === undefined ? 0 : (x["tabId"] as number));
   102        }
   103      },
   104      "load_SetBadgeTextColorArgDetails": (
   105        ptr: Pointer,
   106        create: heap.Ref<boolean>,
   107        ref: heap.Ref<any>
   108      ): heap.Ref<any> => {
   109        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   110  
   111        x["color"] = A.load.Ref(ptr + 0, undefined);
   112        if (A.load.Bool(ptr + 16)) {
   113          x["tabId"] = A.load.Int64(ptr + 8);
   114        } else {
   115          delete x["tabId"];
   116        }
   117        return create === A.H.TRUE ? A.H.push(x) : ref;
   118      },
   119  
   120      "store_SetIconArgDetails": (ptr: Pointer, ref: heap.Ref<any>) => {
   121        const x = A.H.get<any>(ref);
   122  
   123        if (typeof x === "undefined") {
   124          A.store.Bool(ptr + 17, false);
   125          A.store.Ref(ptr + 0, undefined);
   126          A.store.Ref(ptr + 4, undefined);
   127          A.store.Bool(ptr + 16, false);
   128          A.store.Int64(ptr + 8, 0);
   129        } else {
   130          A.store.Bool(ptr + 17, true);
   131          A.store.Ref(ptr + 0, x["imageData"]);
   132          A.store.Ref(ptr + 4, x["path"]);
   133          A.store.Bool(ptr + 16, "tabId" in x ? true : false);
   134          A.store.Int64(ptr + 8, x["tabId"] === undefined ? 0 : (x["tabId"] as number));
   135        }
   136      },
   137      "load_SetIconArgDetails": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   138        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   139  
   140        x["imageData"] = A.load.Ref(ptr + 0, undefined);
   141        x["path"] = A.load.Ref(ptr + 4, undefined);
   142        if (A.load.Bool(ptr + 16)) {
   143          x["tabId"] = A.load.Int64(ptr + 8);
   144        } else {
   145          delete x["tabId"];
   146        }
   147        return create === A.H.TRUE ? A.H.push(x) : ref;
   148      },
   149  
   150      "store_SetPopupArgDetails": (ptr: Pointer, ref: heap.Ref<any>) => {
   151        const x = A.H.get<any>(ref);
   152  
   153        if (typeof x === "undefined") {
   154          A.store.Bool(ptr + 17, false);
   155          A.store.Ref(ptr + 0, undefined);
   156          A.store.Bool(ptr + 16, false);
   157          A.store.Int64(ptr + 8, 0);
   158        } else {
   159          A.store.Bool(ptr + 17, true);
   160          A.store.Ref(ptr + 0, x["popup"]);
   161          A.store.Bool(ptr + 16, "tabId" in x ? true : false);
   162          A.store.Int64(ptr + 8, x["tabId"] === undefined ? 0 : (x["tabId"] as number));
   163        }
   164      },
   165      "load_SetPopupArgDetails": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   166        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   167  
   168        x["popup"] = A.load.Ref(ptr + 0, undefined);
   169        if (A.load.Bool(ptr + 16)) {
   170          x["tabId"] = A.load.Int64(ptr + 8);
   171        } else {
   172          delete x["tabId"];
   173        }
   174        return create === A.H.TRUE ? A.H.push(x) : ref;
   175      },
   176  
   177      "store_SetTitleArgDetails": (ptr: Pointer, ref: heap.Ref<any>) => {
   178        const x = A.H.get<any>(ref);
   179  
   180        if (typeof x === "undefined") {
   181          A.store.Bool(ptr + 13, false);
   182          A.store.Bool(ptr + 12, false);
   183          A.store.Int64(ptr + 0, 0);
   184          A.store.Ref(ptr + 8, undefined);
   185        } else {
   186          A.store.Bool(ptr + 13, true);
   187          A.store.Bool(ptr + 12, "tabId" in x ? true : false);
   188          A.store.Int64(ptr + 0, x["tabId"] === undefined ? 0 : (x["tabId"] as number));
   189          A.store.Ref(ptr + 8, x["title"]);
   190        }
   191      },
   192      "load_SetTitleArgDetails": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   193        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   194  
   195        if (A.load.Bool(ptr + 12)) {
   196          x["tabId"] = A.load.Int64(ptr + 0);
   197        } else {
   198          delete x["tabId"];
   199        }
   200        x["title"] = A.load.Ref(ptr + 8, undefined);
   201        return create === A.H.TRUE ? A.H.push(x) : ref;
   202      },
   203  
   204      "store_TabDetails": (ptr: Pointer, ref: heap.Ref<any>) => {
   205        const x = A.H.get<any>(ref);
   206  
   207        if (typeof x === "undefined") {
   208          A.store.Bool(ptr + 9, false);
   209          A.store.Bool(ptr + 8, false);
   210          A.store.Int64(ptr + 0, 0);
   211        } else {
   212          A.store.Bool(ptr + 9, true);
   213          A.store.Bool(ptr + 8, "tabId" in x ? true : false);
   214          A.store.Int64(ptr + 0, x["tabId"] === undefined ? 0 : (x["tabId"] as number));
   215        }
   216      },
   217      "load_TabDetails": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   218        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   219  
   220        if (A.load.Bool(ptr + 8)) {
   221          x["tabId"] = A.load.Int64(ptr + 0);
   222        } else {
   223          delete x["tabId"];
   224        }
   225        return create === A.H.TRUE ? A.H.push(x) : ref;
   226      },
   227  
   228      "store_UserSettings": (ptr: Pointer, ref: heap.Ref<any>) => {
   229        const x = A.H.get<any>(ref);
   230  
   231        if (typeof x === "undefined") {
   232          A.store.Bool(ptr + 1, false);
   233          A.store.Bool(ptr + 0, false);
   234        } else {
   235          A.store.Bool(ptr + 1, true);
   236          A.store.Bool(ptr + 0, x["isOnToolbar"] ? true : false);
   237        }
   238      },
   239      "load_UserSettings": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   240        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   241  
   242        x["isOnToolbar"] = A.load.Bool(ptr + 0);
   243        return create === A.H.TRUE ? A.H.push(x) : ref;
   244      },
   245      "has_Disable": (): heap.Ref<boolean> => {
   246        if (WEBEXT?.action && "disable" in WEBEXT?.action) {
   247          return A.H.TRUE;
   248        }
   249        return A.H.FALSE;
   250      },
   251      "func_Disable": (fn: Pointer): void => {
   252        A.store.Ref(fn, WEBEXT.action.disable);
   253      },
   254      "call_Disable": (retPtr: Pointer, tabId: number): void => {
   255        const _ret = WEBEXT.action.disable(tabId);
   256        A.store.Ref(retPtr, _ret);
   257      },
   258      "try_Disable": (retPtr: Pointer, errPtr: Pointer, tabId: number): heap.Ref<boolean> => {
   259        try {
   260          const _ret = WEBEXT.action.disable(tabId);
   261          A.store.Ref(retPtr, _ret);
   262          return A.H.TRUE;
   263        } catch (err: any) {
   264          A.store.Ref(errPtr, err);
   265          return A.H.FALSE;
   266        }
   267      },
   268      "has_Enable": (): heap.Ref<boolean> => {
   269        if (WEBEXT?.action && "enable" in WEBEXT?.action) {
   270          return A.H.TRUE;
   271        }
   272        return A.H.FALSE;
   273      },
   274      "func_Enable": (fn: Pointer): void => {
   275        A.store.Ref(fn, WEBEXT.action.enable);
   276      },
   277      "call_Enable": (retPtr: Pointer, tabId: number): void => {
   278        const _ret = WEBEXT.action.enable(tabId);
   279        A.store.Ref(retPtr, _ret);
   280      },
   281      "try_Enable": (retPtr: Pointer, errPtr: Pointer, tabId: number): heap.Ref<boolean> => {
   282        try {
   283          const _ret = WEBEXT.action.enable(tabId);
   284          A.store.Ref(retPtr, _ret);
   285          return A.H.TRUE;
   286        } catch (err: any) {
   287          A.store.Ref(errPtr, err);
   288          return A.H.FALSE;
   289        }
   290      },
   291      "has_GetBadgeBackgroundColor": (): heap.Ref<boolean> => {
   292        if (WEBEXT?.action && "getBadgeBackgroundColor" in WEBEXT?.action) {
   293          return A.H.TRUE;
   294        }
   295        return A.H.FALSE;
   296      },
   297      "func_GetBadgeBackgroundColor": (fn: Pointer): void => {
   298        A.store.Ref(fn, WEBEXT.action.getBadgeBackgroundColor);
   299      },
   300      "call_GetBadgeBackgroundColor": (retPtr: Pointer, details: Pointer): void => {
   301        const details_ffi = {};
   302  
   303        if (A.load.Bool(details + 8)) {
   304          details_ffi["tabId"] = A.load.Int64(details + 0);
   305        }
   306  
   307        const _ret = WEBEXT.action.getBadgeBackgroundColor(details_ffi);
   308        A.store.Ref(retPtr, _ret);
   309      },
   310      "try_GetBadgeBackgroundColor": (retPtr: Pointer, errPtr: Pointer, details: Pointer): heap.Ref<boolean> => {
   311        try {
   312          const details_ffi = {};
   313  
   314          if (A.load.Bool(details + 8)) {
   315            details_ffi["tabId"] = A.load.Int64(details + 0);
   316          }
   317  
   318          const _ret = WEBEXT.action.getBadgeBackgroundColor(details_ffi);
   319          A.store.Ref(retPtr, _ret);
   320          return A.H.TRUE;
   321        } catch (err: any) {
   322          A.store.Ref(errPtr, err);
   323          return A.H.FALSE;
   324        }
   325      },
   326      "has_GetBadgeText": (): heap.Ref<boolean> => {
   327        if (WEBEXT?.action && "getBadgeText" in WEBEXT?.action) {
   328          return A.H.TRUE;
   329        }
   330        return A.H.FALSE;
   331      },
   332      "func_GetBadgeText": (fn: Pointer): void => {
   333        A.store.Ref(fn, WEBEXT.action.getBadgeText);
   334      },
   335      "call_GetBadgeText": (retPtr: Pointer, details: Pointer): void => {
   336        const details_ffi = {};
   337  
   338        if (A.load.Bool(details + 8)) {
   339          details_ffi["tabId"] = A.load.Int64(details + 0);
   340        }
   341  
   342        const _ret = WEBEXT.action.getBadgeText(details_ffi);
   343        A.store.Ref(retPtr, _ret);
   344      },
   345      "try_GetBadgeText": (retPtr: Pointer, errPtr: Pointer, details: Pointer): heap.Ref<boolean> => {
   346        try {
   347          const details_ffi = {};
   348  
   349          if (A.load.Bool(details + 8)) {
   350            details_ffi["tabId"] = A.load.Int64(details + 0);
   351          }
   352  
   353          const _ret = WEBEXT.action.getBadgeText(details_ffi);
   354          A.store.Ref(retPtr, _ret);
   355          return A.H.TRUE;
   356        } catch (err: any) {
   357          A.store.Ref(errPtr, err);
   358          return A.H.FALSE;
   359        }
   360      },
   361      "has_GetBadgeTextColor": (): heap.Ref<boolean> => {
   362        if (WEBEXT?.action && "getBadgeTextColor" in WEBEXT?.action) {
   363          return A.H.TRUE;
   364        }
   365        return A.H.FALSE;
   366      },
   367      "func_GetBadgeTextColor": (fn: Pointer): void => {
   368        A.store.Ref(fn, WEBEXT.action.getBadgeTextColor);
   369      },
   370      "call_GetBadgeTextColor": (retPtr: Pointer, details: Pointer): void => {
   371        const details_ffi = {};
   372  
   373        if (A.load.Bool(details + 8)) {
   374          details_ffi["tabId"] = A.load.Int64(details + 0);
   375        }
   376  
   377        const _ret = WEBEXT.action.getBadgeTextColor(details_ffi);
   378        A.store.Ref(retPtr, _ret);
   379      },
   380      "try_GetBadgeTextColor": (retPtr: Pointer, errPtr: Pointer, details: Pointer): heap.Ref<boolean> => {
   381        try {
   382          const details_ffi = {};
   383  
   384          if (A.load.Bool(details + 8)) {
   385            details_ffi["tabId"] = A.load.Int64(details + 0);
   386          }
   387  
   388          const _ret = WEBEXT.action.getBadgeTextColor(details_ffi);
   389          A.store.Ref(retPtr, _ret);
   390          return A.H.TRUE;
   391        } catch (err: any) {
   392          A.store.Ref(errPtr, err);
   393          return A.H.FALSE;
   394        }
   395      },
   396      "has_GetPopup": (): heap.Ref<boolean> => {
   397        if (WEBEXT?.action && "getPopup" in WEBEXT?.action) {
   398          return A.H.TRUE;
   399        }
   400        return A.H.FALSE;
   401      },
   402      "func_GetPopup": (fn: Pointer): void => {
   403        A.store.Ref(fn, WEBEXT.action.getPopup);
   404      },
   405      "call_GetPopup": (retPtr: Pointer, details: Pointer): void => {
   406        const details_ffi = {};
   407  
   408        if (A.load.Bool(details + 8)) {
   409          details_ffi["tabId"] = A.load.Int64(details + 0);
   410        }
   411  
   412        const _ret = WEBEXT.action.getPopup(details_ffi);
   413        A.store.Ref(retPtr, _ret);
   414      },
   415      "try_GetPopup": (retPtr: Pointer, errPtr: Pointer, details: Pointer): heap.Ref<boolean> => {
   416        try {
   417          const details_ffi = {};
   418  
   419          if (A.load.Bool(details + 8)) {
   420            details_ffi["tabId"] = A.load.Int64(details + 0);
   421          }
   422  
   423          const _ret = WEBEXT.action.getPopup(details_ffi);
   424          A.store.Ref(retPtr, _ret);
   425          return A.H.TRUE;
   426        } catch (err: any) {
   427          A.store.Ref(errPtr, err);
   428          return A.H.FALSE;
   429        }
   430      },
   431      "has_GetTitle": (): heap.Ref<boolean> => {
   432        if (WEBEXT?.action && "getTitle" in WEBEXT?.action) {
   433          return A.H.TRUE;
   434        }
   435        return A.H.FALSE;
   436      },
   437      "func_GetTitle": (fn: Pointer): void => {
   438        A.store.Ref(fn, WEBEXT.action.getTitle);
   439      },
   440      "call_GetTitle": (retPtr: Pointer, details: Pointer): void => {
   441        const details_ffi = {};
   442  
   443        if (A.load.Bool(details + 8)) {
   444          details_ffi["tabId"] = A.load.Int64(details + 0);
   445        }
   446  
   447        const _ret = WEBEXT.action.getTitle(details_ffi);
   448        A.store.Ref(retPtr, _ret);
   449      },
   450      "try_GetTitle": (retPtr: Pointer, errPtr: Pointer, details: Pointer): heap.Ref<boolean> => {
   451        try {
   452          const details_ffi = {};
   453  
   454          if (A.load.Bool(details + 8)) {
   455            details_ffi["tabId"] = A.load.Int64(details + 0);
   456          }
   457  
   458          const _ret = WEBEXT.action.getTitle(details_ffi);
   459          A.store.Ref(retPtr, _ret);
   460          return A.H.TRUE;
   461        } catch (err: any) {
   462          A.store.Ref(errPtr, err);
   463          return A.H.FALSE;
   464        }
   465      },
   466      "has_GetUserSettings": (): heap.Ref<boolean> => {
   467        if (WEBEXT?.action && "getUserSettings" in WEBEXT?.action) {
   468          return A.H.TRUE;
   469        }
   470        return A.H.FALSE;
   471      },
   472      "func_GetUserSettings": (fn: Pointer): void => {
   473        A.store.Ref(fn, WEBEXT.action.getUserSettings);
   474      },
   475      "call_GetUserSettings": (retPtr: Pointer): void => {
   476        const _ret = WEBEXT.action.getUserSettings();
   477        A.store.Ref(retPtr, _ret);
   478      },
   479      "try_GetUserSettings": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => {
   480        try {
   481          const _ret = WEBEXT.action.getUserSettings();
   482          A.store.Ref(retPtr, _ret);
   483          return A.H.TRUE;
   484        } catch (err: any) {
   485          A.store.Ref(errPtr, err);
   486          return A.H.FALSE;
   487        }
   488      },
   489      "has_IsEnabled": (): heap.Ref<boolean> => {
   490        if (WEBEXT?.action && "isEnabled" in WEBEXT?.action) {
   491          return A.H.TRUE;
   492        }
   493        return A.H.FALSE;
   494      },
   495      "func_IsEnabled": (fn: Pointer): void => {
   496        A.store.Ref(fn, WEBEXT.action.isEnabled);
   497      },
   498      "call_IsEnabled": (retPtr: Pointer, tabId: number): void => {
   499        const _ret = WEBEXT.action.isEnabled(tabId);
   500        A.store.Ref(retPtr, _ret);
   501      },
   502      "try_IsEnabled": (retPtr: Pointer, errPtr: Pointer, tabId: number): heap.Ref<boolean> => {
   503        try {
   504          const _ret = WEBEXT.action.isEnabled(tabId);
   505          A.store.Ref(retPtr, _ret);
   506          return A.H.TRUE;
   507        } catch (err: any) {
   508          A.store.Ref(errPtr, err);
   509          return A.H.FALSE;
   510        }
   511      },
   512      "has_OnClicked": (): heap.Ref<boolean> => {
   513        if (WEBEXT?.action?.onClicked && "addListener" in WEBEXT?.action?.onClicked) {
   514          return A.H.TRUE;
   515        }
   516        return A.H.FALSE;
   517      },
   518      "func_OnClicked": (fn: Pointer): void => {
   519        A.store.Ref(fn, WEBEXT.action.onClicked.addListener);
   520      },
   521      "call_OnClicked": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   522        const _ret = WEBEXT.action.onClicked.addListener(A.H.get<object>(callback));
   523      },
   524      "try_OnClicked": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   525        try {
   526          const _ret = WEBEXT.action.onClicked.addListener(A.H.get<object>(callback));
   527          return A.H.TRUE;
   528        } catch (err: any) {
   529          A.store.Ref(errPtr, err);
   530          return A.H.FALSE;
   531        }
   532      },
   533      "has_OffClicked": (): heap.Ref<boolean> => {
   534        if (WEBEXT?.action?.onClicked && "removeListener" in WEBEXT?.action?.onClicked) {
   535          return A.H.TRUE;
   536        }
   537        return A.H.FALSE;
   538      },
   539      "func_OffClicked": (fn: Pointer): void => {
   540        A.store.Ref(fn, WEBEXT.action.onClicked.removeListener);
   541      },
   542      "call_OffClicked": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   543        const _ret = WEBEXT.action.onClicked.removeListener(A.H.get<object>(callback));
   544      },
   545      "try_OffClicked": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   546        try {
   547          const _ret = WEBEXT.action.onClicked.removeListener(A.H.get<object>(callback));
   548          return A.H.TRUE;
   549        } catch (err: any) {
   550          A.store.Ref(errPtr, err);
   551          return A.H.FALSE;
   552        }
   553      },
   554      "has_HasOnClicked": (): heap.Ref<boolean> => {
   555        if (WEBEXT?.action?.onClicked && "hasListener" in WEBEXT?.action?.onClicked) {
   556          return A.H.TRUE;
   557        }
   558        return A.H.FALSE;
   559      },
   560      "func_HasOnClicked": (fn: Pointer): void => {
   561        A.store.Ref(fn, WEBEXT.action.onClicked.hasListener);
   562      },
   563      "call_HasOnClicked": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   564        const _ret = WEBEXT.action.onClicked.hasListener(A.H.get<object>(callback));
   565        A.store.Bool(retPtr, _ret);
   566      },
   567      "try_HasOnClicked": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   568        try {
   569          const _ret = WEBEXT.action.onClicked.hasListener(A.H.get<object>(callback));
   570          A.store.Bool(retPtr, _ret);
   571          return A.H.TRUE;
   572        } catch (err: any) {
   573          A.store.Ref(errPtr, err);
   574          return A.H.FALSE;
   575        }
   576      },
   577      "has_OpenPopup": (): heap.Ref<boolean> => {
   578        if (WEBEXT?.action && "openPopup" in WEBEXT?.action) {
   579          return A.H.TRUE;
   580        }
   581        return A.H.FALSE;
   582      },
   583      "func_OpenPopup": (fn: Pointer): void => {
   584        A.store.Ref(fn, WEBEXT.action.openPopup);
   585      },
   586      "call_OpenPopup": (retPtr: Pointer, options: Pointer): void => {
   587        const options_ffi = {};
   588  
   589        if (A.load.Bool(options + 8)) {
   590          options_ffi["windowId"] = A.load.Int64(options + 0);
   591        }
   592  
   593        const _ret = WEBEXT.action.openPopup(options_ffi);
   594        A.store.Ref(retPtr, _ret);
   595      },
   596      "try_OpenPopup": (retPtr: Pointer, errPtr: Pointer, options: Pointer): heap.Ref<boolean> => {
   597        try {
   598          const options_ffi = {};
   599  
   600          if (A.load.Bool(options + 8)) {
   601            options_ffi["windowId"] = A.load.Int64(options + 0);
   602          }
   603  
   604          const _ret = WEBEXT.action.openPopup(options_ffi);
   605          A.store.Ref(retPtr, _ret);
   606          return A.H.TRUE;
   607        } catch (err: any) {
   608          A.store.Ref(errPtr, err);
   609          return A.H.FALSE;
   610        }
   611      },
   612      "has_SetBadgeBackgroundColor": (): heap.Ref<boolean> => {
   613        if (WEBEXT?.action && "setBadgeBackgroundColor" in WEBEXT?.action) {
   614          return A.H.TRUE;
   615        }
   616        return A.H.FALSE;
   617      },
   618      "func_SetBadgeBackgroundColor": (fn: Pointer): void => {
   619        A.store.Ref(fn, WEBEXT.action.setBadgeBackgroundColor);
   620      },
   621      "call_SetBadgeBackgroundColor": (retPtr: Pointer, details: Pointer): void => {
   622        const details_ffi = {};
   623  
   624        details_ffi["color"] = A.load.Ref(details + 0, undefined);
   625        if (A.load.Bool(details + 16)) {
   626          details_ffi["tabId"] = A.load.Int64(details + 8);
   627        }
   628  
   629        const _ret = WEBEXT.action.setBadgeBackgroundColor(details_ffi);
   630        A.store.Ref(retPtr, _ret);
   631      },
   632      "try_SetBadgeBackgroundColor": (retPtr: Pointer, errPtr: Pointer, details: Pointer): heap.Ref<boolean> => {
   633        try {
   634          const details_ffi = {};
   635  
   636          details_ffi["color"] = A.load.Ref(details + 0, undefined);
   637          if (A.load.Bool(details + 16)) {
   638            details_ffi["tabId"] = A.load.Int64(details + 8);
   639          }
   640  
   641          const _ret = WEBEXT.action.setBadgeBackgroundColor(details_ffi);
   642          A.store.Ref(retPtr, _ret);
   643          return A.H.TRUE;
   644        } catch (err: any) {
   645          A.store.Ref(errPtr, err);
   646          return A.H.FALSE;
   647        }
   648      },
   649      "has_SetBadgeText": (): heap.Ref<boolean> => {
   650        if (WEBEXT?.action && "setBadgeText" in WEBEXT?.action) {
   651          return A.H.TRUE;
   652        }
   653        return A.H.FALSE;
   654      },
   655      "func_SetBadgeText": (fn: Pointer): void => {
   656        A.store.Ref(fn, WEBEXT.action.setBadgeText);
   657      },
   658      "call_SetBadgeText": (retPtr: Pointer, details: Pointer): void => {
   659        const details_ffi = {};
   660  
   661        if (A.load.Bool(details + 12)) {
   662          details_ffi["tabId"] = A.load.Int64(details + 0);
   663        }
   664        details_ffi["text"] = A.load.Ref(details + 8, undefined);
   665  
   666        const _ret = WEBEXT.action.setBadgeText(details_ffi);
   667        A.store.Ref(retPtr, _ret);
   668      },
   669      "try_SetBadgeText": (retPtr: Pointer, errPtr: Pointer, details: Pointer): heap.Ref<boolean> => {
   670        try {
   671          const details_ffi = {};
   672  
   673          if (A.load.Bool(details + 12)) {
   674            details_ffi["tabId"] = A.load.Int64(details + 0);
   675          }
   676          details_ffi["text"] = A.load.Ref(details + 8, undefined);
   677  
   678          const _ret = WEBEXT.action.setBadgeText(details_ffi);
   679          A.store.Ref(retPtr, _ret);
   680          return A.H.TRUE;
   681        } catch (err: any) {
   682          A.store.Ref(errPtr, err);
   683          return A.H.FALSE;
   684        }
   685      },
   686      "has_SetBadgeTextColor": (): heap.Ref<boolean> => {
   687        if (WEBEXT?.action && "setBadgeTextColor" in WEBEXT?.action) {
   688          return A.H.TRUE;
   689        }
   690        return A.H.FALSE;
   691      },
   692      "func_SetBadgeTextColor": (fn: Pointer): void => {
   693        A.store.Ref(fn, WEBEXT.action.setBadgeTextColor);
   694      },
   695      "call_SetBadgeTextColor": (retPtr: Pointer, details: Pointer): void => {
   696        const details_ffi = {};
   697  
   698        details_ffi["color"] = A.load.Ref(details + 0, undefined);
   699        if (A.load.Bool(details + 16)) {
   700          details_ffi["tabId"] = A.load.Int64(details + 8);
   701        }
   702  
   703        const _ret = WEBEXT.action.setBadgeTextColor(details_ffi);
   704        A.store.Ref(retPtr, _ret);
   705      },
   706      "try_SetBadgeTextColor": (retPtr: Pointer, errPtr: Pointer, details: Pointer): heap.Ref<boolean> => {
   707        try {
   708          const details_ffi = {};
   709  
   710          details_ffi["color"] = A.load.Ref(details + 0, undefined);
   711          if (A.load.Bool(details + 16)) {
   712            details_ffi["tabId"] = A.load.Int64(details + 8);
   713          }
   714  
   715          const _ret = WEBEXT.action.setBadgeTextColor(details_ffi);
   716          A.store.Ref(retPtr, _ret);
   717          return A.H.TRUE;
   718        } catch (err: any) {
   719          A.store.Ref(errPtr, err);
   720          return A.H.FALSE;
   721        }
   722      },
   723      "has_SetIcon": (): heap.Ref<boolean> => {
   724        if (WEBEXT?.action && "setIcon" in WEBEXT?.action) {
   725          return A.H.TRUE;
   726        }
   727        return A.H.FALSE;
   728      },
   729      "func_SetIcon": (fn: Pointer): void => {
   730        A.store.Ref(fn, WEBEXT.action.setIcon);
   731      },
   732      "call_SetIcon": (retPtr: Pointer, details: Pointer): void => {
   733        const details_ffi = {};
   734  
   735        details_ffi["imageData"] = A.load.Ref(details + 0, undefined);
   736        details_ffi["path"] = A.load.Ref(details + 4, undefined);
   737        if (A.load.Bool(details + 16)) {
   738          details_ffi["tabId"] = A.load.Int64(details + 8);
   739        }
   740  
   741        const _ret = WEBEXT.action.setIcon(details_ffi);
   742        A.store.Ref(retPtr, _ret);
   743      },
   744      "try_SetIcon": (retPtr: Pointer, errPtr: Pointer, details: Pointer): heap.Ref<boolean> => {
   745        try {
   746          const details_ffi = {};
   747  
   748          details_ffi["imageData"] = A.load.Ref(details + 0, undefined);
   749          details_ffi["path"] = A.load.Ref(details + 4, undefined);
   750          if (A.load.Bool(details + 16)) {
   751            details_ffi["tabId"] = A.load.Int64(details + 8);
   752          }
   753  
   754          const _ret = WEBEXT.action.setIcon(details_ffi);
   755          A.store.Ref(retPtr, _ret);
   756          return A.H.TRUE;
   757        } catch (err: any) {
   758          A.store.Ref(errPtr, err);
   759          return A.H.FALSE;
   760        }
   761      },
   762      "has_SetPopup": (): heap.Ref<boolean> => {
   763        if (WEBEXT?.action && "setPopup" in WEBEXT?.action) {
   764          return A.H.TRUE;
   765        }
   766        return A.H.FALSE;
   767      },
   768      "func_SetPopup": (fn: Pointer): void => {
   769        A.store.Ref(fn, WEBEXT.action.setPopup);
   770      },
   771      "call_SetPopup": (retPtr: Pointer, details: Pointer): void => {
   772        const details_ffi = {};
   773  
   774        details_ffi["popup"] = A.load.Ref(details + 0, undefined);
   775        if (A.load.Bool(details + 16)) {
   776          details_ffi["tabId"] = A.load.Int64(details + 8);
   777        }
   778  
   779        const _ret = WEBEXT.action.setPopup(details_ffi);
   780        A.store.Ref(retPtr, _ret);
   781      },
   782      "try_SetPopup": (retPtr: Pointer, errPtr: Pointer, details: Pointer): heap.Ref<boolean> => {
   783        try {
   784          const details_ffi = {};
   785  
   786          details_ffi["popup"] = A.load.Ref(details + 0, undefined);
   787          if (A.load.Bool(details + 16)) {
   788            details_ffi["tabId"] = A.load.Int64(details + 8);
   789          }
   790  
   791          const _ret = WEBEXT.action.setPopup(details_ffi);
   792          A.store.Ref(retPtr, _ret);
   793          return A.H.TRUE;
   794        } catch (err: any) {
   795          A.store.Ref(errPtr, err);
   796          return A.H.FALSE;
   797        }
   798      },
   799      "has_SetTitle": (): heap.Ref<boolean> => {
   800        if (WEBEXT?.action && "setTitle" in WEBEXT?.action) {
   801          return A.H.TRUE;
   802        }
   803        return A.H.FALSE;
   804      },
   805      "func_SetTitle": (fn: Pointer): void => {
   806        A.store.Ref(fn, WEBEXT.action.setTitle);
   807      },
   808      "call_SetTitle": (retPtr: Pointer, details: Pointer): void => {
   809        const details_ffi = {};
   810  
   811        if (A.load.Bool(details + 12)) {
   812          details_ffi["tabId"] = A.load.Int64(details + 0);
   813        }
   814        details_ffi["title"] = A.load.Ref(details + 8, undefined);
   815  
   816        const _ret = WEBEXT.action.setTitle(details_ffi);
   817        A.store.Ref(retPtr, _ret);
   818      },
   819      "try_SetTitle": (retPtr: Pointer, errPtr: Pointer, details: Pointer): heap.Ref<boolean> => {
   820        try {
   821          const details_ffi = {};
   822  
   823          if (A.load.Bool(details + 12)) {
   824            details_ffi["tabId"] = A.load.Int64(details + 0);
   825          }
   826          details_ffi["title"] = A.load.Ref(details + 8, undefined);
   827  
   828          const _ret = WEBEXT.action.setTitle(details_ffi);
   829          A.store.Ref(retPtr, _ret);
   830          return A.H.TRUE;
   831        } catch (err: any) {
   832          A.store.Ref(errPtr, err);
   833          return A.H.FALSE;
   834        }
   835      },
   836    };
   837  });