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

     1  import { importModule, Application, heap, Pointer } from "@ffi";
     2  
     3  importModule("plat/js/webext/login", (A: Application) => {
     4    const WEBEXT = typeof globalThis.browser === "undefined" ? globalThis.chrome : globalThis.browser;
     5  
     6    return {
     7      "store_SamlUserSessionProperties": (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["email"]);
    19          A.store.Ref(ptr + 4, x["gaiaId"]);
    20          A.store.Ref(ptr + 8, x["password"]);
    21          A.store.Ref(ptr + 12, x["oauthCode"]);
    22        }
    23      },
    24      "load_SamlUserSessionProperties": (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["email"] = A.load.Ref(ptr + 0, undefined);
    28        x["gaiaId"] = A.load.Ref(ptr + 4, undefined);
    29        x["password"] = A.load.Ref(ptr + 8, undefined);
    30        x["oauthCode"] = A.load.Ref(ptr + 12, undefined);
    31        return create === A.H.TRUE ? A.H.push(x) : ref;
    32      },
    33      "has_EndSharedSession": (): heap.Ref<boolean> => {
    34        if (WEBEXT?.login && "endSharedSession" in WEBEXT?.login) {
    35          return A.H.TRUE;
    36        }
    37        return A.H.FALSE;
    38      },
    39      "func_EndSharedSession": (fn: Pointer): void => {
    40        A.store.Ref(fn, WEBEXT.login.endSharedSession);
    41      },
    42      "call_EndSharedSession": (retPtr: Pointer): void => {
    43        const _ret = WEBEXT.login.endSharedSession();
    44        A.store.Ref(retPtr, _ret);
    45      },
    46      "try_EndSharedSession": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => {
    47        try {
    48          const _ret = WEBEXT.login.endSharedSession();
    49          A.store.Ref(retPtr, _ret);
    50          return A.H.TRUE;
    51        } catch (err: any) {
    52          A.store.Ref(errPtr, err);
    53          return A.H.FALSE;
    54        }
    55      },
    56      "has_EnterSharedSession": (): heap.Ref<boolean> => {
    57        if (WEBEXT?.login && "enterSharedSession" in WEBEXT?.login) {
    58          return A.H.TRUE;
    59        }
    60        return A.H.FALSE;
    61      },
    62      "func_EnterSharedSession": (fn: Pointer): void => {
    63        A.store.Ref(fn, WEBEXT.login.enterSharedSession);
    64      },
    65      "call_EnterSharedSession": (retPtr: Pointer, password: heap.Ref<object>): void => {
    66        const _ret = WEBEXT.login.enterSharedSession(A.H.get<object>(password));
    67        A.store.Ref(retPtr, _ret);
    68      },
    69      "try_EnterSharedSession": (retPtr: Pointer, errPtr: Pointer, password: heap.Ref<object>): heap.Ref<boolean> => {
    70        try {
    71          const _ret = WEBEXT.login.enterSharedSession(A.H.get<object>(password));
    72          A.store.Ref(retPtr, _ret);
    73          return A.H.TRUE;
    74        } catch (err: any) {
    75          A.store.Ref(errPtr, err);
    76          return A.H.FALSE;
    77        }
    78      },
    79      "has_ExitCurrentSession": (): heap.Ref<boolean> => {
    80        if (WEBEXT?.login && "exitCurrentSession" in WEBEXT?.login) {
    81          return A.H.TRUE;
    82        }
    83        return A.H.FALSE;
    84      },
    85      "func_ExitCurrentSession": (fn: Pointer): void => {
    86        A.store.Ref(fn, WEBEXT.login.exitCurrentSession);
    87      },
    88      "call_ExitCurrentSession": (retPtr: Pointer, dataForNextLoginAttempt: heap.Ref<object>): void => {
    89        const _ret = WEBEXT.login.exitCurrentSession(A.H.get<object>(dataForNextLoginAttempt));
    90        A.store.Ref(retPtr, _ret);
    91      },
    92      "try_ExitCurrentSession": (
    93        retPtr: Pointer,
    94        errPtr: Pointer,
    95        dataForNextLoginAttempt: heap.Ref<object>
    96      ): heap.Ref<boolean> => {
    97        try {
    98          const _ret = WEBEXT.login.exitCurrentSession(A.H.get<object>(dataForNextLoginAttempt));
    99          A.store.Ref(retPtr, _ret);
   100          return A.H.TRUE;
   101        } catch (err: any) {
   102          A.store.Ref(errPtr, err);
   103          return A.H.FALSE;
   104        }
   105      },
   106      "has_FetchDataForNextLoginAttempt": (): heap.Ref<boolean> => {
   107        if (WEBEXT?.login && "fetchDataForNextLoginAttempt" in WEBEXT?.login) {
   108          return A.H.TRUE;
   109        }
   110        return A.H.FALSE;
   111      },
   112      "func_FetchDataForNextLoginAttempt": (fn: Pointer): void => {
   113        A.store.Ref(fn, WEBEXT.login.fetchDataForNextLoginAttempt);
   114      },
   115      "call_FetchDataForNextLoginAttempt": (retPtr: Pointer): void => {
   116        const _ret = WEBEXT.login.fetchDataForNextLoginAttempt();
   117        A.store.Ref(retPtr, _ret);
   118      },
   119      "try_FetchDataForNextLoginAttempt": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => {
   120        try {
   121          const _ret = WEBEXT.login.fetchDataForNextLoginAttempt();
   122          A.store.Ref(retPtr, _ret);
   123          return A.H.TRUE;
   124        } catch (err: any) {
   125          A.store.Ref(errPtr, err);
   126          return A.H.FALSE;
   127        }
   128      },
   129      "has_LaunchManagedGuestSession": (): heap.Ref<boolean> => {
   130        if (WEBEXT?.login && "launchManagedGuestSession" in WEBEXT?.login) {
   131          return A.H.TRUE;
   132        }
   133        return A.H.FALSE;
   134      },
   135      "func_LaunchManagedGuestSession": (fn: Pointer): void => {
   136        A.store.Ref(fn, WEBEXT.login.launchManagedGuestSession);
   137      },
   138      "call_LaunchManagedGuestSession": (retPtr: Pointer, password: heap.Ref<object>): void => {
   139        const _ret = WEBEXT.login.launchManagedGuestSession(A.H.get<object>(password));
   140        A.store.Ref(retPtr, _ret);
   141      },
   142      "try_LaunchManagedGuestSession": (
   143        retPtr: Pointer,
   144        errPtr: Pointer,
   145        password: heap.Ref<object>
   146      ): heap.Ref<boolean> => {
   147        try {
   148          const _ret = WEBEXT.login.launchManagedGuestSession(A.H.get<object>(password));
   149          A.store.Ref(retPtr, _ret);
   150          return A.H.TRUE;
   151        } catch (err: any) {
   152          A.store.Ref(errPtr, err);
   153          return A.H.FALSE;
   154        }
   155      },
   156      "has_LaunchSamlUserSession": (): heap.Ref<boolean> => {
   157        if (WEBEXT?.login && "launchSamlUserSession" in WEBEXT?.login) {
   158          return A.H.TRUE;
   159        }
   160        return A.H.FALSE;
   161      },
   162      "func_LaunchSamlUserSession": (fn: Pointer): void => {
   163        A.store.Ref(fn, WEBEXT.login.launchSamlUserSession);
   164      },
   165      "call_LaunchSamlUserSession": (retPtr: Pointer, properties: Pointer): void => {
   166        const properties_ffi = {};
   167  
   168        properties_ffi["email"] = A.load.Ref(properties + 0, undefined);
   169        properties_ffi["gaiaId"] = A.load.Ref(properties + 4, undefined);
   170        properties_ffi["password"] = A.load.Ref(properties + 8, undefined);
   171        properties_ffi["oauthCode"] = A.load.Ref(properties + 12, undefined);
   172  
   173        const _ret = WEBEXT.login.launchSamlUserSession(properties_ffi);
   174        A.store.Ref(retPtr, _ret);
   175      },
   176      "try_LaunchSamlUserSession": (retPtr: Pointer, errPtr: Pointer, properties: Pointer): heap.Ref<boolean> => {
   177        try {
   178          const properties_ffi = {};
   179  
   180          properties_ffi["email"] = A.load.Ref(properties + 0, undefined);
   181          properties_ffi["gaiaId"] = A.load.Ref(properties + 4, undefined);
   182          properties_ffi["password"] = A.load.Ref(properties + 8, undefined);
   183          properties_ffi["oauthCode"] = A.load.Ref(properties + 12, undefined);
   184  
   185          const _ret = WEBEXT.login.launchSamlUserSession(properties_ffi);
   186          A.store.Ref(retPtr, _ret);
   187          return A.H.TRUE;
   188        } catch (err: any) {
   189          A.store.Ref(errPtr, err);
   190          return A.H.FALSE;
   191        }
   192      },
   193      "has_LaunchSharedManagedGuestSession": (): heap.Ref<boolean> => {
   194        if (WEBEXT?.login && "launchSharedManagedGuestSession" in WEBEXT?.login) {
   195          return A.H.TRUE;
   196        }
   197        return A.H.FALSE;
   198      },
   199      "func_LaunchSharedManagedGuestSession": (fn: Pointer): void => {
   200        A.store.Ref(fn, WEBEXT.login.launchSharedManagedGuestSession);
   201      },
   202      "call_LaunchSharedManagedGuestSession": (retPtr: Pointer, password: heap.Ref<object>): void => {
   203        const _ret = WEBEXT.login.launchSharedManagedGuestSession(A.H.get<object>(password));
   204        A.store.Ref(retPtr, _ret);
   205      },
   206      "try_LaunchSharedManagedGuestSession": (
   207        retPtr: Pointer,
   208        errPtr: Pointer,
   209        password: heap.Ref<object>
   210      ): heap.Ref<boolean> => {
   211        try {
   212          const _ret = WEBEXT.login.launchSharedManagedGuestSession(A.H.get<object>(password));
   213          A.store.Ref(retPtr, _ret);
   214          return A.H.TRUE;
   215        } catch (err: any) {
   216          A.store.Ref(errPtr, err);
   217          return A.H.FALSE;
   218        }
   219      },
   220      "has_LockCurrentSession": (): heap.Ref<boolean> => {
   221        if (WEBEXT?.login && "lockCurrentSession" in WEBEXT?.login) {
   222          return A.H.TRUE;
   223        }
   224        return A.H.FALSE;
   225      },
   226      "func_LockCurrentSession": (fn: Pointer): void => {
   227        A.store.Ref(fn, WEBEXT.login.lockCurrentSession);
   228      },
   229      "call_LockCurrentSession": (retPtr: Pointer): void => {
   230        const _ret = WEBEXT.login.lockCurrentSession();
   231        A.store.Ref(retPtr, _ret);
   232      },
   233      "try_LockCurrentSession": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => {
   234        try {
   235          const _ret = WEBEXT.login.lockCurrentSession();
   236          A.store.Ref(retPtr, _ret);
   237          return A.H.TRUE;
   238        } catch (err: any) {
   239          A.store.Ref(errPtr, err);
   240          return A.H.FALSE;
   241        }
   242      },
   243      "has_LockManagedGuestSession": (): heap.Ref<boolean> => {
   244        if (WEBEXT?.login && "lockManagedGuestSession" in WEBEXT?.login) {
   245          return A.H.TRUE;
   246        }
   247        return A.H.FALSE;
   248      },
   249      "func_LockManagedGuestSession": (fn: Pointer): void => {
   250        A.store.Ref(fn, WEBEXT.login.lockManagedGuestSession);
   251      },
   252      "call_LockManagedGuestSession": (retPtr: Pointer): void => {
   253        const _ret = WEBEXT.login.lockManagedGuestSession();
   254        A.store.Ref(retPtr, _ret);
   255      },
   256      "try_LockManagedGuestSession": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => {
   257        try {
   258          const _ret = WEBEXT.login.lockManagedGuestSession();
   259          A.store.Ref(retPtr, _ret);
   260          return A.H.TRUE;
   261        } catch (err: any) {
   262          A.store.Ref(errPtr, err);
   263          return A.H.FALSE;
   264        }
   265      },
   266      "has_NotifyExternalLogoutDone": (): heap.Ref<boolean> => {
   267        if (WEBEXT?.login && "notifyExternalLogoutDone" in WEBEXT?.login) {
   268          return A.H.TRUE;
   269        }
   270        return A.H.FALSE;
   271      },
   272      "func_NotifyExternalLogoutDone": (fn: Pointer): void => {
   273        A.store.Ref(fn, WEBEXT.login.notifyExternalLogoutDone);
   274      },
   275      "call_NotifyExternalLogoutDone": (retPtr: Pointer): void => {
   276        const _ret = WEBEXT.login.notifyExternalLogoutDone();
   277        A.store.Ref(retPtr, _ret);
   278      },
   279      "try_NotifyExternalLogoutDone": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => {
   280        try {
   281          const _ret = WEBEXT.login.notifyExternalLogoutDone();
   282          A.store.Ref(retPtr, _ret);
   283          return A.H.TRUE;
   284        } catch (err: any) {
   285          A.store.Ref(errPtr, err);
   286          return A.H.FALSE;
   287        }
   288      },
   289      "has_OnExternalLogoutDone": (): heap.Ref<boolean> => {
   290        if (WEBEXT?.login?.onExternalLogoutDone && "addListener" in WEBEXT?.login?.onExternalLogoutDone) {
   291          return A.H.TRUE;
   292        }
   293        return A.H.FALSE;
   294      },
   295      "func_OnExternalLogoutDone": (fn: Pointer): void => {
   296        A.store.Ref(fn, WEBEXT.login.onExternalLogoutDone.addListener);
   297      },
   298      "call_OnExternalLogoutDone": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   299        const _ret = WEBEXT.login.onExternalLogoutDone.addListener(A.H.get<object>(callback));
   300      },
   301      "try_OnExternalLogoutDone": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   302        try {
   303          const _ret = WEBEXT.login.onExternalLogoutDone.addListener(A.H.get<object>(callback));
   304          return A.H.TRUE;
   305        } catch (err: any) {
   306          A.store.Ref(errPtr, err);
   307          return A.H.FALSE;
   308        }
   309      },
   310      "has_OffExternalLogoutDone": (): heap.Ref<boolean> => {
   311        if (WEBEXT?.login?.onExternalLogoutDone && "removeListener" in WEBEXT?.login?.onExternalLogoutDone) {
   312          return A.H.TRUE;
   313        }
   314        return A.H.FALSE;
   315      },
   316      "func_OffExternalLogoutDone": (fn: Pointer): void => {
   317        A.store.Ref(fn, WEBEXT.login.onExternalLogoutDone.removeListener);
   318      },
   319      "call_OffExternalLogoutDone": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   320        const _ret = WEBEXT.login.onExternalLogoutDone.removeListener(A.H.get<object>(callback));
   321      },
   322      "try_OffExternalLogoutDone": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   323        try {
   324          const _ret = WEBEXT.login.onExternalLogoutDone.removeListener(A.H.get<object>(callback));
   325          return A.H.TRUE;
   326        } catch (err: any) {
   327          A.store.Ref(errPtr, err);
   328          return A.H.FALSE;
   329        }
   330      },
   331      "has_HasOnExternalLogoutDone": (): heap.Ref<boolean> => {
   332        if (WEBEXT?.login?.onExternalLogoutDone && "hasListener" in WEBEXT?.login?.onExternalLogoutDone) {
   333          return A.H.TRUE;
   334        }
   335        return A.H.FALSE;
   336      },
   337      "func_HasOnExternalLogoutDone": (fn: Pointer): void => {
   338        A.store.Ref(fn, WEBEXT.login.onExternalLogoutDone.hasListener);
   339      },
   340      "call_HasOnExternalLogoutDone": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   341        const _ret = WEBEXT.login.onExternalLogoutDone.hasListener(A.H.get<object>(callback));
   342        A.store.Bool(retPtr, _ret);
   343      },
   344      "try_HasOnExternalLogoutDone": (
   345        retPtr: Pointer,
   346        errPtr: Pointer,
   347        callback: heap.Ref<object>
   348      ): heap.Ref<boolean> => {
   349        try {
   350          const _ret = WEBEXT.login.onExternalLogoutDone.hasListener(A.H.get<object>(callback));
   351          A.store.Bool(retPtr, _ret);
   352          return A.H.TRUE;
   353        } catch (err: any) {
   354          A.store.Ref(errPtr, err);
   355          return A.H.FALSE;
   356        }
   357      },
   358      "has_OnRequestExternalLogout": (): heap.Ref<boolean> => {
   359        if (WEBEXT?.login?.onRequestExternalLogout && "addListener" in WEBEXT?.login?.onRequestExternalLogout) {
   360          return A.H.TRUE;
   361        }
   362        return A.H.FALSE;
   363      },
   364      "func_OnRequestExternalLogout": (fn: Pointer): void => {
   365        A.store.Ref(fn, WEBEXT.login.onRequestExternalLogout.addListener);
   366      },
   367      "call_OnRequestExternalLogout": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   368        const _ret = WEBEXT.login.onRequestExternalLogout.addListener(A.H.get<object>(callback));
   369      },
   370      "try_OnRequestExternalLogout": (
   371        retPtr: Pointer,
   372        errPtr: Pointer,
   373        callback: heap.Ref<object>
   374      ): heap.Ref<boolean> => {
   375        try {
   376          const _ret = WEBEXT.login.onRequestExternalLogout.addListener(A.H.get<object>(callback));
   377          return A.H.TRUE;
   378        } catch (err: any) {
   379          A.store.Ref(errPtr, err);
   380          return A.H.FALSE;
   381        }
   382      },
   383      "has_OffRequestExternalLogout": (): heap.Ref<boolean> => {
   384        if (WEBEXT?.login?.onRequestExternalLogout && "removeListener" in WEBEXT?.login?.onRequestExternalLogout) {
   385          return A.H.TRUE;
   386        }
   387        return A.H.FALSE;
   388      },
   389      "func_OffRequestExternalLogout": (fn: Pointer): void => {
   390        A.store.Ref(fn, WEBEXT.login.onRequestExternalLogout.removeListener);
   391      },
   392      "call_OffRequestExternalLogout": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   393        const _ret = WEBEXT.login.onRequestExternalLogout.removeListener(A.H.get<object>(callback));
   394      },
   395      "try_OffRequestExternalLogout": (
   396        retPtr: Pointer,
   397        errPtr: Pointer,
   398        callback: heap.Ref<object>
   399      ): heap.Ref<boolean> => {
   400        try {
   401          const _ret = WEBEXT.login.onRequestExternalLogout.removeListener(A.H.get<object>(callback));
   402          return A.H.TRUE;
   403        } catch (err: any) {
   404          A.store.Ref(errPtr, err);
   405          return A.H.FALSE;
   406        }
   407      },
   408      "has_HasOnRequestExternalLogout": (): heap.Ref<boolean> => {
   409        if (WEBEXT?.login?.onRequestExternalLogout && "hasListener" in WEBEXT?.login?.onRequestExternalLogout) {
   410          return A.H.TRUE;
   411        }
   412        return A.H.FALSE;
   413      },
   414      "func_HasOnRequestExternalLogout": (fn: Pointer): void => {
   415        A.store.Ref(fn, WEBEXT.login.onRequestExternalLogout.hasListener);
   416      },
   417      "call_HasOnRequestExternalLogout": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   418        const _ret = WEBEXT.login.onRequestExternalLogout.hasListener(A.H.get<object>(callback));
   419        A.store.Bool(retPtr, _ret);
   420      },
   421      "try_HasOnRequestExternalLogout": (
   422        retPtr: Pointer,
   423        errPtr: Pointer,
   424        callback: heap.Ref<object>
   425      ): heap.Ref<boolean> => {
   426        try {
   427          const _ret = WEBEXT.login.onRequestExternalLogout.hasListener(A.H.get<object>(callback));
   428          A.store.Bool(retPtr, _ret);
   429          return A.H.TRUE;
   430        } catch (err: any) {
   431          A.store.Ref(errPtr, err);
   432          return A.H.FALSE;
   433        }
   434      },
   435      "has_RequestExternalLogout": (): heap.Ref<boolean> => {
   436        if (WEBEXT?.login && "requestExternalLogout" in WEBEXT?.login) {
   437          return A.H.TRUE;
   438        }
   439        return A.H.FALSE;
   440      },
   441      "func_RequestExternalLogout": (fn: Pointer): void => {
   442        A.store.Ref(fn, WEBEXT.login.requestExternalLogout);
   443      },
   444      "call_RequestExternalLogout": (retPtr: Pointer): void => {
   445        const _ret = WEBEXT.login.requestExternalLogout();
   446        A.store.Ref(retPtr, _ret);
   447      },
   448      "try_RequestExternalLogout": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => {
   449        try {
   450          const _ret = WEBEXT.login.requestExternalLogout();
   451          A.store.Ref(retPtr, _ret);
   452          return A.H.TRUE;
   453        } catch (err: any) {
   454          A.store.Ref(errPtr, err);
   455          return A.H.FALSE;
   456        }
   457      },
   458      "has_SetDataForNextLoginAttempt": (): heap.Ref<boolean> => {
   459        if (WEBEXT?.login && "setDataForNextLoginAttempt" in WEBEXT?.login) {
   460          return A.H.TRUE;
   461        }
   462        return A.H.FALSE;
   463      },
   464      "func_SetDataForNextLoginAttempt": (fn: Pointer): void => {
   465        A.store.Ref(fn, WEBEXT.login.setDataForNextLoginAttempt);
   466      },
   467      "call_SetDataForNextLoginAttempt": (retPtr: Pointer, dataForNextLoginAttempt: heap.Ref<object>): void => {
   468        const _ret = WEBEXT.login.setDataForNextLoginAttempt(A.H.get<object>(dataForNextLoginAttempt));
   469        A.store.Ref(retPtr, _ret);
   470      },
   471      "try_SetDataForNextLoginAttempt": (
   472        retPtr: Pointer,
   473        errPtr: Pointer,
   474        dataForNextLoginAttempt: heap.Ref<object>
   475      ): heap.Ref<boolean> => {
   476        try {
   477          const _ret = WEBEXT.login.setDataForNextLoginAttempt(A.H.get<object>(dataForNextLoginAttempt));
   478          A.store.Ref(retPtr, _ret);
   479          return A.H.TRUE;
   480        } catch (err: any) {
   481          A.store.Ref(errPtr, err);
   482          return A.H.FALSE;
   483        }
   484      },
   485      "has_UnlockCurrentSession": (): heap.Ref<boolean> => {
   486        if (WEBEXT?.login && "unlockCurrentSession" in WEBEXT?.login) {
   487          return A.H.TRUE;
   488        }
   489        return A.H.FALSE;
   490      },
   491      "func_UnlockCurrentSession": (fn: Pointer): void => {
   492        A.store.Ref(fn, WEBEXT.login.unlockCurrentSession);
   493      },
   494      "call_UnlockCurrentSession": (retPtr: Pointer, password: heap.Ref<object>): void => {
   495        const _ret = WEBEXT.login.unlockCurrentSession(A.H.get<object>(password));
   496        A.store.Ref(retPtr, _ret);
   497      },
   498      "try_UnlockCurrentSession": (retPtr: Pointer, errPtr: Pointer, password: heap.Ref<object>): heap.Ref<boolean> => {
   499        try {
   500          const _ret = WEBEXT.login.unlockCurrentSession(A.H.get<object>(password));
   501          A.store.Ref(retPtr, _ret);
   502          return A.H.TRUE;
   503        } catch (err: any) {
   504          A.store.Ref(errPtr, err);
   505          return A.H.FALSE;
   506        }
   507      },
   508      "has_UnlockManagedGuestSession": (): heap.Ref<boolean> => {
   509        if (WEBEXT?.login && "unlockManagedGuestSession" in WEBEXT?.login) {
   510          return A.H.TRUE;
   511        }
   512        return A.H.FALSE;
   513      },
   514      "func_UnlockManagedGuestSession": (fn: Pointer): void => {
   515        A.store.Ref(fn, WEBEXT.login.unlockManagedGuestSession);
   516      },
   517      "call_UnlockManagedGuestSession": (retPtr: Pointer, password: heap.Ref<object>): void => {
   518        const _ret = WEBEXT.login.unlockManagedGuestSession(A.H.get<object>(password));
   519        A.store.Ref(retPtr, _ret);
   520      },
   521      "try_UnlockManagedGuestSession": (
   522        retPtr: Pointer,
   523        errPtr: Pointer,
   524        password: heap.Ref<object>
   525      ): heap.Ref<boolean> => {
   526        try {
   527          const _ret = WEBEXT.login.unlockManagedGuestSession(A.H.get<object>(password));
   528          A.store.Ref(retPtr, _ret);
   529          return A.H.TRUE;
   530        } catch (err: any) {
   531          A.store.Ref(errPtr, err);
   532          return A.H.FALSE;
   533        }
   534      },
   535      "has_UnlockSharedSession": (): heap.Ref<boolean> => {
   536        if (WEBEXT?.login && "unlockSharedSession" in WEBEXT?.login) {
   537          return A.H.TRUE;
   538        }
   539        return A.H.FALSE;
   540      },
   541      "func_UnlockSharedSession": (fn: Pointer): void => {
   542        A.store.Ref(fn, WEBEXT.login.unlockSharedSession);
   543      },
   544      "call_UnlockSharedSession": (retPtr: Pointer, password: heap.Ref<object>): void => {
   545        const _ret = WEBEXT.login.unlockSharedSession(A.H.get<object>(password));
   546        A.store.Ref(retPtr, _ret);
   547      },
   548      "try_UnlockSharedSession": (retPtr: Pointer, errPtr: Pointer, password: heap.Ref<object>): heap.Ref<boolean> => {
   549        try {
   550          const _ret = WEBEXT.login.unlockSharedSession(A.H.get<object>(password));
   551          A.store.Ref(retPtr, _ret);
   552          return A.H.TRUE;
   553        } catch (err: any) {
   554          A.store.Ref(errPtr, err);
   555          return A.H.FALSE;
   556        }
   557      },
   558    };
   559  });