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

     1  import { importModule, Application, heap, Pointer } from "@ffi";
     2  
     3  importModule("plat/js/webext/feedbackprivate", (A: Application) => {
     4    const WEBEXT = typeof globalThis.browser === "undefined" ? globalThis.chrome : globalThis.browser;
     5  
     6    return {
     7      "store_AttachedFile": (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 + 8, false);
    12          A.store.Ref(ptr + 0, undefined);
    13          A.store.Ref(ptr + 4, undefined);
    14        } else {
    15          A.store.Bool(ptr + 8, true);
    16          A.store.Ref(ptr + 0, x["name"]);
    17          A.store.Ref(ptr + 4, x["data"]);
    18        }
    19      },
    20      "load_AttachedFile": (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        x["name"] = A.load.Ref(ptr + 0, undefined);
    24        x["data"] = A.load.Ref(ptr + 4, undefined);
    25        return create === A.H.TRUE ? A.H.push(x) : ref;
    26      },
    27      "constof_FeedbackFlow": (ref: heap.Ref<string>): number => {
    28        const idx = ["regular", "login", "sadTabCrash", "googleInternal"].indexOf(A.H.get(ref));
    29        return idx < 0 ? 0 : idx + 1;
    30      },
    31  
    32      "store_LogsMapEntry": (ptr: Pointer, ref: heap.Ref<any>) => {
    33        const x = A.H.get<any>(ref);
    34  
    35        if (typeof x === "undefined") {
    36          A.store.Bool(ptr + 8, false);
    37          A.store.Ref(ptr + 0, undefined);
    38          A.store.Ref(ptr + 4, undefined);
    39        } else {
    40          A.store.Bool(ptr + 8, true);
    41          A.store.Ref(ptr + 0, x["key"]);
    42          A.store.Ref(ptr + 4, x["value"]);
    43        }
    44      },
    45      "load_LogsMapEntry": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
    46        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
    47  
    48        x["key"] = A.load.Ref(ptr + 0, undefined);
    49        x["value"] = A.load.Ref(ptr + 4, undefined);
    50        return create === A.H.TRUE ? A.H.push(x) : ref;
    51      },
    52  
    53      "store_FeedbackInfo": (ptr: Pointer, ref: heap.Ref<any>) => {
    54        const x = A.H.get<any>(ref);
    55  
    56        if (typeof x === "undefined") {
    57          A.store.Bool(ptr + 89, false);
    58  
    59          A.store.Bool(ptr + 0 + 8, false);
    60          A.store.Ref(ptr + 0 + 0, undefined);
    61          A.store.Ref(ptr + 0 + 4, undefined);
    62          A.store.Ref(ptr + 12, undefined);
    63          A.store.Ref(ptr + 16, undefined);
    64          A.store.Ref(ptr + 20, undefined);
    65          A.store.Ref(ptr + 24, undefined);
    66          A.store.Ref(ptr + 28, undefined);
    67          A.store.Bool(ptr + 77, false);
    68          A.store.Int32(ptr + 32, 0);
    69          A.store.Ref(ptr + 36, undefined);
    70          A.store.Bool(ptr + 78, false);
    71          A.store.Int32(ptr + 40, 0);
    72          A.store.Ref(ptr + 44, undefined);
    73          A.store.Bool(ptr + 79, false);
    74          A.store.Bool(ptr + 48, false);
    75          A.store.Enum(ptr + 52, -1);
    76          A.store.Ref(ptr + 56, undefined);
    77          A.store.Ref(ptr + 60, undefined);
    78          A.store.Bool(ptr + 80, false);
    79          A.store.Bool(ptr + 64, false);
    80          A.store.Bool(ptr + 81, false);
    81          A.store.Bool(ptr + 65, false);
    82          A.store.Bool(ptr + 82, false);
    83          A.store.Bool(ptr + 66, false);
    84          A.store.Bool(ptr + 83, false);
    85          A.store.Bool(ptr + 67, false);
    86          A.store.Bool(ptr + 84, false);
    87          A.store.Bool(ptr + 68, false);
    88          A.store.Bool(ptr + 85, false);
    89          A.store.Bool(ptr + 69, false);
    90          A.store.Bool(ptr + 86, false);
    91          A.store.Bool(ptr + 70, false);
    92          A.store.Bool(ptr + 87, false);
    93          A.store.Bool(ptr + 71, false);
    94          A.store.Ref(ptr + 72, undefined);
    95          A.store.Bool(ptr + 88, false);
    96          A.store.Bool(ptr + 76, false);
    97        } else {
    98          A.store.Bool(ptr + 89, true);
    99  
   100          if (typeof x["attachedFile"] === "undefined") {
   101            A.store.Bool(ptr + 0 + 8, false);
   102            A.store.Ref(ptr + 0 + 0, undefined);
   103            A.store.Ref(ptr + 0 + 4, undefined);
   104          } else {
   105            A.store.Bool(ptr + 0 + 8, true);
   106            A.store.Ref(ptr + 0 + 0, x["attachedFile"]["name"]);
   107            A.store.Ref(ptr + 0 + 4, x["attachedFile"]["data"]);
   108          }
   109          A.store.Ref(ptr + 12, x["categoryTag"]);
   110          A.store.Ref(ptr + 16, x["description"]);
   111          A.store.Ref(ptr + 20, x["descriptionPlaceholder"]);
   112          A.store.Ref(ptr + 24, x["email"]);
   113          A.store.Ref(ptr + 28, x["pageUrl"]);
   114          A.store.Bool(ptr + 77, "productId" in x ? true : false);
   115          A.store.Int32(ptr + 32, x["productId"] === undefined ? 0 : (x["productId"] as number));
   116          A.store.Ref(ptr + 36, x["screenshot"]);
   117          A.store.Bool(ptr + 78, "traceId" in x ? true : false);
   118          A.store.Int32(ptr + 40, x["traceId"] === undefined ? 0 : (x["traceId"] as number));
   119          A.store.Ref(ptr + 44, x["systemInformation"]);
   120          A.store.Bool(ptr + 79, "sendHistograms" in x ? true : false);
   121          A.store.Bool(ptr + 48, x["sendHistograms"] ? true : false);
   122          A.store.Enum(ptr + 52, ["regular", "login", "sadTabCrash", "googleInternal"].indexOf(x["flow"] as string));
   123          A.store.Ref(ptr + 56, x["attachedFileBlobUuid"]);
   124          A.store.Ref(ptr + 60, x["screenshotBlobUuid"]);
   125          A.store.Bool(ptr + 80, "useSystemWindowFrame" in x ? true : false);
   126          A.store.Bool(ptr + 64, x["useSystemWindowFrame"] ? true : false);
   127          A.store.Bool(ptr + 81, "sendBluetoothLogs" in x ? true : false);
   128          A.store.Bool(ptr + 65, x["sendBluetoothLogs"] ? true : false);
   129          A.store.Bool(ptr + 82, "sendTabTitles" in x ? true : false);
   130          A.store.Bool(ptr + 66, x["sendTabTitles"] ? true : false);
   131          A.store.Bool(ptr + 83, "assistantDebugInfoAllowed" in x ? true : false);
   132          A.store.Bool(ptr + 67, x["assistantDebugInfoAllowed"] ? true : false);
   133          A.store.Bool(ptr + 84, "fromAssistant" in x ? true : false);
   134          A.store.Bool(ptr + 68, x["fromAssistant"] ? true : false);
   135          A.store.Bool(ptr + 85, "includeBluetoothLogs" in x ? true : false);
   136          A.store.Bool(ptr + 69, x["includeBluetoothLogs"] ? true : false);
   137          A.store.Bool(ptr + 86, "showQuestionnaire" in x ? true : false);
   138          A.store.Bool(ptr + 70, x["showQuestionnaire"] ? true : false);
   139          A.store.Bool(ptr + 87, "fromAutofill" in x ? true : false);
   140          A.store.Bool(ptr + 71, x["fromAutofill"] ? true : false);
   141          A.store.Ref(ptr + 72, x["autofillMetadata"]);
   142          A.store.Bool(ptr + 88, "sendAutofillMetadata" in x ? true : false);
   143          A.store.Bool(ptr + 76, x["sendAutofillMetadata"] ? true : false);
   144        }
   145      },
   146      "load_FeedbackInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   147        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   148  
   149        if (A.load.Bool(ptr + 0 + 8)) {
   150          x["attachedFile"] = {};
   151          x["attachedFile"]["name"] = A.load.Ref(ptr + 0 + 0, undefined);
   152          x["attachedFile"]["data"] = A.load.Ref(ptr + 0 + 4, undefined);
   153        } else {
   154          delete x["attachedFile"];
   155        }
   156        x["categoryTag"] = A.load.Ref(ptr + 12, undefined);
   157        x["description"] = A.load.Ref(ptr + 16, undefined);
   158        x["descriptionPlaceholder"] = A.load.Ref(ptr + 20, undefined);
   159        x["email"] = A.load.Ref(ptr + 24, undefined);
   160        x["pageUrl"] = A.load.Ref(ptr + 28, undefined);
   161        if (A.load.Bool(ptr + 77)) {
   162          x["productId"] = A.load.Int32(ptr + 32);
   163        } else {
   164          delete x["productId"];
   165        }
   166        x["screenshot"] = A.load.Ref(ptr + 36, undefined);
   167        if (A.load.Bool(ptr + 78)) {
   168          x["traceId"] = A.load.Int32(ptr + 40);
   169        } else {
   170          delete x["traceId"];
   171        }
   172        x["systemInformation"] = A.load.Ref(ptr + 44, undefined);
   173        if (A.load.Bool(ptr + 79)) {
   174          x["sendHistograms"] = A.load.Bool(ptr + 48);
   175        } else {
   176          delete x["sendHistograms"];
   177        }
   178        x["flow"] = A.load.Enum(ptr + 52, ["regular", "login", "sadTabCrash", "googleInternal"]);
   179        x["attachedFileBlobUuid"] = A.load.Ref(ptr + 56, undefined);
   180        x["screenshotBlobUuid"] = A.load.Ref(ptr + 60, undefined);
   181        if (A.load.Bool(ptr + 80)) {
   182          x["useSystemWindowFrame"] = A.load.Bool(ptr + 64);
   183        } else {
   184          delete x["useSystemWindowFrame"];
   185        }
   186        if (A.load.Bool(ptr + 81)) {
   187          x["sendBluetoothLogs"] = A.load.Bool(ptr + 65);
   188        } else {
   189          delete x["sendBluetoothLogs"];
   190        }
   191        if (A.load.Bool(ptr + 82)) {
   192          x["sendTabTitles"] = A.load.Bool(ptr + 66);
   193        } else {
   194          delete x["sendTabTitles"];
   195        }
   196        if (A.load.Bool(ptr + 83)) {
   197          x["assistantDebugInfoAllowed"] = A.load.Bool(ptr + 67);
   198        } else {
   199          delete x["assistantDebugInfoAllowed"];
   200        }
   201        if (A.load.Bool(ptr + 84)) {
   202          x["fromAssistant"] = A.load.Bool(ptr + 68);
   203        } else {
   204          delete x["fromAssistant"];
   205        }
   206        if (A.load.Bool(ptr + 85)) {
   207          x["includeBluetoothLogs"] = A.load.Bool(ptr + 69);
   208        } else {
   209          delete x["includeBluetoothLogs"];
   210        }
   211        if (A.load.Bool(ptr + 86)) {
   212          x["showQuestionnaire"] = A.load.Bool(ptr + 70);
   213        } else {
   214          delete x["showQuestionnaire"];
   215        }
   216        if (A.load.Bool(ptr + 87)) {
   217          x["fromAutofill"] = A.load.Bool(ptr + 71);
   218        } else {
   219          delete x["fromAutofill"];
   220        }
   221        x["autofillMetadata"] = A.load.Ref(ptr + 72, undefined);
   222        if (A.load.Bool(ptr + 88)) {
   223          x["sendAutofillMetadata"] = A.load.Bool(ptr + 76);
   224        } else {
   225          delete x["sendAutofillMetadata"];
   226        }
   227        return create === A.H.TRUE ? A.H.push(x) : ref;
   228      },
   229      "constof_FeedbackSource": (ref: heap.Ref<string>): number => {
   230        const idx = ["quickoffice"].indexOf(A.H.get(ref));
   231        return idx < 0 ? 0 : idx + 1;
   232      },
   233      "constof_LandingPageType": (ref: heap.Ref<string>): number => {
   234        const idx = ["normal", "techstop", "noLandingPage"].indexOf(A.H.get(ref));
   235        return idx < 0 ? 0 : idx + 1;
   236      },
   237      "constof_LogSource": (ref: heap.Ref<string>): number => {
   238        const idx = [
   239          "messages",
   240          "uiLatest",
   241          "drmModetest",
   242          "lsusb",
   243          "atrusLog",
   244          "netLog",
   245          "eventLog",
   246          "updateEngineLog",
   247          "powerdLatest",
   248          "powerdPrevious",
   249          "lspci",
   250          "ifconfig",
   251          "uptime",
   252        ].indexOf(A.H.get(ref));
   253        return idx < 0 ? 0 : idx + 1;
   254      },
   255  
   256      "store_ReadLogSourceResult": (ptr: Pointer, ref: heap.Ref<any>) => {
   257        const x = A.H.get<any>(ref);
   258  
   259        if (typeof x === "undefined") {
   260          A.store.Bool(ptr + 9, false);
   261          A.store.Bool(ptr + 8, false);
   262          A.store.Int32(ptr + 0, 0);
   263          A.store.Ref(ptr + 4, undefined);
   264        } else {
   265          A.store.Bool(ptr + 9, true);
   266          A.store.Bool(ptr + 8, "readerId" in x ? true : false);
   267          A.store.Int32(ptr + 0, x["readerId"] === undefined ? 0 : (x["readerId"] as number));
   268          A.store.Ref(ptr + 4, x["logLines"]);
   269        }
   270      },
   271      "load_ReadLogSourceResult": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   272        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   273  
   274        if (A.load.Bool(ptr + 8)) {
   275          x["readerId"] = A.load.Int32(ptr + 0);
   276        } else {
   277          delete x["readerId"];
   278        }
   279        x["logLines"] = A.load.Ref(ptr + 4, undefined);
   280        return create === A.H.TRUE ? A.H.push(x) : ref;
   281      },
   282  
   283      "store_ReadLogSourceParams": (ptr: Pointer, ref: heap.Ref<any>) => {
   284        const x = A.H.get<any>(ref);
   285  
   286        if (typeof x === "undefined") {
   287          A.store.Bool(ptr + 14, false);
   288          A.store.Enum(ptr + 0, -1);
   289          A.store.Bool(ptr + 12, false);
   290          A.store.Bool(ptr + 4, false);
   291          A.store.Bool(ptr + 13, false);
   292          A.store.Int32(ptr + 8, 0);
   293        } else {
   294          A.store.Bool(ptr + 14, true);
   295          A.store.Enum(
   296            ptr + 0,
   297            [
   298              "messages",
   299              "uiLatest",
   300              "drmModetest",
   301              "lsusb",
   302              "atrusLog",
   303              "netLog",
   304              "eventLog",
   305              "updateEngineLog",
   306              "powerdLatest",
   307              "powerdPrevious",
   308              "lspci",
   309              "ifconfig",
   310              "uptime",
   311            ].indexOf(x["source"] as string)
   312          );
   313          A.store.Bool(ptr + 12, "incremental" in x ? true : false);
   314          A.store.Bool(ptr + 4, x["incremental"] ? true : false);
   315          A.store.Bool(ptr + 13, "readerId" in x ? true : false);
   316          A.store.Int32(ptr + 8, x["readerId"] === undefined ? 0 : (x["readerId"] as number));
   317        }
   318      },
   319      "load_ReadLogSourceParams": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   320        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   321  
   322        x["source"] = A.load.Enum(ptr + 0, [
   323          "messages",
   324          "uiLatest",
   325          "drmModetest",
   326          "lsusb",
   327          "atrusLog",
   328          "netLog",
   329          "eventLog",
   330          "updateEngineLog",
   331          "powerdLatest",
   332          "powerdPrevious",
   333          "lspci",
   334          "ifconfig",
   335          "uptime",
   336        ]);
   337        if (A.load.Bool(ptr + 12)) {
   338          x["incremental"] = A.load.Bool(ptr + 4);
   339        } else {
   340          delete x["incremental"];
   341        }
   342        if (A.load.Bool(ptr + 13)) {
   343          x["readerId"] = A.load.Int32(ptr + 8);
   344        } else {
   345          delete x["readerId"];
   346        }
   347        return create === A.H.TRUE ? A.H.push(x) : ref;
   348      },
   349      "constof_Status": (ref: heap.Ref<string>): number => {
   350        const idx = ["success", "delayed"].indexOf(A.H.get(ref));
   351        return idx < 0 ? 0 : idx + 1;
   352      },
   353  
   354      "store_SendFeedbackResult": (ptr: Pointer, ref: heap.Ref<any>) => {
   355        const x = A.H.get<any>(ref);
   356  
   357        if (typeof x === "undefined") {
   358          A.store.Bool(ptr + 8, false);
   359          A.store.Enum(ptr + 0, -1);
   360          A.store.Enum(ptr + 4, -1);
   361        } else {
   362          A.store.Bool(ptr + 8, true);
   363          A.store.Enum(ptr + 0, ["success", "delayed"].indexOf(x["status"] as string));
   364          A.store.Enum(ptr + 4, ["normal", "techstop", "noLandingPage"].indexOf(x["landingPageType"] as string));
   365        }
   366      },
   367      "load_SendFeedbackResult": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   368        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   369  
   370        x["status"] = A.load.Enum(ptr + 0, ["success", "delayed"]);
   371        x["landingPageType"] = A.load.Enum(ptr + 4, ["normal", "techstop", "noLandingPage"]);
   372        return create === A.H.TRUE ? A.H.push(x) : ref;
   373      },
   374      "has_GetSystemInformation": (): heap.Ref<boolean> => {
   375        if (WEBEXT?.feedbackPrivate && "getSystemInformation" in WEBEXT?.feedbackPrivate) {
   376          return A.H.TRUE;
   377        }
   378        return A.H.FALSE;
   379      },
   380      "func_GetSystemInformation": (fn: Pointer): void => {
   381        A.store.Ref(fn, WEBEXT.feedbackPrivate.getSystemInformation);
   382      },
   383      "call_GetSystemInformation": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   384        const _ret = WEBEXT.feedbackPrivate.getSystemInformation(A.H.get<object>(callback));
   385      },
   386      "try_GetSystemInformation": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   387        try {
   388          const _ret = WEBEXT.feedbackPrivate.getSystemInformation(A.H.get<object>(callback));
   389          return A.H.TRUE;
   390        } catch (err: any) {
   391          A.store.Ref(errPtr, err);
   392          return A.H.FALSE;
   393        }
   394      },
   395      "has_GetUserEmail": (): heap.Ref<boolean> => {
   396        if (WEBEXT?.feedbackPrivate && "getUserEmail" in WEBEXT?.feedbackPrivate) {
   397          return A.H.TRUE;
   398        }
   399        return A.H.FALSE;
   400      },
   401      "func_GetUserEmail": (fn: Pointer): void => {
   402        A.store.Ref(fn, WEBEXT.feedbackPrivate.getUserEmail);
   403      },
   404      "call_GetUserEmail": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   405        const _ret = WEBEXT.feedbackPrivate.getUserEmail(A.H.get<object>(callback));
   406      },
   407      "try_GetUserEmail": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   408        try {
   409          const _ret = WEBEXT.feedbackPrivate.getUserEmail(A.H.get<object>(callback));
   410          return A.H.TRUE;
   411        } catch (err: any) {
   412          A.store.Ref(errPtr, err);
   413          return A.H.FALSE;
   414        }
   415      },
   416      "has_OnFeedbackRequested": (): heap.Ref<boolean> => {
   417        if (
   418          WEBEXT?.feedbackPrivate?.onFeedbackRequested &&
   419          "addListener" in WEBEXT?.feedbackPrivate?.onFeedbackRequested
   420        ) {
   421          return A.H.TRUE;
   422        }
   423        return A.H.FALSE;
   424      },
   425      "func_OnFeedbackRequested": (fn: Pointer): void => {
   426        A.store.Ref(fn, WEBEXT.feedbackPrivate.onFeedbackRequested.addListener);
   427      },
   428      "call_OnFeedbackRequested": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   429        const _ret = WEBEXT.feedbackPrivate.onFeedbackRequested.addListener(A.H.get<object>(callback));
   430      },
   431      "try_OnFeedbackRequested": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   432        try {
   433          const _ret = WEBEXT.feedbackPrivate.onFeedbackRequested.addListener(A.H.get<object>(callback));
   434          return A.H.TRUE;
   435        } catch (err: any) {
   436          A.store.Ref(errPtr, err);
   437          return A.H.FALSE;
   438        }
   439      },
   440      "has_OffFeedbackRequested": (): heap.Ref<boolean> => {
   441        if (
   442          WEBEXT?.feedbackPrivate?.onFeedbackRequested &&
   443          "removeListener" in WEBEXT?.feedbackPrivate?.onFeedbackRequested
   444        ) {
   445          return A.H.TRUE;
   446        }
   447        return A.H.FALSE;
   448      },
   449      "func_OffFeedbackRequested": (fn: Pointer): void => {
   450        A.store.Ref(fn, WEBEXT.feedbackPrivate.onFeedbackRequested.removeListener);
   451      },
   452      "call_OffFeedbackRequested": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   453        const _ret = WEBEXT.feedbackPrivate.onFeedbackRequested.removeListener(A.H.get<object>(callback));
   454      },
   455      "try_OffFeedbackRequested": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   456        try {
   457          const _ret = WEBEXT.feedbackPrivate.onFeedbackRequested.removeListener(A.H.get<object>(callback));
   458          return A.H.TRUE;
   459        } catch (err: any) {
   460          A.store.Ref(errPtr, err);
   461          return A.H.FALSE;
   462        }
   463      },
   464      "has_HasOnFeedbackRequested": (): heap.Ref<boolean> => {
   465        if (
   466          WEBEXT?.feedbackPrivate?.onFeedbackRequested &&
   467          "hasListener" in WEBEXT?.feedbackPrivate?.onFeedbackRequested
   468        ) {
   469          return A.H.TRUE;
   470        }
   471        return A.H.FALSE;
   472      },
   473      "func_HasOnFeedbackRequested": (fn: Pointer): void => {
   474        A.store.Ref(fn, WEBEXT.feedbackPrivate.onFeedbackRequested.hasListener);
   475      },
   476      "call_HasOnFeedbackRequested": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   477        const _ret = WEBEXT.feedbackPrivate.onFeedbackRequested.hasListener(A.H.get<object>(callback));
   478        A.store.Bool(retPtr, _ret);
   479      },
   480      "try_HasOnFeedbackRequested": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   481        try {
   482          const _ret = WEBEXT.feedbackPrivate.onFeedbackRequested.hasListener(A.H.get<object>(callback));
   483          A.store.Bool(retPtr, _ret);
   484          return A.H.TRUE;
   485        } catch (err: any) {
   486          A.store.Ref(errPtr, err);
   487          return A.H.FALSE;
   488        }
   489      },
   490      "has_OpenFeedback": (): heap.Ref<boolean> => {
   491        if (WEBEXT?.feedbackPrivate && "openFeedback" in WEBEXT?.feedbackPrivate) {
   492          return A.H.TRUE;
   493        }
   494        return A.H.FALSE;
   495      },
   496      "func_OpenFeedback": (fn: Pointer): void => {
   497        A.store.Ref(fn, WEBEXT.feedbackPrivate.openFeedback);
   498      },
   499      "call_OpenFeedback": (retPtr: Pointer, source: number): void => {
   500        const _ret = WEBEXT.feedbackPrivate.openFeedback(
   501          source > 0 && source <= 1 ? ["quickoffice"][source - 1] : undefined
   502        );
   503      },
   504      "try_OpenFeedback": (retPtr: Pointer, errPtr: Pointer, source: number): heap.Ref<boolean> => {
   505        try {
   506          const _ret = WEBEXT.feedbackPrivate.openFeedback(
   507            source > 0 && source <= 1 ? ["quickoffice"][source - 1] : undefined
   508          );
   509          return A.H.TRUE;
   510        } catch (err: any) {
   511          A.store.Ref(errPtr, err);
   512          return A.H.FALSE;
   513        }
   514      },
   515      "has_ReadLogSource": (): heap.Ref<boolean> => {
   516        if (WEBEXT?.feedbackPrivate && "readLogSource" in WEBEXT?.feedbackPrivate) {
   517          return A.H.TRUE;
   518        }
   519        return A.H.FALSE;
   520      },
   521      "func_ReadLogSource": (fn: Pointer): void => {
   522        A.store.Ref(fn, WEBEXT.feedbackPrivate.readLogSource);
   523      },
   524      "call_ReadLogSource": (retPtr: Pointer, params: Pointer, callback: heap.Ref<object>): void => {
   525        const params_ffi = {};
   526  
   527        params_ffi["source"] = A.load.Enum(params + 0, [
   528          "messages",
   529          "uiLatest",
   530          "drmModetest",
   531          "lsusb",
   532          "atrusLog",
   533          "netLog",
   534          "eventLog",
   535          "updateEngineLog",
   536          "powerdLatest",
   537          "powerdPrevious",
   538          "lspci",
   539          "ifconfig",
   540          "uptime",
   541        ]);
   542        if (A.load.Bool(params + 12)) {
   543          params_ffi["incremental"] = A.load.Bool(params + 4);
   544        }
   545        if (A.load.Bool(params + 13)) {
   546          params_ffi["readerId"] = A.load.Int32(params + 8);
   547        }
   548  
   549        const _ret = WEBEXT.feedbackPrivate.readLogSource(params_ffi, A.H.get<object>(callback));
   550      },
   551      "try_ReadLogSource": (
   552        retPtr: Pointer,
   553        errPtr: Pointer,
   554        params: Pointer,
   555        callback: heap.Ref<object>
   556      ): heap.Ref<boolean> => {
   557        try {
   558          const params_ffi = {};
   559  
   560          params_ffi["source"] = A.load.Enum(params + 0, [
   561            "messages",
   562            "uiLatest",
   563            "drmModetest",
   564            "lsusb",
   565            "atrusLog",
   566            "netLog",
   567            "eventLog",
   568            "updateEngineLog",
   569            "powerdLatest",
   570            "powerdPrevious",
   571            "lspci",
   572            "ifconfig",
   573            "uptime",
   574          ]);
   575          if (A.load.Bool(params + 12)) {
   576            params_ffi["incremental"] = A.load.Bool(params + 4);
   577          }
   578          if (A.load.Bool(params + 13)) {
   579            params_ffi["readerId"] = A.load.Int32(params + 8);
   580          }
   581  
   582          const _ret = WEBEXT.feedbackPrivate.readLogSource(params_ffi, A.H.get<object>(callback));
   583          return A.H.TRUE;
   584        } catch (err: any) {
   585          A.store.Ref(errPtr, err);
   586          return A.H.FALSE;
   587        }
   588      },
   589      "has_SendFeedback": (): heap.Ref<boolean> => {
   590        if (WEBEXT?.feedbackPrivate && "sendFeedback" in WEBEXT?.feedbackPrivate) {
   591          return A.H.TRUE;
   592        }
   593        return A.H.FALSE;
   594      },
   595      "func_SendFeedback": (fn: Pointer): void => {
   596        A.store.Ref(fn, WEBEXT.feedbackPrivate.sendFeedback);
   597      },
   598      "call_SendFeedback": (
   599        retPtr: Pointer,
   600        feedback: Pointer,
   601        loadSystemInfo: heap.Ref<boolean>,
   602        formOpenTime: number
   603      ): void => {
   604        const feedback_ffi = {};
   605  
   606        if (A.load.Bool(feedback + 0 + 8)) {
   607          feedback_ffi["attachedFile"] = {};
   608          feedback_ffi["attachedFile"]["name"] = A.load.Ref(feedback + 0 + 0, undefined);
   609          feedback_ffi["attachedFile"]["data"] = A.load.Ref(feedback + 0 + 4, undefined);
   610        }
   611        feedback_ffi["categoryTag"] = A.load.Ref(feedback + 12, undefined);
   612        feedback_ffi["description"] = A.load.Ref(feedback + 16, undefined);
   613        feedback_ffi["descriptionPlaceholder"] = A.load.Ref(feedback + 20, undefined);
   614        feedback_ffi["email"] = A.load.Ref(feedback + 24, undefined);
   615        feedback_ffi["pageUrl"] = A.load.Ref(feedback + 28, undefined);
   616        if (A.load.Bool(feedback + 77)) {
   617          feedback_ffi["productId"] = A.load.Int32(feedback + 32);
   618        }
   619        feedback_ffi["screenshot"] = A.load.Ref(feedback + 36, undefined);
   620        if (A.load.Bool(feedback + 78)) {
   621          feedback_ffi["traceId"] = A.load.Int32(feedback + 40);
   622        }
   623        feedback_ffi["systemInformation"] = A.load.Ref(feedback + 44, undefined);
   624        if (A.load.Bool(feedback + 79)) {
   625          feedback_ffi["sendHistograms"] = A.load.Bool(feedback + 48);
   626        }
   627        feedback_ffi["flow"] = A.load.Enum(feedback + 52, ["regular", "login", "sadTabCrash", "googleInternal"]);
   628        feedback_ffi["attachedFileBlobUuid"] = A.load.Ref(feedback + 56, undefined);
   629        feedback_ffi["screenshotBlobUuid"] = A.load.Ref(feedback + 60, undefined);
   630        if (A.load.Bool(feedback + 80)) {
   631          feedback_ffi["useSystemWindowFrame"] = A.load.Bool(feedback + 64);
   632        }
   633        if (A.load.Bool(feedback + 81)) {
   634          feedback_ffi["sendBluetoothLogs"] = A.load.Bool(feedback + 65);
   635        }
   636        if (A.load.Bool(feedback + 82)) {
   637          feedback_ffi["sendTabTitles"] = A.load.Bool(feedback + 66);
   638        }
   639        if (A.load.Bool(feedback + 83)) {
   640          feedback_ffi["assistantDebugInfoAllowed"] = A.load.Bool(feedback + 67);
   641        }
   642        if (A.load.Bool(feedback + 84)) {
   643          feedback_ffi["fromAssistant"] = A.load.Bool(feedback + 68);
   644        }
   645        if (A.load.Bool(feedback + 85)) {
   646          feedback_ffi["includeBluetoothLogs"] = A.load.Bool(feedback + 69);
   647        }
   648        if (A.load.Bool(feedback + 86)) {
   649          feedback_ffi["showQuestionnaire"] = A.load.Bool(feedback + 70);
   650        }
   651        if (A.load.Bool(feedback + 87)) {
   652          feedback_ffi["fromAutofill"] = A.load.Bool(feedback + 71);
   653        }
   654        feedback_ffi["autofillMetadata"] = A.load.Ref(feedback + 72, undefined);
   655        if (A.load.Bool(feedback + 88)) {
   656          feedback_ffi["sendAutofillMetadata"] = A.load.Bool(feedback + 76);
   657        }
   658  
   659        const _ret = WEBEXT.feedbackPrivate.sendFeedback(feedback_ffi, loadSystemInfo === A.H.TRUE, formOpenTime);
   660        A.store.Ref(retPtr, _ret);
   661      },
   662      "try_SendFeedback": (
   663        retPtr: Pointer,
   664        errPtr: Pointer,
   665        feedback: Pointer,
   666        loadSystemInfo: heap.Ref<boolean>,
   667        formOpenTime: number
   668      ): heap.Ref<boolean> => {
   669        try {
   670          const feedback_ffi = {};
   671  
   672          if (A.load.Bool(feedback + 0 + 8)) {
   673            feedback_ffi["attachedFile"] = {};
   674            feedback_ffi["attachedFile"]["name"] = A.load.Ref(feedback + 0 + 0, undefined);
   675            feedback_ffi["attachedFile"]["data"] = A.load.Ref(feedback + 0 + 4, undefined);
   676          }
   677          feedback_ffi["categoryTag"] = A.load.Ref(feedback + 12, undefined);
   678          feedback_ffi["description"] = A.load.Ref(feedback + 16, undefined);
   679          feedback_ffi["descriptionPlaceholder"] = A.load.Ref(feedback + 20, undefined);
   680          feedback_ffi["email"] = A.load.Ref(feedback + 24, undefined);
   681          feedback_ffi["pageUrl"] = A.load.Ref(feedback + 28, undefined);
   682          if (A.load.Bool(feedback + 77)) {
   683            feedback_ffi["productId"] = A.load.Int32(feedback + 32);
   684          }
   685          feedback_ffi["screenshot"] = A.load.Ref(feedback + 36, undefined);
   686          if (A.load.Bool(feedback + 78)) {
   687            feedback_ffi["traceId"] = A.load.Int32(feedback + 40);
   688          }
   689          feedback_ffi["systemInformation"] = A.load.Ref(feedback + 44, undefined);
   690          if (A.load.Bool(feedback + 79)) {
   691            feedback_ffi["sendHistograms"] = A.load.Bool(feedback + 48);
   692          }
   693          feedback_ffi["flow"] = A.load.Enum(feedback + 52, ["regular", "login", "sadTabCrash", "googleInternal"]);
   694          feedback_ffi["attachedFileBlobUuid"] = A.load.Ref(feedback + 56, undefined);
   695          feedback_ffi["screenshotBlobUuid"] = A.load.Ref(feedback + 60, undefined);
   696          if (A.load.Bool(feedback + 80)) {
   697            feedback_ffi["useSystemWindowFrame"] = A.load.Bool(feedback + 64);
   698          }
   699          if (A.load.Bool(feedback + 81)) {
   700            feedback_ffi["sendBluetoothLogs"] = A.load.Bool(feedback + 65);
   701          }
   702          if (A.load.Bool(feedback + 82)) {
   703            feedback_ffi["sendTabTitles"] = A.load.Bool(feedback + 66);
   704          }
   705          if (A.load.Bool(feedback + 83)) {
   706            feedback_ffi["assistantDebugInfoAllowed"] = A.load.Bool(feedback + 67);
   707          }
   708          if (A.load.Bool(feedback + 84)) {
   709            feedback_ffi["fromAssistant"] = A.load.Bool(feedback + 68);
   710          }
   711          if (A.load.Bool(feedback + 85)) {
   712            feedback_ffi["includeBluetoothLogs"] = A.load.Bool(feedback + 69);
   713          }
   714          if (A.load.Bool(feedback + 86)) {
   715            feedback_ffi["showQuestionnaire"] = A.load.Bool(feedback + 70);
   716          }
   717          if (A.load.Bool(feedback + 87)) {
   718            feedback_ffi["fromAutofill"] = A.load.Bool(feedback + 71);
   719          }
   720          feedback_ffi["autofillMetadata"] = A.load.Ref(feedback + 72, undefined);
   721          if (A.load.Bool(feedback + 88)) {
   722            feedback_ffi["sendAutofillMetadata"] = A.load.Bool(feedback + 76);
   723          }
   724  
   725          const _ret = WEBEXT.feedbackPrivate.sendFeedback(feedback_ffi, loadSystemInfo === A.H.TRUE, formOpenTime);
   726          A.store.Ref(retPtr, _ret);
   727          return A.H.TRUE;
   728        } catch (err: any) {
   729          A.store.Ref(errPtr, err);
   730          return A.H.FALSE;
   731        }
   732      },
   733    };
   734  });