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

     1  import { importModule, Application, heap, Pointer } from "@ffi";
     2  
     3  importModule("plat/js/webext/safebrowsingprivate", (A: Application) => {
     4    const WEBEXT = typeof globalThis.browser === "undefined" ? globalThis.chrome : globalThis.browser;
     5  
     6    return {
     7      "store_DangerousDownloadInfo": (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 + 16, false);
    12          A.store.Ref(ptr + 0, undefined);
    13          A.store.Ref(ptr + 4, undefined);
    14          A.store.Ref(ptr + 8, undefined);
    15          A.store.Ref(ptr + 12, undefined);
    16        } else {
    17          A.store.Bool(ptr + 16, true);
    18          A.store.Ref(ptr + 0, x["url"]);
    19          A.store.Ref(ptr + 4, x["fileName"]);
    20          A.store.Ref(ptr + 8, x["downloadDigestSha256"]);
    21          A.store.Ref(ptr + 12, x["userName"]);
    22        }
    23      },
    24      "load_DangerousDownloadInfo": (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        x["url"] = A.load.Ref(ptr + 0, undefined);
    28        x["fileName"] = A.load.Ref(ptr + 4, undefined);
    29        x["downloadDigestSha256"] = A.load.Ref(ptr + 8, undefined);
    30        x["userName"] = A.load.Ref(ptr + 12, undefined);
    31        return create === A.H.TRUE ? A.H.push(x) : ref;
    32      },
    33      "constof_URLType": (ref: heap.Ref<string>): number => {
    34        const idx = [
    35          "EVENT_URL",
    36          "LANDING_PAGE",
    37          "LANDING_REFERRER",
    38          "CLIENT_REDIRECT",
    39          "RECENT_NAVIGATION",
    40          "REFERRER",
    41        ].indexOf(A.H.get(ref));
    42        return idx < 0 ? 0 : idx + 1;
    43      },
    44  
    45      "store_ServerRedirect": (ptr: Pointer, ref: heap.Ref<any>) => {
    46        const x = A.H.get<any>(ref);
    47  
    48        if (typeof x === "undefined") {
    49          A.store.Bool(ptr + 4, false);
    50          A.store.Ref(ptr + 0, undefined);
    51        } else {
    52          A.store.Bool(ptr + 4, true);
    53          A.store.Ref(ptr + 0, x["url"]);
    54        }
    55      },
    56      "load_ServerRedirect": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
    57        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
    58  
    59        x["url"] = A.load.Ref(ptr + 0, undefined);
    60        return create === A.H.TRUE ? A.H.push(x) : ref;
    61      },
    62      "constof_NavigationInitiation": (ref: heap.Ref<string>): number => {
    63        const idx = [
    64          "BROWSER_INITIATED",
    65          "RENDERER_INITIATED_WITHOUT_USER_GESTURE",
    66          "RENDERER_INITIATED_WITH_USER_GESTURE",
    67          "COPY_PASTE_USER_INITIATED",
    68          "NOTIFICATION_INITIATED",
    69        ].indexOf(A.H.get(ref));
    70        return idx < 0 ? 0 : idx + 1;
    71      },
    72  
    73      "store_ReferrerChainEntry": (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 + 58, false);
    78          A.store.Ref(ptr + 0, undefined);
    79          A.store.Ref(ptr + 4, undefined);
    80          A.store.Enum(ptr + 8, -1);
    81          A.store.Ref(ptr + 12, undefined);
    82          A.store.Ref(ptr + 16, undefined);
    83          A.store.Ref(ptr + 20, undefined);
    84          A.store.Bool(ptr + 52, false);
    85          A.store.Bool(ptr + 24, false);
    86          A.store.Bool(ptr + 53, false);
    87          A.store.Float64(ptr + 32, 0);
    88          A.store.Ref(ptr + 40, undefined);
    89          A.store.Enum(ptr + 44, -1);
    90          A.store.Bool(ptr + 54, false);
    91          A.store.Bool(ptr + 48, false);
    92          A.store.Bool(ptr + 55, false);
    93          A.store.Bool(ptr + 49, false);
    94          A.store.Bool(ptr + 56, false);
    95          A.store.Bool(ptr + 50, false);
    96          A.store.Bool(ptr + 57, false);
    97          A.store.Bool(ptr + 51, false);
    98        } else {
    99          A.store.Bool(ptr + 58, true);
   100          A.store.Ref(ptr + 0, x["url"]);
   101          A.store.Ref(ptr + 4, x["mainFrameUrl"]);
   102          A.store.Enum(
   103            ptr + 8,
   104            ["EVENT_URL", "LANDING_PAGE", "LANDING_REFERRER", "CLIENT_REDIRECT", "RECENT_NAVIGATION", "REFERRER"].indexOf(
   105              x["urlType"] as string
   106            )
   107          );
   108          A.store.Ref(ptr + 12, x["ipAddresses"]);
   109          A.store.Ref(ptr + 16, x["referrerUrl"]);
   110          A.store.Ref(ptr + 20, x["referrerMainFrameUrl"]);
   111          A.store.Bool(ptr + 52, "isRetargeting" in x ? true : false);
   112          A.store.Bool(ptr + 24, x["isRetargeting"] ? true : false);
   113          A.store.Bool(ptr + 53, "navigationTimeMs" in x ? true : false);
   114          A.store.Float64(ptr + 32, x["navigationTimeMs"] === undefined ? 0 : (x["navigationTimeMs"] as number));
   115          A.store.Ref(ptr + 40, x["serverRedirectChain"]);
   116          A.store.Enum(
   117            ptr + 44,
   118            [
   119              "BROWSER_INITIATED",
   120              "RENDERER_INITIATED_WITHOUT_USER_GESTURE",
   121              "RENDERER_INITIATED_WITH_USER_GESTURE",
   122              "COPY_PASTE_USER_INITIATED",
   123              "NOTIFICATION_INITIATED",
   124            ].indexOf(x["navigationInitiation"] as string)
   125          );
   126          A.store.Bool(ptr + 54, "maybeLaunchedByExternalApp" in x ? true : false);
   127          A.store.Bool(ptr + 48, x["maybeLaunchedByExternalApp"] ? true : false);
   128          A.store.Bool(ptr + 55, "isSubframeUrlRemoved" in x ? true : false);
   129          A.store.Bool(ptr + 49, x["isSubframeUrlRemoved"] ? true : false);
   130          A.store.Bool(ptr + 56, "isSubframeReferrerUrlRemoved" in x ? true : false);
   131          A.store.Bool(ptr + 50, x["isSubframeReferrerUrlRemoved"] ? true : false);
   132          A.store.Bool(ptr + 57, "isUrlRemovedByPolicy" in x ? true : false);
   133          A.store.Bool(ptr + 51, x["isUrlRemovedByPolicy"] ? true : false);
   134        }
   135      },
   136      "load_ReferrerChainEntry": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   137        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   138  
   139        x["url"] = A.load.Ref(ptr + 0, undefined);
   140        x["mainFrameUrl"] = A.load.Ref(ptr + 4, undefined);
   141        x["urlType"] = A.load.Enum(ptr + 8, [
   142          "EVENT_URL",
   143          "LANDING_PAGE",
   144          "LANDING_REFERRER",
   145          "CLIENT_REDIRECT",
   146          "RECENT_NAVIGATION",
   147          "REFERRER",
   148        ]);
   149        x["ipAddresses"] = A.load.Ref(ptr + 12, undefined);
   150        x["referrerUrl"] = A.load.Ref(ptr + 16, undefined);
   151        x["referrerMainFrameUrl"] = A.load.Ref(ptr + 20, undefined);
   152        if (A.load.Bool(ptr + 52)) {
   153          x["isRetargeting"] = A.load.Bool(ptr + 24);
   154        } else {
   155          delete x["isRetargeting"];
   156        }
   157        if (A.load.Bool(ptr + 53)) {
   158          x["navigationTimeMs"] = A.load.Float64(ptr + 32);
   159        } else {
   160          delete x["navigationTimeMs"];
   161        }
   162        x["serverRedirectChain"] = A.load.Ref(ptr + 40, undefined);
   163        x["navigationInitiation"] = A.load.Enum(ptr + 44, [
   164          "BROWSER_INITIATED",
   165          "RENDERER_INITIATED_WITHOUT_USER_GESTURE",
   166          "RENDERER_INITIATED_WITH_USER_GESTURE",
   167          "COPY_PASTE_USER_INITIATED",
   168          "NOTIFICATION_INITIATED",
   169        ]);
   170        if (A.load.Bool(ptr + 54)) {
   171          x["maybeLaunchedByExternalApp"] = A.load.Bool(ptr + 48);
   172        } else {
   173          delete x["maybeLaunchedByExternalApp"];
   174        }
   175        if (A.load.Bool(ptr + 55)) {
   176          x["isSubframeUrlRemoved"] = A.load.Bool(ptr + 49);
   177        } else {
   178          delete x["isSubframeUrlRemoved"];
   179        }
   180        if (A.load.Bool(ptr + 56)) {
   181          x["isSubframeReferrerUrlRemoved"] = A.load.Bool(ptr + 50);
   182        } else {
   183          delete x["isSubframeReferrerUrlRemoved"];
   184        }
   185        if (A.load.Bool(ptr + 57)) {
   186          x["isUrlRemovedByPolicy"] = A.load.Bool(ptr + 51);
   187        } else {
   188          delete x["isUrlRemovedByPolicy"];
   189        }
   190        return create === A.H.TRUE ? A.H.push(x) : ref;
   191      },
   192  
   193      "store_InterstitialInfo": (ptr: Pointer, ref: heap.Ref<any>) => {
   194        const x = A.H.get<any>(ref);
   195  
   196        if (typeof x === "undefined") {
   197          A.store.Bool(ptr + 16, false);
   198          A.store.Ref(ptr + 0, undefined);
   199          A.store.Ref(ptr + 4, undefined);
   200          A.store.Ref(ptr + 8, undefined);
   201          A.store.Ref(ptr + 12, undefined);
   202        } else {
   203          A.store.Bool(ptr + 16, true);
   204          A.store.Ref(ptr + 0, x["url"]);
   205          A.store.Ref(ptr + 4, x["reason"]);
   206          A.store.Ref(ptr + 8, x["netErrorCode"]);
   207          A.store.Ref(ptr + 12, x["userName"]);
   208        }
   209      },
   210      "load_InterstitialInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   211        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   212  
   213        x["url"] = A.load.Ref(ptr + 0, undefined);
   214        x["reason"] = A.load.Ref(ptr + 4, undefined);
   215        x["netErrorCode"] = A.load.Ref(ptr + 8, undefined);
   216        x["userName"] = A.load.Ref(ptr + 12, undefined);
   217        return create === A.H.TRUE ? A.H.push(x) : ref;
   218      },
   219  
   220      "store_PolicySpecifiedPasswordReuse": (ptr: Pointer, ref: heap.Ref<any>) => {
   221        const x = A.H.get<any>(ref);
   222  
   223        if (typeof x === "undefined") {
   224          A.store.Bool(ptr + 10, false);
   225          A.store.Ref(ptr + 0, undefined);
   226          A.store.Ref(ptr + 4, undefined);
   227          A.store.Bool(ptr + 9, false);
   228          A.store.Bool(ptr + 8, false);
   229        } else {
   230          A.store.Bool(ptr + 10, true);
   231          A.store.Ref(ptr + 0, x["url"]);
   232          A.store.Ref(ptr + 4, x["userName"]);
   233          A.store.Bool(ptr + 9, "isPhishingUrl" in x ? true : false);
   234          A.store.Bool(ptr + 8, x["isPhishingUrl"] ? true : false);
   235        }
   236      },
   237      "load_PolicySpecifiedPasswordReuse": (
   238        ptr: Pointer,
   239        create: heap.Ref<boolean>,
   240        ref: heap.Ref<any>
   241      ): heap.Ref<any> => {
   242        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   243  
   244        x["url"] = A.load.Ref(ptr + 0, undefined);
   245        x["userName"] = A.load.Ref(ptr + 4, undefined);
   246        if (A.load.Bool(ptr + 9)) {
   247          x["isPhishingUrl"] = A.load.Bool(ptr + 8);
   248        } else {
   249          delete x["isPhishingUrl"];
   250        }
   251        return create === A.H.TRUE ? A.H.push(x) : ref;
   252      },
   253      "has_GetReferrerChain": (): heap.Ref<boolean> => {
   254        if (WEBEXT?.safeBrowsingPrivate && "getReferrerChain" in WEBEXT?.safeBrowsingPrivate) {
   255          return A.H.TRUE;
   256        }
   257        return A.H.FALSE;
   258      },
   259      "func_GetReferrerChain": (fn: Pointer): void => {
   260        A.store.Ref(fn, WEBEXT.safeBrowsingPrivate.getReferrerChain);
   261      },
   262      "call_GetReferrerChain": (retPtr: Pointer, tabId: number): void => {
   263        const _ret = WEBEXT.safeBrowsingPrivate.getReferrerChain(tabId);
   264        A.store.Ref(retPtr, _ret);
   265      },
   266      "try_GetReferrerChain": (retPtr: Pointer, errPtr: Pointer, tabId: number): heap.Ref<boolean> => {
   267        try {
   268          const _ret = WEBEXT.safeBrowsingPrivate.getReferrerChain(tabId);
   269          A.store.Ref(retPtr, _ret);
   270          return A.H.TRUE;
   271        } catch (err: any) {
   272          A.store.Ref(errPtr, err);
   273          return A.H.FALSE;
   274        }
   275      },
   276      "has_OnDangerousDownloadOpened": (): heap.Ref<boolean> => {
   277        if (
   278          WEBEXT?.safeBrowsingPrivate?.onDangerousDownloadOpened &&
   279          "addListener" in WEBEXT?.safeBrowsingPrivate?.onDangerousDownloadOpened
   280        ) {
   281          return A.H.TRUE;
   282        }
   283        return A.H.FALSE;
   284      },
   285      "func_OnDangerousDownloadOpened": (fn: Pointer): void => {
   286        A.store.Ref(fn, WEBEXT.safeBrowsingPrivate.onDangerousDownloadOpened.addListener);
   287      },
   288      "call_OnDangerousDownloadOpened": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   289        const _ret = WEBEXT.safeBrowsingPrivate.onDangerousDownloadOpened.addListener(A.H.get<object>(callback));
   290      },
   291      "try_OnDangerousDownloadOpened": (
   292        retPtr: Pointer,
   293        errPtr: Pointer,
   294        callback: heap.Ref<object>
   295      ): heap.Ref<boolean> => {
   296        try {
   297          const _ret = WEBEXT.safeBrowsingPrivate.onDangerousDownloadOpened.addListener(A.H.get<object>(callback));
   298          return A.H.TRUE;
   299        } catch (err: any) {
   300          A.store.Ref(errPtr, err);
   301          return A.H.FALSE;
   302        }
   303      },
   304      "has_OffDangerousDownloadOpened": (): heap.Ref<boolean> => {
   305        if (
   306          WEBEXT?.safeBrowsingPrivate?.onDangerousDownloadOpened &&
   307          "removeListener" in WEBEXT?.safeBrowsingPrivate?.onDangerousDownloadOpened
   308        ) {
   309          return A.H.TRUE;
   310        }
   311        return A.H.FALSE;
   312      },
   313      "func_OffDangerousDownloadOpened": (fn: Pointer): void => {
   314        A.store.Ref(fn, WEBEXT.safeBrowsingPrivate.onDangerousDownloadOpened.removeListener);
   315      },
   316      "call_OffDangerousDownloadOpened": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   317        const _ret = WEBEXT.safeBrowsingPrivate.onDangerousDownloadOpened.removeListener(A.H.get<object>(callback));
   318      },
   319      "try_OffDangerousDownloadOpened": (
   320        retPtr: Pointer,
   321        errPtr: Pointer,
   322        callback: heap.Ref<object>
   323      ): heap.Ref<boolean> => {
   324        try {
   325          const _ret = WEBEXT.safeBrowsingPrivate.onDangerousDownloadOpened.removeListener(A.H.get<object>(callback));
   326          return A.H.TRUE;
   327        } catch (err: any) {
   328          A.store.Ref(errPtr, err);
   329          return A.H.FALSE;
   330        }
   331      },
   332      "has_HasOnDangerousDownloadOpened": (): heap.Ref<boolean> => {
   333        if (
   334          WEBEXT?.safeBrowsingPrivate?.onDangerousDownloadOpened &&
   335          "hasListener" in WEBEXT?.safeBrowsingPrivate?.onDangerousDownloadOpened
   336        ) {
   337          return A.H.TRUE;
   338        }
   339        return A.H.FALSE;
   340      },
   341      "func_HasOnDangerousDownloadOpened": (fn: Pointer): void => {
   342        A.store.Ref(fn, WEBEXT.safeBrowsingPrivate.onDangerousDownloadOpened.hasListener);
   343      },
   344      "call_HasOnDangerousDownloadOpened": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   345        const _ret = WEBEXT.safeBrowsingPrivate.onDangerousDownloadOpened.hasListener(A.H.get<object>(callback));
   346        A.store.Bool(retPtr, _ret);
   347      },
   348      "try_HasOnDangerousDownloadOpened": (
   349        retPtr: Pointer,
   350        errPtr: Pointer,
   351        callback: heap.Ref<object>
   352      ): heap.Ref<boolean> => {
   353        try {
   354          const _ret = WEBEXT.safeBrowsingPrivate.onDangerousDownloadOpened.hasListener(A.H.get<object>(callback));
   355          A.store.Bool(retPtr, _ret);
   356          return A.H.TRUE;
   357        } catch (err: any) {
   358          A.store.Ref(errPtr, err);
   359          return A.H.FALSE;
   360        }
   361      },
   362      "has_OnPolicySpecifiedPasswordChanged": (): heap.Ref<boolean> => {
   363        if (
   364          WEBEXT?.safeBrowsingPrivate?.onPolicySpecifiedPasswordChanged &&
   365          "addListener" in WEBEXT?.safeBrowsingPrivate?.onPolicySpecifiedPasswordChanged
   366        ) {
   367          return A.H.TRUE;
   368        }
   369        return A.H.FALSE;
   370      },
   371      "func_OnPolicySpecifiedPasswordChanged": (fn: Pointer): void => {
   372        A.store.Ref(fn, WEBEXT.safeBrowsingPrivate.onPolicySpecifiedPasswordChanged.addListener);
   373      },
   374      "call_OnPolicySpecifiedPasswordChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   375        const _ret = WEBEXT.safeBrowsingPrivate.onPolicySpecifiedPasswordChanged.addListener(A.H.get<object>(callback));
   376      },
   377      "try_OnPolicySpecifiedPasswordChanged": (
   378        retPtr: Pointer,
   379        errPtr: Pointer,
   380        callback: heap.Ref<object>
   381      ): heap.Ref<boolean> => {
   382        try {
   383          const _ret = WEBEXT.safeBrowsingPrivate.onPolicySpecifiedPasswordChanged.addListener(A.H.get<object>(callback));
   384          return A.H.TRUE;
   385        } catch (err: any) {
   386          A.store.Ref(errPtr, err);
   387          return A.H.FALSE;
   388        }
   389      },
   390      "has_OffPolicySpecifiedPasswordChanged": (): heap.Ref<boolean> => {
   391        if (
   392          WEBEXT?.safeBrowsingPrivate?.onPolicySpecifiedPasswordChanged &&
   393          "removeListener" in WEBEXT?.safeBrowsingPrivate?.onPolicySpecifiedPasswordChanged
   394        ) {
   395          return A.H.TRUE;
   396        }
   397        return A.H.FALSE;
   398      },
   399      "func_OffPolicySpecifiedPasswordChanged": (fn: Pointer): void => {
   400        A.store.Ref(fn, WEBEXT.safeBrowsingPrivate.onPolicySpecifiedPasswordChanged.removeListener);
   401      },
   402      "call_OffPolicySpecifiedPasswordChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   403        const _ret = WEBEXT.safeBrowsingPrivate.onPolicySpecifiedPasswordChanged.removeListener(
   404          A.H.get<object>(callback)
   405        );
   406      },
   407      "try_OffPolicySpecifiedPasswordChanged": (
   408        retPtr: Pointer,
   409        errPtr: Pointer,
   410        callback: heap.Ref<object>
   411      ): heap.Ref<boolean> => {
   412        try {
   413          const _ret = WEBEXT.safeBrowsingPrivate.onPolicySpecifiedPasswordChanged.removeListener(
   414            A.H.get<object>(callback)
   415          );
   416          return A.H.TRUE;
   417        } catch (err: any) {
   418          A.store.Ref(errPtr, err);
   419          return A.H.FALSE;
   420        }
   421      },
   422      "has_HasOnPolicySpecifiedPasswordChanged": (): heap.Ref<boolean> => {
   423        if (
   424          WEBEXT?.safeBrowsingPrivate?.onPolicySpecifiedPasswordChanged &&
   425          "hasListener" in WEBEXT?.safeBrowsingPrivate?.onPolicySpecifiedPasswordChanged
   426        ) {
   427          return A.H.TRUE;
   428        }
   429        return A.H.FALSE;
   430      },
   431      "func_HasOnPolicySpecifiedPasswordChanged": (fn: Pointer): void => {
   432        A.store.Ref(fn, WEBEXT.safeBrowsingPrivate.onPolicySpecifiedPasswordChanged.hasListener);
   433      },
   434      "call_HasOnPolicySpecifiedPasswordChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   435        const _ret = WEBEXT.safeBrowsingPrivate.onPolicySpecifiedPasswordChanged.hasListener(A.H.get<object>(callback));
   436        A.store.Bool(retPtr, _ret);
   437      },
   438      "try_HasOnPolicySpecifiedPasswordChanged": (
   439        retPtr: Pointer,
   440        errPtr: Pointer,
   441        callback: heap.Ref<object>
   442      ): heap.Ref<boolean> => {
   443        try {
   444          const _ret = WEBEXT.safeBrowsingPrivate.onPolicySpecifiedPasswordChanged.hasListener(A.H.get<object>(callback));
   445          A.store.Bool(retPtr, _ret);
   446          return A.H.TRUE;
   447        } catch (err: any) {
   448          A.store.Ref(errPtr, err);
   449          return A.H.FALSE;
   450        }
   451      },
   452      "has_OnPolicySpecifiedPasswordReuseDetected": (): heap.Ref<boolean> => {
   453        if (
   454          WEBEXT?.safeBrowsingPrivate?.onPolicySpecifiedPasswordReuseDetected &&
   455          "addListener" in WEBEXT?.safeBrowsingPrivate?.onPolicySpecifiedPasswordReuseDetected
   456        ) {
   457          return A.H.TRUE;
   458        }
   459        return A.H.FALSE;
   460      },
   461      "func_OnPolicySpecifiedPasswordReuseDetected": (fn: Pointer): void => {
   462        A.store.Ref(fn, WEBEXT.safeBrowsingPrivate.onPolicySpecifiedPasswordReuseDetected.addListener);
   463      },
   464      "call_OnPolicySpecifiedPasswordReuseDetected": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   465        const _ret = WEBEXT.safeBrowsingPrivate.onPolicySpecifiedPasswordReuseDetected.addListener(
   466          A.H.get<object>(callback)
   467        );
   468      },
   469      "try_OnPolicySpecifiedPasswordReuseDetected": (
   470        retPtr: Pointer,
   471        errPtr: Pointer,
   472        callback: heap.Ref<object>
   473      ): heap.Ref<boolean> => {
   474        try {
   475          const _ret = WEBEXT.safeBrowsingPrivate.onPolicySpecifiedPasswordReuseDetected.addListener(
   476            A.H.get<object>(callback)
   477          );
   478          return A.H.TRUE;
   479        } catch (err: any) {
   480          A.store.Ref(errPtr, err);
   481          return A.H.FALSE;
   482        }
   483      },
   484      "has_OffPolicySpecifiedPasswordReuseDetected": (): heap.Ref<boolean> => {
   485        if (
   486          WEBEXT?.safeBrowsingPrivate?.onPolicySpecifiedPasswordReuseDetected &&
   487          "removeListener" in WEBEXT?.safeBrowsingPrivate?.onPolicySpecifiedPasswordReuseDetected
   488        ) {
   489          return A.H.TRUE;
   490        }
   491        return A.H.FALSE;
   492      },
   493      "func_OffPolicySpecifiedPasswordReuseDetected": (fn: Pointer): void => {
   494        A.store.Ref(fn, WEBEXT.safeBrowsingPrivate.onPolicySpecifiedPasswordReuseDetected.removeListener);
   495      },
   496      "call_OffPolicySpecifiedPasswordReuseDetected": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   497        const _ret = WEBEXT.safeBrowsingPrivate.onPolicySpecifiedPasswordReuseDetected.removeListener(
   498          A.H.get<object>(callback)
   499        );
   500      },
   501      "try_OffPolicySpecifiedPasswordReuseDetected": (
   502        retPtr: Pointer,
   503        errPtr: Pointer,
   504        callback: heap.Ref<object>
   505      ): heap.Ref<boolean> => {
   506        try {
   507          const _ret = WEBEXT.safeBrowsingPrivate.onPolicySpecifiedPasswordReuseDetected.removeListener(
   508            A.H.get<object>(callback)
   509          );
   510          return A.H.TRUE;
   511        } catch (err: any) {
   512          A.store.Ref(errPtr, err);
   513          return A.H.FALSE;
   514        }
   515      },
   516      "has_HasOnPolicySpecifiedPasswordReuseDetected": (): heap.Ref<boolean> => {
   517        if (
   518          WEBEXT?.safeBrowsingPrivate?.onPolicySpecifiedPasswordReuseDetected &&
   519          "hasListener" in WEBEXT?.safeBrowsingPrivate?.onPolicySpecifiedPasswordReuseDetected
   520        ) {
   521          return A.H.TRUE;
   522        }
   523        return A.H.FALSE;
   524      },
   525      "func_HasOnPolicySpecifiedPasswordReuseDetected": (fn: Pointer): void => {
   526        A.store.Ref(fn, WEBEXT.safeBrowsingPrivate.onPolicySpecifiedPasswordReuseDetected.hasListener);
   527      },
   528      "call_HasOnPolicySpecifiedPasswordReuseDetected": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   529        const _ret = WEBEXT.safeBrowsingPrivate.onPolicySpecifiedPasswordReuseDetected.hasListener(
   530          A.H.get<object>(callback)
   531        );
   532        A.store.Bool(retPtr, _ret);
   533      },
   534      "try_HasOnPolicySpecifiedPasswordReuseDetected": (
   535        retPtr: Pointer,
   536        errPtr: Pointer,
   537        callback: heap.Ref<object>
   538      ): heap.Ref<boolean> => {
   539        try {
   540          const _ret = WEBEXT.safeBrowsingPrivate.onPolicySpecifiedPasswordReuseDetected.hasListener(
   541            A.H.get<object>(callback)
   542          );
   543          A.store.Bool(retPtr, _ret);
   544          return A.H.TRUE;
   545        } catch (err: any) {
   546          A.store.Ref(errPtr, err);
   547          return A.H.FALSE;
   548        }
   549      },
   550      "has_OnSecurityInterstitialProceeded": (): heap.Ref<boolean> => {
   551        if (
   552          WEBEXT?.safeBrowsingPrivate?.onSecurityInterstitialProceeded &&
   553          "addListener" in WEBEXT?.safeBrowsingPrivate?.onSecurityInterstitialProceeded
   554        ) {
   555          return A.H.TRUE;
   556        }
   557        return A.H.FALSE;
   558      },
   559      "func_OnSecurityInterstitialProceeded": (fn: Pointer): void => {
   560        A.store.Ref(fn, WEBEXT.safeBrowsingPrivate.onSecurityInterstitialProceeded.addListener);
   561      },
   562      "call_OnSecurityInterstitialProceeded": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   563        const _ret = WEBEXT.safeBrowsingPrivate.onSecurityInterstitialProceeded.addListener(A.H.get<object>(callback));
   564      },
   565      "try_OnSecurityInterstitialProceeded": (
   566        retPtr: Pointer,
   567        errPtr: Pointer,
   568        callback: heap.Ref<object>
   569      ): heap.Ref<boolean> => {
   570        try {
   571          const _ret = WEBEXT.safeBrowsingPrivate.onSecurityInterstitialProceeded.addListener(A.H.get<object>(callback));
   572          return A.H.TRUE;
   573        } catch (err: any) {
   574          A.store.Ref(errPtr, err);
   575          return A.H.FALSE;
   576        }
   577      },
   578      "has_OffSecurityInterstitialProceeded": (): heap.Ref<boolean> => {
   579        if (
   580          WEBEXT?.safeBrowsingPrivate?.onSecurityInterstitialProceeded &&
   581          "removeListener" in WEBEXT?.safeBrowsingPrivate?.onSecurityInterstitialProceeded
   582        ) {
   583          return A.H.TRUE;
   584        }
   585        return A.H.FALSE;
   586      },
   587      "func_OffSecurityInterstitialProceeded": (fn: Pointer): void => {
   588        A.store.Ref(fn, WEBEXT.safeBrowsingPrivate.onSecurityInterstitialProceeded.removeListener);
   589      },
   590      "call_OffSecurityInterstitialProceeded": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   591        const _ret = WEBEXT.safeBrowsingPrivate.onSecurityInterstitialProceeded.removeListener(A.H.get<object>(callback));
   592      },
   593      "try_OffSecurityInterstitialProceeded": (
   594        retPtr: Pointer,
   595        errPtr: Pointer,
   596        callback: heap.Ref<object>
   597      ): heap.Ref<boolean> => {
   598        try {
   599          const _ret = WEBEXT.safeBrowsingPrivate.onSecurityInterstitialProceeded.removeListener(
   600            A.H.get<object>(callback)
   601          );
   602          return A.H.TRUE;
   603        } catch (err: any) {
   604          A.store.Ref(errPtr, err);
   605          return A.H.FALSE;
   606        }
   607      },
   608      "has_HasOnSecurityInterstitialProceeded": (): heap.Ref<boolean> => {
   609        if (
   610          WEBEXT?.safeBrowsingPrivate?.onSecurityInterstitialProceeded &&
   611          "hasListener" in WEBEXT?.safeBrowsingPrivate?.onSecurityInterstitialProceeded
   612        ) {
   613          return A.H.TRUE;
   614        }
   615        return A.H.FALSE;
   616      },
   617      "func_HasOnSecurityInterstitialProceeded": (fn: Pointer): void => {
   618        A.store.Ref(fn, WEBEXT.safeBrowsingPrivate.onSecurityInterstitialProceeded.hasListener);
   619      },
   620      "call_HasOnSecurityInterstitialProceeded": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   621        const _ret = WEBEXT.safeBrowsingPrivate.onSecurityInterstitialProceeded.hasListener(A.H.get<object>(callback));
   622        A.store.Bool(retPtr, _ret);
   623      },
   624      "try_HasOnSecurityInterstitialProceeded": (
   625        retPtr: Pointer,
   626        errPtr: Pointer,
   627        callback: heap.Ref<object>
   628      ): heap.Ref<boolean> => {
   629        try {
   630          const _ret = WEBEXT.safeBrowsingPrivate.onSecurityInterstitialProceeded.hasListener(A.H.get<object>(callback));
   631          A.store.Bool(retPtr, _ret);
   632          return A.H.TRUE;
   633        } catch (err: any) {
   634          A.store.Ref(errPtr, err);
   635          return A.H.FALSE;
   636        }
   637      },
   638      "has_OnSecurityInterstitialShown": (): heap.Ref<boolean> => {
   639        if (
   640          WEBEXT?.safeBrowsingPrivate?.onSecurityInterstitialShown &&
   641          "addListener" in WEBEXT?.safeBrowsingPrivate?.onSecurityInterstitialShown
   642        ) {
   643          return A.H.TRUE;
   644        }
   645        return A.H.FALSE;
   646      },
   647      "func_OnSecurityInterstitialShown": (fn: Pointer): void => {
   648        A.store.Ref(fn, WEBEXT.safeBrowsingPrivate.onSecurityInterstitialShown.addListener);
   649      },
   650      "call_OnSecurityInterstitialShown": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   651        const _ret = WEBEXT.safeBrowsingPrivate.onSecurityInterstitialShown.addListener(A.H.get<object>(callback));
   652      },
   653      "try_OnSecurityInterstitialShown": (
   654        retPtr: Pointer,
   655        errPtr: Pointer,
   656        callback: heap.Ref<object>
   657      ): heap.Ref<boolean> => {
   658        try {
   659          const _ret = WEBEXT.safeBrowsingPrivate.onSecurityInterstitialShown.addListener(A.H.get<object>(callback));
   660          return A.H.TRUE;
   661        } catch (err: any) {
   662          A.store.Ref(errPtr, err);
   663          return A.H.FALSE;
   664        }
   665      },
   666      "has_OffSecurityInterstitialShown": (): heap.Ref<boolean> => {
   667        if (
   668          WEBEXT?.safeBrowsingPrivate?.onSecurityInterstitialShown &&
   669          "removeListener" in WEBEXT?.safeBrowsingPrivate?.onSecurityInterstitialShown
   670        ) {
   671          return A.H.TRUE;
   672        }
   673        return A.H.FALSE;
   674      },
   675      "func_OffSecurityInterstitialShown": (fn: Pointer): void => {
   676        A.store.Ref(fn, WEBEXT.safeBrowsingPrivate.onSecurityInterstitialShown.removeListener);
   677      },
   678      "call_OffSecurityInterstitialShown": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   679        const _ret = WEBEXT.safeBrowsingPrivate.onSecurityInterstitialShown.removeListener(A.H.get<object>(callback));
   680      },
   681      "try_OffSecurityInterstitialShown": (
   682        retPtr: Pointer,
   683        errPtr: Pointer,
   684        callback: heap.Ref<object>
   685      ): heap.Ref<boolean> => {
   686        try {
   687          const _ret = WEBEXT.safeBrowsingPrivate.onSecurityInterstitialShown.removeListener(A.H.get<object>(callback));
   688          return A.H.TRUE;
   689        } catch (err: any) {
   690          A.store.Ref(errPtr, err);
   691          return A.H.FALSE;
   692        }
   693      },
   694      "has_HasOnSecurityInterstitialShown": (): heap.Ref<boolean> => {
   695        if (
   696          WEBEXT?.safeBrowsingPrivate?.onSecurityInterstitialShown &&
   697          "hasListener" in WEBEXT?.safeBrowsingPrivate?.onSecurityInterstitialShown
   698        ) {
   699          return A.H.TRUE;
   700        }
   701        return A.H.FALSE;
   702      },
   703      "func_HasOnSecurityInterstitialShown": (fn: Pointer): void => {
   704        A.store.Ref(fn, WEBEXT.safeBrowsingPrivate.onSecurityInterstitialShown.hasListener);
   705      },
   706      "call_HasOnSecurityInterstitialShown": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   707        const _ret = WEBEXT.safeBrowsingPrivate.onSecurityInterstitialShown.hasListener(A.H.get<object>(callback));
   708        A.store.Bool(retPtr, _ret);
   709      },
   710      "try_HasOnSecurityInterstitialShown": (
   711        retPtr: Pointer,
   712        errPtr: Pointer,
   713        callback: heap.Ref<object>
   714      ): heap.Ref<boolean> => {
   715        try {
   716          const _ret = WEBEXT.safeBrowsingPrivate.onSecurityInterstitialShown.hasListener(A.H.get<object>(callback));
   717          A.store.Bool(retPtr, _ret);
   718          return A.H.TRUE;
   719        } catch (err: any) {
   720          A.store.Ref(errPtr, err);
   721          return A.H.FALSE;
   722        }
   723      },
   724    };
   725  });