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

     1  import { importModule, Application, heap, Pointer } from "@ffi";
     2  
     3  importModule("plat/js/webext/metricsprivate", (A: Application) => {
     4    const WEBEXT = typeof globalThis.browser === "undefined" ? globalThis.chrome : globalThis.browser;
     5  
     6    return {
     7      "store_HistogramBucket": (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 + 24, false);
    12          A.store.Int64(ptr + 0, 0);
    13          A.store.Int64(ptr + 8, 0);
    14          A.store.Int64(ptr + 16, 0);
    15        } else {
    16          A.store.Bool(ptr + 24, true);
    17          A.store.Int64(ptr + 0, x["count"] === undefined ? 0 : (x["count"] as number));
    18          A.store.Int64(ptr + 8, x["max"] === undefined ? 0 : (x["max"] as number));
    19          A.store.Int64(ptr + 16, x["min"] === undefined ? 0 : (x["min"] as number));
    20        }
    21      },
    22      "load_HistogramBucket": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
    23        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
    24  
    25        x["count"] = A.load.Int64(ptr + 0);
    26        x["max"] = A.load.Int64(ptr + 8);
    27        x["min"] = A.load.Int64(ptr + 16);
    28        return create === A.H.TRUE ? A.H.push(x) : ref;
    29      },
    30  
    31      "store_Histogram": (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 + 16, false);
    36          A.store.Ref(ptr + 0, undefined);
    37          A.store.Float64(ptr + 8, 0);
    38        } else {
    39          A.store.Bool(ptr + 16, true);
    40          A.store.Ref(ptr + 0, x["buckets"]);
    41          A.store.Float64(ptr + 8, x["sum"] === undefined ? 0 : (x["sum"] as number));
    42        }
    43      },
    44      "load_Histogram": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
    45        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
    46  
    47        x["buckets"] = A.load.Ref(ptr + 0, undefined);
    48        x["sum"] = A.load.Float64(ptr + 8);
    49        return create === A.H.TRUE ? A.H.push(x) : ref;
    50      },
    51      "constof_MetricTypeType": (ref: heap.Ref<string>): number => {
    52        const idx = ["histogram-log", "histogram-linear"].indexOf(A.H.get(ref));
    53        return idx < 0 ? 0 : idx + 1;
    54      },
    55  
    56      "store_MetricType": (ptr: Pointer, ref: heap.Ref<any>) => {
    57        const x = A.H.get<any>(ref);
    58  
    59        if (typeof x === "undefined") {
    60          A.store.Bool(ptr + 36, false);
    61          A.store.Int64(ptr + 0, 0);
    62          A.store.Int64(ptr + 8, 0);
    63          A.store.Ref(ptr + 16, undefined);
    64          A.store.Int64(ptr + 24, 0);
    65          A.store.Enum(ptr + 32, -1);
    66        } else {
    67          A.store.Bool(ptr + 36, true);
    68          A.store.Int64(ptr + 0, x["buckets"] === undefined ? 0 : (x["buckets"] as number));
    69          A.store.Int64(ptr + 8, x["max"] === undefined ? 0 : (x["max"] as number));
    70          A.store.Ref(ptr + 16, x["metricName"]);
    71          A.store.Int64(ptr + 24, x["min"] === undefined ? 0 : (x["min"] as number));
    72          A.store.Enum(ptr + 32, ["histogram-log", "histogram-linear"].indexOf(x["type"] as string));
    73        }
    74      },
    75      "load_MetricType": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
    76        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
    77  
    78        x["buckets"] = A.load.Int64(ptr + 0);
    79        x["max"] = A.load.Int64(ptr + 8);
    80        x["metricName"] = A.load.Ref(ptr + 16, undefined);
    81        x["min"] = A.load.Int64(ptr + 24);
    82        x["type"] = A.load.Enum(ptr + 32, ["histogram-log", "histogram-linear"]);
    83        return create === A.H.TRUE ? A.H.push(x) : ref;
    84      },
    85      "has_GetFieldTrial": (): heap.Ref<boolean> => {
    86        if (WEBEXT?.metricsPrivate && "getFieldTrial" in WEBEXT?.metricsPrivate) {
    87          return A.H.TRUE;
    88        }
    89        return A.H.FALSE;
    90      },
    91      "func_GetFieldTrial": (fn: Pointer): void => {
    92        A.store.Ref(fn, WEBEXT.metricsPrivate.getFieldTrial);
    93      },
    94      "call_GetFieldTrial": (retPtr: Pointer, name: heap.Ref<object>): void => {
    95        const _ret = WEBEXT.metricsPrivate.getFieldTrial(A.H.get<object>(name));
    96        A.store.Ref(retPtr, _ret);
    97      },
    98      "try_GetFieldTrial": (retPtr: Pointer, errPtr: Pointer, name: heap.Ref<object>): heap.Ref<boolean> => {
    99        try {
   100          const _ret = WEBEXT.metricsPrivate.getFieldTrial(A.H.get<object>(name));
   101          A.store.Ref(retPtr, _ret);
   102          return A.H.TRUE;
   103        } catch (err: any) {
   104          A.store.Ref(errPtr, err);
   105          return A.H.FALSE;
   106        }
   107      },
   108      "has_GetHistogram": (): heap.Ref<boolean> => {
   109        if (WEBEXT?.metricsPrivate && "getHistogram" in WEBEXT?.metricsPrivate) {
   110          return A.H.TRUE;
   111        }
   112        return A.H.FALSE;
   113      },
   114      "func_GetHistogram": (fn: Pointer): void => {
   115        A.store.Ref(fn, WEBEXT.metricsPrivate.getHistogram);
   116      },
   117      "call_GetHistogram": (retPtr: Pointer, name: heap.Ref<object>): void => {
   118        const _ret = WEBEXT.metricsPrivate.getHistogram(A.H.get<object>(name));
   119        A.store.Ref(retPtr, _ret);
   120      },
   121      "try_GetHistogram": (retPtr: Pointer, errPtr: Pointer, name: heap.Ref<object>): heap.Ref<boolean> => {
   122        try {
   123          const _ret = WEBEXT.metricsPrivate.getHistogram(A.H.get<object>(name));
   124          A.store.Ref(retPtr, _ret);
   125          return A.H.TRUE;
   126        } catch (err: any) {
   127          A.store.Ref(errPtr, err);
   128          return A.H.FALSE;
   129        }
   130      },
   131      "has_GetIsCrashReportingEnabled": (): heap.Ref<boolean> => {
   132        if (WEBEXT?.metricsPrivate && "getIsCrashReportingEnabled" in WEBEXT?.metricsPrivate) {
   133          return A.H.TRUE;
   134        }
   135        return A.H.FALSE;
   136      },
   137      "func_GetIsCrashReportingEnabled": (fn: Pointer): void => {
   138        A.store.Ref(fn, WEBEXT.metricsPrivate.getIsCrashReportingEnabled);
   139      },
   140      "call_GetIsCrashReportingEnabled": (retPtr: Pointer): void => {
   141        const _ret = WEBEXT.metricsPrivate.getIsCrashReportingEnabled();
   142        A.store.Ref(retPtr, _ret);
   143      },
   144      "try_GetIsCrashReportingEnabled": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => {
   145        try {
   146          const _ret = WEBEXT.metricsPrivate.getIsCrashReportingEnabled();
   147          A.store.Ref(retPtr, _ret);
   148          return A.H.TRUE;
   149        } catch (err: any) {
   150          A.store.Ref(errPtr, err);
   151          return A.H.FALSE;
   152        }
   153      },
   154      "has_GetVariationParams": (): heap.Ref<boolean> => {
   155        if (WEBEXT?.metricsPrivate && "getVariationParams" in WEBEXT?.metricsPrivate) {
   156          return A.H.TRUE;
   157        }
   158        return A.H.FALSE;
   159      },
   160      "func_GetVariationParams": (fn: Pointer): void => {
   161        A.store.Ref(fn, WEBEXT.metricsPrivate.getVariationParams);
   162      },
   163      "call_GetVariationParams": (retPtr: Pointer, name: heap.Ref<object>): void => {
   164        const _ret = WEBEXT.metricsPrivate.getVariationParams(A.H.get<object>(name));
   165        A.store.Ref(retPtr, _ret);
   166      },
   167      "try_GetVariationParams": (retPtr: Pointer, errPtr: Pointer, name: heap.Ref<object>): heap.Ref<boolean> => {
   168        try {
   169          const _ret = WEBEXT.metricsPrivate.getVariationParams(A.H.get<object>(name));
   170          A.store.Ref(retPtr, _ret);
   171          return A.H.TRUE;
   172        } catch (err: any) {
   173          A.store.Ref(errPtr, err);
   174          return A.H.FALSE;
   175        }
   176      },
   177      "has_RecordBoolean": (): heap.Ref<boolean> => {
   178        if (WEBEXT?.metricsPrivate && "recordBoolean" in WEBEXT?.metricsPrivate) {
   179          return A.H.TRUE;
   180        }
   181        return A.H.FALSE;
   182      },
   183      "func_RecordBoolean": (fn: Pointer): void => {
   184        A.store.Ref(fn, WEBEXT.metricsPrivate.recordBoolean);
   185      },
   186      "call_RecordBoolean": (retPtr: Pointer, metricName: heap.Ref<object>, value: heap.Ref<boolean>): void => {
   187        const _ret = WEBEXT.metricsPrivate.recordBoolean(A.H.get<object>(metricName), value === A.H.TRUE);
   188      },
   189      "try_RecordBoolean": (
   190        retPtr: Pointer,
   191        errPtr: Pointer,
   192        metricName: heap.Ref<object>,
   193        value: heap.Ref<boolean>
   194      ): heap.Ref<boolean> => {
   195        try {
   196          const _ret = WEBEXT.metricsPrivate.recordBoolean(A.H.get<object>(metricName), value === A.H.TRUE);
   197          return A.H.TRUE;
   198        } catch (err: any) {
   199          A.store.Ref(errPtr, err);
   200          return A.H.FALSE;
   201        }
   202      },
   203      "has_RecordCount": (): heap.Ref<boolean> => {
   204        if (WEBEXT?.metricsPrivate && "recordCount" in WEBEXT?.metricsPrivate) {
   205          return A.H.TRUE;
   206        }
   207        return A.H.FALSE;
   208      },
   209      "func_RecordCount": (fn: Pointer): void => {
   210        A.store.Ref(fn, WEBEXT.metricsPrivate.recordCount);
   211      },
   212      "call_RecordCount": (retPtr: Pointer, metricName: heap.Ref<object>, value: number): void => {
   213        const _ret = WEBEXT.metricsPrivate.recordCount(A.H.get<object>(metricName), value);
   214      },
   215      "try_RecordCount": (
   216        retPtr: Pointer,
   217        errPtr: Pointer,
   218        metricName: heap.Ref<object>,
   219        value: number
   220      ): heap.Ref<boolean> => {
   221        try {
   222          const _ret = WEBEXT.metricsPrivate.recordCount(A.H.get<object>(metricName), value);
   223          return A.H.TRUE;
   224        } catch (err: any) {
   225          A.store.Ref(errPtr, err);
   226          return A.H.FALSE;
   227        }
   228      },
   229      "has_RecordEnumerationValue": (): heap.Ref<boolean> => {
   230        if (WEBEXT?.metricsPrivate && "recordEnumerationValue" in WEBEXT?.metricsPrivate) {
   231          return A.H.TRUE;
   232        }
   233        return A.H.FALSE;
   234      },
   235      "func_RecordEnumerationValue": (fn: Pointer): void => {
   236        A.store.Ref(fn, WEBEXT.metricsPrivate.recordEnumerationValue);
   237      },
   238      "call_RecordEnumerationValue": (
   239        retPtr: Pointer,
   240        metricName: heap.Ref<object>,
   241        value: number,
   242        enumSize: number
   243      ): void => {
   244        const _ret = WEBEXT.metricsPrivate.recordEnumerationValue(A.H.get<object>(metricName), value, enumSize);
   245      },
   246      "try_RecordEnumerationValue": (
   247        retPtr: Pointer,
   248        errPtr: Pointer,
   249        metricName: heap.Ref<object>,
   250        value: number,
   251        enumSize: number
   252      ): heap.Ref<boolean> => {
   253        try {
   254          const _ret = WEBEXT.metricsPrivate.recordEnumerationValue(A.H.get<object>(metricName), value, enumSize);
   255          return A.H.TRUE;
   256        } catch (err: any) {
   257          A.store.Ref(errPtr, err);
   258          return A.H.FALSE;
   259        }
   260      },
   261      "has_RecordLongTime": (): heap.Ref<boolean> => {
   262        if (WEBEXT?.metricsPrivate && "recordLongTime" in WEBEXT?.metricsPrivate) {
   263          return A.H.TRUE;
   264        }
   265        return A.H.FALSE;
   266      },
   267      "func_RecordLongTime": (fn: Pointer): void => {
   268        A.store.Ref(fn, WEBEXT.metricsPrivate.recordLongTime);
   269      },
   270      "call_RecordLongTime": (retPtr: Pointer, metricName: heap.Ref<object>, value: number): void => {
   271        const _ret = WEBEXT.metricsPrivate.recordLongTime(A.H.get<object>(metricName), value);
   272      },
   273      "try_RecordLongTime": (
   274        retPtr: Pointer,
   275        errPtr: Pointer,
   276        metricName: heap.Ref<object>,
   277        value: number
   278      ): heap.Ref<boolean> => {
   279        try {
   280          const _ret = WEBEXT.metricsPrivate.recordLongTime(A.H.get<object>(metricName), value);
   281          return A.H.TRUE;
   282        } catch (err: any) {
   283          A.store.Ref(errPtr, err);
   284          return A.H.FALSE;
   285        }
   286      },
   287      "has_RecordMediumCount": (): heap.Ref<boolean> => {
   288        if (WEBEXT?.metricsPrivate && "recordMediumCount" in WEBEXT?.metricsPrivate) {
   289          return A.H.TRUE;
   290        }
   291        return A.H.FALSE;
   292      },
   293      "func_RecordMediumCount": (fn: Pointer): void => {
   294        A.store.Ref(fn, WEBEXT.metricsPrivate.recordMediumCount);
   295      },
   296      "call_RecordMediumCount": (retPtr: Pointer, metricName: heap.Ref<object>, value: number): void => {
   297        const _ret = WEBEXT.metricsPrivate.recordMediumCount(A.H.get<object>(metricName), value);
   298      },
   299      "try_RecordMediumCount": (
   300        retPtr: Pointer,
   301        errPtr: Pointer,
   302        metricName: heap.Ref<object>,
   303        value: number
   304      ): heap.Ref<boolean> => {
   305        try {
   306          const _ret = WEBEXT.metricsPrivate.recordMediumCount(A.H.get<object>(metricName), value);
   307          return A.H.TRUE;
   308        } catch (err: any) {
   309          A.store.Ref(errPtr, err);
   310          return A.H.FALSE;
   311        }
   312      },
   313      "has_RecordMediumTime": (): heap.Ref<boolean> => {
   314        if (WEBEXT?.metricsPrivate && "recordMediumTime" in WEBEXT?.metricsPrivate) {
   315          return A.H.TRUE;
   316        }
   317        return A.H.FALSE;
   318      },
   319      "func_RecordMediumTime": (fn: Pointer): void => {
   320        A.store.Ref(fn, WEBEXT.metricsPrivate.recordMediumTime);
   321      },
   322      "call_RecordMediumTime": (retPtr: Pointer, metricName: heap.Ref<object>, value: number): void => {
   323        const _ret = WEBEXT.metricsPrivate.recordMediumTime(A.H.get<object>(metricName), value);
   324      },
   325      "try_RecordMediumTime": (
   326        retPtr: Pointer,
   327        errPtr: Pointer,
   328        metricName: heap.Ref<object>,
   329        value: number
   330      ): heap.Ref<boolean> => {
   331        try {
   332          const _ret = WEBEXT.metricsPrivate.recordMediumTime(A.H.get<object>(metricName), value);
   333          return A.H.TRUE;
   334        } catch (err: any) {
   335          A.store.Ref(errPtr, err);
   336          return A.H.FALSE;
   337        }
   338      },
   339      "has_RecordPercentage": (): heap.Ref<boolean> => {
   340        if (WEBEXT?.metricsPrivate && "recordPercentage" in WEBEXT?.metricsPrivate) {
   341          return A.H.TRUE;
   342        }
   343        return A.H.FALSE;
   344      },
   345      "func_RecordPercentage": (fn: Pointer): void => {
   346        A.store.Ref(fn, WEBEXT.metricsPrivate.recordPercentage);
   347      },
   348      "call_RecordPercentage": (retPtr: Pointer, metricName: heap.Ref<object>, value: number): void => {
   349        const _ret = WEBEXT.metricsPrivate.recordPercentage(A.H.get<object>(metricName), value);
   350      },
   351      "try_RecordPercentage": (
   352        retPtr: Pointer,
   353        errPtr: Pointer,
   354        metricName: heap.Ref<object>,
   355        value: number
   356      ): heap.Ref<boolean> => {
   357        try {
   358          const _ret = WEBEXT.metricsPrivate.recordPercentage(A.H.get<object>(metricName), value);
   359          return A.H.TRUE;
   360        } catch (err: any) {
   361          A.store.Ref(errPtr, err);
   362          return A.H.FALSE;
   363        }
   364      },
   365      "has_RecordSmallCount": (): heap.Ref<boolean> => {
   366        if (WEBEXT?.metricsPrivate && "recordSmallCount" in WEBEXT?.metricsPrivate) {
   367          return A.H.TRUE;
   368        }
   369        return A.H.FALSE;
   370      },
   371      "func_RecordSmallCount": (fn: Pointer): void => {
   372        A.store.Ref(fn, WEBEXT.metricsPrivate.recordSmallCount);
   373      },
   374      "call_RecordSmallCount": (retPtr: Pointer, metricName: heap.Ref<object>, value: number): void => {
   375        const _ret = WEBEXT.metricsPrivate.recordSmallCount(A.H.get<object>(metricName), value);
   376      },
   377      "try_RecordSmallCount": (
   378        retPtr: Pointer,
   379        errPtr: Pointer,
   380        metricName: heap.Ref<object>,
   381        value: number
   382      ): heap.Ref<boolean> => {
   383        try {
   384          const _ret = WEBEXT.metricsPrivate.recordSmallCount(A.H.get<object>(metricName), value);
   385          return A.H.TRUE;
   386        } catch (err: any) {
   387          A.store.Ref(errPtr, err);
   388          return A.H.FALSE;
   389        }
   390      },
   391      "has_RecordSparseValue": (): heap.Ref<boolean> => {
   392        if (WEBEXT?.metricsPrivate && "recordSparseValue" in WEBEXT?.metricsPrivate) {
   393          return A.H.TRUE;
   394        }
   395        return A.H.FALSE;
   396      },
   397      "func_RecordSparseValue": (fn: Pointer): void => {
   398        A.store.Ref(fn, WEBEXT.metricsPrivate.recordSparseValue);
   399      },
   400      "call_RecordSparseValue": (retPtr: Pointer, metricName: heap.Ref<object>, value: number): void => {
   401        const _ret = WEBEXT.metricsPrivate.recordSparseValue(A.H.get<object>(metricName), value);
   402      },
   403      "try_RecordSparseValue": (
   404        retPtr: Pointer,
   405        errPtr: Pointer,
   406        metricName: heap.Ref<object>,
   407        value: number
   408      ): heap.Ref<boolean> => {
   409        try {
   410          const _ret = WEBEXT.metricsPrivate.recordSparseValue(A.H.get<object>(metricName), value);
   411          return A.H.TRUE;
   412        } catch (err: any) {
   413          A.store.Ref(errPtr, err);
   414          return A.H.FALSE;
   415        }
   416      },
   417      "has_RecordSparseValueWithHashMetricName": (): heap.Ref<boolean> => {
   418        if (WEBEXT?.metricsPrivate && "recordSparseValueWithHashMetricName" in WEBEXT?.metricsPrivate) {
   419          return A.H.TRUE;
   420        }
   421        return A.H.FALSE;
   422      },
   423      "func_RecordSparseValueWithHashMetricName": (fn: Pointer): void => {
   424        A.store.Ref(fn, WEBEXT.metricsPrivate.recordSparseValueWithHashMetricName);
   425      },
   426      "call_RecordSparseValueWithHashMetricName": (
   427        retPtr: Pointer,
   428        metricName: heap.Ref<object>,
   429        value: heap.Ref<object>
   430      ): void => {
   431        const _ret = WEBEXT.metricsPrivate.recordSparseValueWithHashMetricName(
   432          A.H.get<object>(metricName),
   433          A.H.get<object>(value)
   434        );
   435      },
   436      "try_RecordSparseValueWithHashMetricName": (
   437        retPtr: Pointer,
   438        errPtr: Pointer,
   439        metricName: heap.Ref<object>,
   440        value: heap.Ref<object>
   441      ): heap.Ref<boolean> => {
   442        try {
   443          const _ret = WEBEXT.metricsPrivate.recordSparseValueWithHashMetricName(
   444            A.H.get<object>(metricName),
   445            A.H.get<object>(value)
   446          );
   447          return A.H.TRUE;
   448        } catch (err: any) {
   449          A.store.Ref(errPtr, err);
   450          return A.H.FALSE;
   451        }
   452      },
   453      "has_RecordSparseValueWithPersistentHash": (): heap.Ref<boolean> => {
   454        if (WEBEXT?.metricsPrivate && "recordSparseValueWithPersistentHash" in WEBEXT?.metricsPrivate) {
   455          return A.H.TRUE;
   456        }
   457        return A.H.FALSE;
   458      },
   459      "func_RecordSparseValueWithPersistentHash": (fn: Pointer): void => {
   460        A.store.Ref(fn, WEBEXT.metricsPrivate.recordSparseValueWithPersistentHash);
   461      },
   462      "call_RecordSparseValueWithPersistentHash": (
   463        retPtr: Pointer,
   464        metricName: heap.Ref<object>,
   465        value: heap.Ref<object>
   466      ): void => {
   467        const _ret = WEBEXT.metricsPrivate.recordSparseValueWithPersistentHash(
   468          A.H.get<object>(metricName),
   469          A.H.get<object>(value)
   470        );
   471      },
   472      "try_RecordSparseValueWithPersistentHash": (
   473        retPtr: Pointer,
   474        errPtr: Pointer,
   475        metricName: heap.Ref<object>,
   476        value: heap.Ref<object>
   477      ): heap.Ref<boolean> => {
   478        try {
   479          const _ret = WEBEXT.metricsPrivate.recordSparseValueWithPersistentHash(
   480            A.H.get<object>(metricName),
   481            A.H.get<object>(value)
   482          );
   483          return A.H.TRUE;
   484        } catch (err: any) {
   485          A.store.Ref(errPtr, err);
   486          return A.H.FALSE;
   487        }
   488      },
   489      "has_RecordTime": (): heap.Ref<boolean> => {
   490        if (WEBEXT?.metricsPrivate && "recordTime" in WEBEXT?.metricsPrivate) {
   491          return A.H.TRUE;
   492        }
   493        return A.H.FALSE;
   494      },
   495      "func_RecordTime": (fn: Pointer): void => {
   496        A.store.Ref(fn, WEBEXT.metricsPrivate.recordTime);
   497      },
   498      "call_RecordTime": (retPtr: Pointer, metricName: heap.Ref<object>, value: number): void => {
   499        const _ret = WEBEXT.metricsPrivate.recordTime(A.H.get<object>(metricName), value);
   500      },
   501      "try_RecordTime": (
   502        retPtr: Pointer,
   503        errPtr: Pointer,
   504        metricName: heap.Ref<object>,
   505        value: number
   506      ): heap.Ref<boolean> => {
   507        try {
   508          const _ret = WEBEXT.metricsPrivate.recordTime(A.H.get<object>(metricName), value);
   509          return A.H.TRUE;
   510        } catch (err: any) {
   511          A.store.Ref(errPtr, err);
   512          return A.H.FALSE;
   513        }
   514      },
   515      "has_RecordUserAction": (): heap.Ref<boolean> => {
   516        if (WEBEXT?.metricsPrivate && "recordUserAction" in WEBEXT?.metricsPrivate) {
   517          return A.H.TRUE;
   518        }
   519        return A.H.FALSE;
   520      },
   521      "func_RecordUserAction": (fn: Pointer): void => {
   522        A.store.Ref(fn, WEBEXT.metricsPrivate.recordUserAction);
   523      },
   524      "call_RecordUserAction": (retPtr: Pointer, name: heap.Ref<object>): void => {
   525        const _ret = WEBEXT.metricsPrivate.recordUserAction(A.H.get<object>(name));
   526      },
   527      "try_RecordUserAction": (retPtr: Pointer, errPtr: Pointer, name: heap.Ref<object>): heap.Ref<boolean> => {
   528        try {
   529          const _ret = WEBEXT.metricsPrivate.recordUserAction(A.H.get<object>(name));
   530          return A.H.TRUE;
   531        } catch (err: any) {
   532          A.store.Ref(errPtr, err);
   533          return A.H.FALSE;
   534        }
   535      },
   536      "has_RecordValue": (): heap.Ref<boolean> => {
   537        if (WEBEXT?.metricsPrivate && "recordValue" in WEBEXT?.metricsPrivate) {
   538          return A.H.TRUE;
   539        }
   540        return A.H.FALSE;
   541      },
   542      "func_RecordValue": (fn: Pointer): void => {
   543        A.store.Ref(fn, WEBEXT.metricsPrivate.recordValue);
   544      },
   545      "call_RecordValue": (retPtr: Pointer, metric: Pointer, value: number): void => {
   546        const metric_ffi = {};
   547  
   548        metric_ffi["buckets"] = A.load.Int64(metric + 0);
   549        metric_ffi["max"] = A.load.Int64(metric + 8);
   550        metric_ffi["metricName"] = A.load.Ref(metric + 16, undefined);
   551        metric_ffi["min"] = A.load.Int64(metric + 24);
   552        metric_ffi["type"] = A.load.Enum(metric + 32, ["histogram-log", "histogram-linear"]);
   553  
   554        const _ret = WEBEXT.metricsPrivate.recordValue(metric_ffi, value);
   555      },
   556      "try_RecordValue": (retPtr: Pointer, errPtr: Pointer, metric: Pointer, value: number): heap.Ref<boolean> => {
   557        try {
   558          const metric_ffi = {};
   559  
   560          metric_ffi["buckets"] = A.load.Int64(metric + 0);
   561          metric_ffi["max"] = A.load.Int64(metric + 8);
   562          metric_ffi["metricName"] = A.load.Ref(metric + 16, undefined);
   563          metric_ffi["min"] = A.load.Int64(metric + 24);
   564          metric_ffi["type"] = A.load.Enum(metric + 32, ["histogram-log", "histogram-linear"]);
   565  
   566          const _ret = WEBEXT.metricsPrivate.recordValue(metric_ffi, value);
   567          return A.H.TRUE;
   568        } catch (err: any) {
   569          A.store.Ref(errPtr, err);
   570          return A.H.FALSE;
   571        }
   572      },
   573    };
   574  });