github.com/primecitizens/pcz/std@v0.2.1/plat/js/webext/passwordsprivate/bindings/ffi_bindings.ts (about) 1 import { importModule, Application, heap, Pointer } from "@ffi"; 2 3 importModule("plat/js/webext/passwordsprivate", (A: Application) => { 4 const WEBEXT = typeof globalThis.browser === "undefined" ? globalThis.chrome : globalThis.browser; 5 6 return { 7 "store_AddPasswordOptions": (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 + 18, 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 A.store.Bool(ptr + 17, false); 17 A.store.Bool(ptr + 16, false); 18 } else { 19 A.store.Bool(ptr + 18, true); 20 A.store.Ref(ptr + 0, x["url"]); 21 A.store.Ref(ptr + 4, x["username"]); 22 A.store.Ref(ptr + 8, x["password"]); 23 A.store.Ref(ptr + 12, x["note"]); 24 A.store.Bool(ptr + 17, "useAccountStore" in x ? true : false); 25 A.store.Bool(ptr + 16, x["useAccountStore"] ? true : false); 26 } 27 }, 28 "load_AddPasswordOptions": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 29 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 30 31 x["url"] = A.load.Ref(ptr + 0, undefined); 32 x["username"] = A.load.Ref(ptr + 4, undefined); 33 x["password"] = A.load.Ref(ptr + 8, undefined); 34 x["note"] = A.load.Ref(ptr + 12, undefined); 35 if (A.load.Bool(ptr + 17)) { 36 x["useAccountStore"] = A.load.Bool(ptr + 16); 37 } else { 38 delete x["useAccountStore"]; 39 } 40 return create === A.H.TRUE ? A.H.push(x) : ref; 41 }, 42 "constof_CompromiseType": (ref: heap.Ref<string>): number => { 43 const idx = ["LEAKED", "PHISHED", "REUSED", "WEAK"].indexOf(A.H.get(ref)); 44 return idx < 0 ? 0 : idx + 1; 45 }, 46 47 "store_CompromisedInfo": (ptr: Pointer, ref: heap.Ref<any>) => { 48 const x = A.H.get<any>(ref); 49 50 if (typeof x === "undefined") { 51 A.store.Bool(ptr + 19, false); 52 A.store.Bool(ptr + 17, false); 53 A.store.Float64(ptr + 0, 0); 54 A.store.Ref(ptr + 8, undefined); 55 A.store.Ref(ptr + 12, undefined); 56 A.store.Bool(ptr + 18, false); 57 A.store.Bool(ptr + 16, false); 58 } else { 59 A.store.Bool(ptr + 19, true); 60 A.store.Bool(ptr + 17, "compromiseTime" in x ? true : false); 61 A.store.Float64(ptr + 0, x["compromiseTime"] === undefined ? 0 : (x["compromiseTime"] as number)); 62 A.store.Ref(ptr + 8, x["elapsedTimeSinceCompromise"]); 63 A.store.Ref(ptr + 12, x["compromiseTypes"]); 64 A.store.Bool(ptr + 18, "isMuted" in x ? true : false); 65 A.store.Bool(ptr + 16, x["isMuted"] ? true : false); 66 } 67 }, 68 "load_CompromisedInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 69 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 70 71 if (A.load.Bool(ptr + 17)) { 72 x["compromiseTime"] = A.load.Float64(ptr + 0); 73 } else { 74 delete x["compromiseTime"]; 75 } 76 x["elapsedTimeSinceCompromise"] = A.load.Ref(ptr + 8, undefined); 77 x["compromiseTypes"] = A.load.Ref(ptr + 12, undefined); 78 if (A.load.Bool(ptr + 18)) { 79 x["isMuted"] = A.load.Bool(ptr + 16); 80 } else { 81 delete x["isMuted"]; 82 } 83 return create === A.H.TRUE ? A.H.push(x) : ref; 84 }, 85 86 "store_DomainInfo": (ptr: Pointer, ref: heap.Ref<any>) => { 87 const x = A.H.get<any>(ref); 88 89 if (typeof x === "undefined") { 90 A.store.Bool(ptr + 12, false); 91 A.store.Ref(ptr + 0, undefined); 92 A.store.Ref(ptr + 4, undefined); 93 A.store.Ref(ptr + 8, undefined); 94 } else { 95 A.store.Bool(ptr + 12, true); 96 A.store.Ref(ptr + 0, x["name"]); 97 A.store.Ref(ptr + 4, x["url"]); 98 A.store.Ref(ptr + 8, x["signonRealm"]); 99 } 100 }, 101 "load_DomainInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 102 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 103 104 x["name"] = A.load.Ref(ptr + 0, undefined); 105 x["url"] = A.load.Ref(ptr + 4, undefined); 106 x["signonRealm"] = A.load.Ref(ptr + 8, undefined); 107 return create === A.H.TRUE ? A.H.push(x) : ref; 108 }, 109 "constof_PasswordStoreSet": (ref: heap.Ref<string>): number => { 110 const idx = ["DEVICE", "ACCOUNT", "DEVICE_AND_ACCOUNT"].indexOf(A.H.get(ref)); 111 return idx < 0 ? 0 : idx + 1; 112 }, 113 114 "store_PasswordUiEntry": (ptr: Pointer, ref: heap.Ref<any>) => { 115 const x = A.H.get<any>(ref); 116 117 if (typeof x === "undefined") { 118 A.store.Bool(ptr + 62, false); 119 A.store.Ref(ptr + 0, undefined); 120 A.store.Ref(ptr + 4, undefined); 121 A.store.Ref(ptr + 8, undefined); 122 A.store.Ref(ptr + 12, undefined); 123 A.store.Ref(ptr + 16, undefined); 124 A.store.Bool(ptr + 60, false); 125 A.store.Int32(ptr + 20, 0); 126 A.store.Enum(ptr + 24, -1); 127 A.store.Bool(ptr + 61, false); 128 A.store.Bool(ptr + 28, false); 129 A.store.Ref(ptr + 32, undefined); 130 A.store.Ref(ptr + 36, undefined); 131 132 A.store.Bool(ptr + 40 + 19, false); 133 A.store.Bool(ptr + 40 + 17, false); 134 A.store.Float64(ptr + 40 + 0, 0); 135 A.store.Ref(ptr + 40 + 8, undefined); 136 A.store.Ref(ptr + 40 + 12, undefined); 137 A.store.Bool(ptr + 40 + 18, false); 138 A.store.Bool(ptr + 40 + 16, false); 139 } else { 140 A.store.Bool(ptr + 62, true); 141 A.store.Ref(ptr + 0, x["affiliatedDomains"]); 142 A.store.Ref(ptr + 4, x["username"]); 143 A.store.Ref(ptr + 8, x["displayName"]); 144 A.store.Ref(ptr + 12, x["password"]); 145 A.store.Ref(ptr + 16, x["federationText"]); 146 A.store.Bool(ptr + 60, "id" in x ? true : false); 147 A.store.Int32(ptr + 20, x["id"] === undefined ? 0 : (x["id"] as number)); 148 A.store.Enum(ptr + 24, ["DEVICE", "ACCOUNT", "DEVICE_AND_ACCOUNT"].indexOf(x["storedIn"] as string)); 149 A.store.Bool(ptr + 61, "isPasskey" in x ? true : false); 150 A.store.Bool(ptr + 28, x["isPasskey"] ? true : false); 151 A.store.Ref(ptr + 32, x["note"]); 152 A.store.Ref(ptr + 36, x["changePasswordUrl"]); 153 154 if (typeof x["compromisedInfo"] === "undefined") { 155 A.store.Bool(ptr + 40 + 19, false); 156 A.store.Bool(ptr + 40 + 17, false); 157 A.store.Float64(ptr + 40 + 0, 0); 158 A.store.Ref(ptr + 40 + 8, undefined); 159 A.store.Ref(ptr + 40 + 12, undefined); 160 A.store.Bool(ptr + 40 + 18, false); 161 A.store.Bool(ptr + 40 + 16, false); 162 } else { 163 A.store.Bool(ptr + 40 + 19, true); 164 A.store.Bool(ptr + 40 + 17, "compromiseTime" in x["compromisedInfo"] ? true : false); 165 A.store.Float64( 166 ptr + 40 + 0, 167 x["compromisedInfo"]["compromiseTime"] === undefined 168 ? 0 169 : (x["compromisedInfo"]["compromiseTime"] as number) 170 ); 171 A.store.Ref(ptr + 40 + 8, x["compromisedInfo"]["elapsedTimeSinceCompromise"]); 172 A.store.Ref(ptr + 40 + 12, x["compromisedInfo"]["compromiseTypes"]); 173 A.store.Bool(ptr + 40 + 18, "isMuted" in x["compromisedInfo"] ? true : false); 174 A.store.Bool(ptr + 40 + 16, x["compromisedInfo"]["isMuted"] ? true : false); 175 } 176 } 177 }, 178 "load_PasswordUiEntry": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 179 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 180 181 x["affiliatedDomains"] = A.load.Ref(ptr + 0, undefined); 182 x["username"] = A.load.Ref(ptr + 4, undefined); 183 x["displayName"] = A.load.Ref(ptr + 8, undefined); 184 x["password"] = A.load.Ref(ptr + 12, undefined); 185 x["federationText"] = A.load.Ref(ptr + 16, undefined); 186 if (A.load.Bool(ptr + 60)) { 187 x["id"] = A.load.Int32(ptr + 20); 188 } else { 189 delete x["id"]; 190 } 191 x["storedIn"] = A.load.Enum(ptr + 24, ["DEVICE", "ACCOUNT", "DEVICE_AND_ACCOUNT"]); 192 if (A.load.Bool(ptr + 61)) { 193 x["isPasskey"] = A.load.Bool(ptr + 28); 194 } else { 195 delete x["isPasskey"]; 196 } 197 x["note"] = A.load.Ref(ptr + 32, undefined); 198 x["changePasswordUrl"] = A.load.Ref(ptr + 36, undefined); 199 if (A.load.Bool(ptr + 40 + 19)) { 200 x["compromisedInfo"] = {}; 201 if (A.load.Bool(ptr + 40 + 17)) { 202 x["compromisedInfo"]["compromiseTime"] = A.load.Float64(ptr + 40 + 0); 203 } else { 204 delete x["compromisedInfo"]["compromiseTime"]; 205 } 206 x["compromisedInfo"]["elapsedTimeSinceCompromise"] = A.load.Ref(ptr + 40 + 8, undefined); 207 x["compromisedInfo"]["compromiseTypes"] = A.load.Ref(ptr + 40 + 12, undefined); 208 if (A.load.Bool(ptr + 40 + 18)) { 209 x["compromisedInfo"]["isMuted"] = A.load.Bool(ptr + 40 + 16); 210 } else { 211 delete x["compromisedInfo"]["isMuted"]; 212 } 213 } else { 214 delete x["compromisedInfo"]; 215 } 216 return create === A.H.TRUE ? A.H.push(x) : ref; 217 }, 218 219 "store_CredentialGroup": (ptr: Pointer, ref: heap.Ref<any>) => { 220 const x = A.H.get<any>(ref); 221 222 if (typeof x === "undefined") { 223 A.store.Bool(ptr + 12, false); 224 A.store.Ref(ptr + 0, undefined); 225 A.store.Ref(ptr + 4, undefined); 226 A.store.Ref(ptr + 8, undefined); 227 } else { 228 A.store.Bool(ptr + 12, true); 229 A.store.Ref(ptr + 0, x["name"]); 230 A.store.Ref(ptr + 4, x["iconUrl"]); 231 A.store.Ref(ptr + 8, x["entries"]); 232 } 233 }, 234 "load_CredentialGroup": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 235 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 236 237 x["name"] = A.load.Ref(ptr + 0, undefined); 238 x["iconUrl"] = A.load.Ref(ptr + 4, undefined); 239 x["entries"] = A.load.Ref(ptr + 8, undefined); 240 return create === A.H.TRUE ? A.H.push(x) : ref; 241 }, 242 243 "store_PasswordUiEntryList": (ptr: Pointer, ref: heap.Ref<any>) => { 244 const x = A.H.get<any>(ref); 245 246 if (typeof x === "undefined") { 247 A.store.Bool(ptr + 4, false); 248 A.store.Ref(ptr + 0, undefined); 249 } else { 250 A.store.Bool(ptr + 4, true); 251 A.store.Ref(ptr + 0, x["entries"]); 252 } 253 }, 254 "load_PasswordUiEntryList": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 255 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 256 257 x["entries"] = A.load.Ref(ptr + 0, undefined); 258 return create === A.H.TRUE ? A.H.push(x) : ref; 259 }, 260 261 "store_UrlCollection": (ptr: Pointer, ref: heap.Ref<any>) => { 262 const x = A.H.get<any>(ref); 263 264 if (typeof x === "undefined") { 265 A.store.Bool(ptr + 12, false); 266 A.store.Ref(ptr + 0, undefined); 267 A.store.Ref(ptr + 4, undefined); 268 A.store.Ref(ptr + 8, undefined); 269 } else { 270 A.store.Bool(ptr + 12, true); 271 A.store.Ref(ptr + 0, x["signonRealm"]); 272 A.store.Ref(ptr + 4, x["shown"]); 273 A.store.Ref(ptr + 8, x["link"]); 274 } 275 }, 276 "load_UrlCollection": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 277 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 278 279 x["signonRealm"] = A.load.Ref(ptr + 0, undefined); 280 x["shown"] = A.load.Ref(ptr + 4, undefined); 281 x["link"] = A.load.Ref(ptr + 8, undefined); 282 return create === A.H.TRUE ? A.H.push(x) : ref; 283 }, 284 285 "store_ExceptionEntry": (ptr: Pointer, ref: heap.Ref<any>) => { 286 const x = A.H.get<any>(ref); 287 288 if (typeof x === "undefined") { 289 A.store.Bool(ptr + 21, false); 290 291 A.store.Bool(ptr + 0 + 12, false); 292 A.store.Ref(ptr + 0 + 0, undefined); 293 A.store.Ref(ptr + 0 + 4, undefined); 294 A.store.Ref(ptr + 0 + 8, undefined); 295 A.store.Bool(ptr + 20, false); 296 A.store.Int32(ptr + 16, 0); 297 } else { 298 A.store.Bool(ptr + 21, true); 299 300 if (typeof x["urls"] === "undefined") { 301 A.store.Bool(ptr + 0 + 12, false); 302 A.store.Ref(ptr + 0 + 0, undefined); 303 A.store.Ref(ptr + 0 + 4, undefined); 304 A.store.Ref(ptr + 0 + 8, undefined); 305 } else { 306 A.store.Bool(ptr + 0 + 12, true); 307 A.store.Ref(ptr + 0 + 0, x["urls"]["signonRealm"]); 308 A.store.Ref(ptr + 0 + 4, x["urls"]["shown"]); 309 A.store.Ref(ptr + 0 + 8, x["urls"]["link"]); 310 } 311 A.store.Bool(ptr + 20, "id" in x ? true : false); 312 A.store.Int32(ptr + 16, x["id"] === undefined ? 0 : (x["id"] as number)); 313 } 314 }, 315 "load_ExceptionEntry": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 316 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 317 318 if (A.load.Bool(ptr + 0 + 12)) { 319 x["urls"] = {}; 320 x["urls"]["signonRealm"] = A.load.Ref(ptr + 0 + 0, undefined); 321 x["urls"]["shown"] = A.load.Ref(ptr + 0 + 4, undefined); 322 x["urls"]["link"] = A.load.Ref(ptr + 0 + 8, undefined); 323 } else { 324 delete x["urls"]; 325 } 326 if (A.load.Bool(ptr + 20)) { 327 x["id"] = A.load.Int32(ptr + 16); 328 } else { 329 delete x["id"]; 330 } 331 return create === A.H.TRUE ? A.H.push(x) : ref; 332 }, 333 "constof_ExportProgressStatus": (ref: heap.Ref<string>): number => { 334 const idx = ["NOT_STARTED", "IN_PROGRESS", "SUCCEEDED", "FAILED_CANCELLED", "FAILED_WRITE_FAILED"].indexOf( 335 A.H.get(ref) 336 ); 337 return idx < 0 ? 0 : idx + 1; 338 }, 339 "constof_FamilyFetchStatus": (ref: heap.Ref<string>): number => { 340 const idx = ["UNKNOWN_ERROR", "NO_MEMBERS", "SUCCESS"].indexOf(A.H.get(ref)); 341 return idx < 0 ? 0 : idx + 1; 342 }, 343 344 "store_PublicKey": (ptr: Pointer, ref: heap.Ref<any>) => { 345 const x = A.H.get<any>(ref); 346 347 if (typeof x === "undefined") { 348 A.store.Bool(ptr + 9, false); 349 A.store.Ref(ptr + 0, undefined); 350 A.store.Bool(ptr + 8, false); 351 A.store.Int32(ptr + 4, 0); 352 } else { 353 A.store.Bool(ptr + 9, true); 354 A.store.Ref(ptr + 0, x["value"]); 355 A.store.Bool(ptr + 8, "version" in x ? true : false); 356 A.store.Int32(ptr + 4, x["version"] === undefined ? 0 : (x["version"] as number)); 357 } 358 }, 359 "load_PublicKey": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 360 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 361 362 x["value"] = A.load.Ref(ptr + 0, undefined); 363 if (A.load.Bool(ptr + 8)) { 364 x["version"] = A.load.Int32(ptr + 4); 365 } else { 366 delete x["version"]; 367 } 368 return create === A.H.TRUE ? A.H.push(x) : ref; 369 }, 370 371 "store_RecipientInfo": (ptr: Pointer, ref: heap.Ref<any>) => { 372 const x = A.H.get<any>(ref); 373 374 if (typeof x === "undefined") { 375 A.store.Bool(ptr + 31, false); 376 A.store.Ref(ptr + 0, undefined); 377 A.store.Ref(ptr + 4, undefined); 378 A.store.Ref(ptr + 8, undefined); 379 A.store.Ref(ptr + 12, undefined); 380 A.store.Bool(ptr + 30, false); 381 A.store.Bool(ptr + 16, false); 382 383 A.store.Bool(ptr + 20 + 9, false); 384 A.store.Ref(ptr + 20 + 0, undefined); 385 A.store.Bool(ptr + 20 + 8, false); 386 A.store.Int32(ptr + 20 + 4, 0); 387 } else { 388 A.store.Bool(ptr + 31, true); 389 A.store.Ref(ptr + 0, x["userId"]); 390 A.store.Ref(ptr + 4, x["email"]); 391 A.store.Ref(ptr + 8, x["displayName"]); 392 A.store.Ref(ptr + 12, x["profileImageUrl"]); 393 A.store.Bool(ptr + 30, "isEligible" in x ? true : false); 394 A.store.Bool(ptr + 16, x["isEligible"] ? true : false); 395 396 if (typeof x["publicKey"] === "undefined") { 397 A.store.Bool(ptr + 20 + 9, false); 398 A.store.Ref(ptr + 20 + 0, undefined); 399 A.store.Bool(ptr + 20 + 8, false); 400 A.store.Int32(ptr + 20 + 4, 0); 401 } else { 402 A.store.Bool(ptr + 20 + 9, true); 403 A.store.Ref(ptr + 20 + 0, x["publicKey"]["value"]); 404 A.store.Bool(ptr + 20 + 8, "version" in x["publicKey"] ? true : false); 405 A.store.Int32( 406 ptr + 20 + 4, 407 x["publicKey"]["version"] === undefined ? 0 : (x["publicKey"]["version"] as number) 408 ); 409 } 410 } 411 }, 412 "load_RecipientInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 413 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 414 415 x["userId"] = A.load.Ref(ptr + 0, undefined); 416 x["email"] = A.load.Ref(ptr + 4, undefined); 417 x["displayName"] = A.load.Ref(ptr + 8, undefined); 418 x["profileImageUrl"] = A.load.Ref(ptr + 12, undefined); 419 if (A.load.Bool(ptr + 30)) { 420 x["isEligible"] = A.load.Bool(ptr + 16); 421 } else { 422 delete x["isEligible"]; 423 } 424 if (A.load.Bool(ptr + 20 + 9)) { 425 x["publicKey"] = {}; 426 x["publicKey"]["value"] = A.load.Ref(ptr + 20 + 0, undefined); 427 if (A.load.Bool(ptr + 20 + 8)) { 428 x["publicKey"]["version"] = A.load.Int32(ptr + 20 + 4); 429 } else { 430 delete x["publicKey"]["version"]; 431 } 432 } else { 433 delete x["publicKey"]; 434 } 435 return create === A.H.TRUE ? A.H.push(x) : ref; 436 }, 437 438 "store_FamilyFetchResults": (ptr: Pointer, ref: heap.Ref<any>) => { 439 const x = A.H.get<any>(ref); 440 441 if (typeof x === "undefined") { 442 A.store.Bool(ptr + 8, false); 443 A.store.Enum(ptr + 0, -1); 444 A.store.Ref(ptr + 4, undefined); 445 } else { 446 A.store.Bool(ptr + 8, true); 447 A.store.Enum(ptr + 0, ["UNKNOWN_ERROR", "NO_MEMBERS", "SUCCESS"].indexOf(x["status"] as string)); 448 A.store.Ref(ptr + 4, x["familyMembers"]); 449 } 450 }, 451 "load_FamilyFetchResults": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 452 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 453 454 x["status"] = A.load.Enum(ptr + 0, ["UNKNOWN_ERROR", "NO_MEMBERS", "SUCCESS"]); 455 x["familyMembers"] = A.load.Ref(ptr + 4, undefined); 456 return create === A.H.TRUE ? A.H.push(x) : ref; 457 }, 458 "constof_ImportEntryStatus": (ref: heap.Ref<string>): number => { 459 const idx = [ 460 "UNKNOWN_ERROR", 461 "MISSING_PASSWORD", 462 "MISSING_URL", 463 "INVALID_URL", 464 "NON_ASCII_URL", 465 "LONG_URL", 466 "LONG_PASSWORD", 467 "LONG_USERNAME", 468 "CONFLICT_PROFILE", 469 "CONFLICT_ACCOUNT", 470 "LONG_NOTE", 471 "LONG_CONCATENATED_NOTE", 472 "VALID", 473 ].indexOf(A.H.get(ref)); 474 return idx < 0 ? 0 : idx + 1; 475 }, 476 477 "store_ImportEntry": (ptr: Pointer, ref: heap.Ref<any>) => { 478 const x = A.H.get<any>(ref); 479 480 if (typeof x === "undefined") { 481 A.store.Bool(ptr + 21, false); 482 A.store.Enum(ptr + 0, -1); 483 A.store.Ref(ptr + 4, undefined); 484 A.store.Ref(ptr + 8, undefined); 485 A.store.Ref(ptr + 12, undefined); 486 A.store.Bool(ptr + 20, false); 487 A.store.Int32(ptr + 16, 0); 488 } else { 489 A.store.Bool(ptr + 21, true); 490 A.store.Enum( 491 ptr + 0, 492 [ 493 "UNKNOWN_ERROR", 494 "MISSING_PASSWORD", 495 "MISSING_URL", 496 "INVALID_URL", 497 "NON_ASCII_URL", 498 "LONG_URL", 499 "LONG_PASSWORD", 500 "LONG_USERNAME", 501 "CONFLICT_PROFILE", 502 "CONFLICT_ACCOUNT", 503 "LONG_NOTE", 504 "LONG_CONCATENATED_NOTE", 505 "VALID", 506 ].indexOf(x["status"] as string) 507 ); 508 A.store.Ref(ptr + 4, x["url"]); 509 A.store.Ref(ptr + 8, x["username"]); 510 A.store.Ref(ptr + 12, x["password"]); 511 A.store.Bool(ptr + 20, "id" in x ? true : false); 512 A.store.Int32(ptr + 16, x["id"] === undefined ? 0 : (x["id"] as number)); 513 } 514 }, 515 "load_ImportEntry": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 516 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 517 518 x["status"] = A.load.Enum(ptr + 0, [ 519 "UNKNOWN_ERROR", 520 "MISSING_PASSWORD", 521 "MISSING_URL", 522 "INVALID_URL", 523 "NON_ASCII_URL", 524 "LONG_URL", 525 "LONG_PASSWORD", 526 "LONG_USERNAME", 527 "CONFLICT_PROFILE", 528 "CONFLICT_ACCOUNT", 529 "LONG_NOTE", 530 "LONG_CONCATENATED_NOTE", 531 "VALID", 532 ]); 533 x["url"] = A.load.Ref(ptr + 4, undefined); 534 x["username"] = A.load.Ref(ptr + 8, undefined); 535 x["password"] = A.load.Ref(ptr + 12, undefined); 536 if (A.load.Bool(ptr + 20)) { 537 x["id"] = A.load.Int32(ptr + 16); 538 } else { 539 delete x["id"]; 540 } 541 return create === A.H.TRUE ? A.H.push(x) : ref; 542 }, 543 "constof_ImportResultsStatus": (ref: heap.Ref<string>): number => { 544 const idx = [ 545 "UNKNOWN_ERROR", 546 "SUCCESS", 547 "IO_ERROR", 548 "BAD_FORMAT", 549 "DISMISSED", 550 "MAX_FILE_SIZE", 551 "IMPORT_ALREADY_ACTIVE", 552 "NUM_PASSWORDS_EXCEEDED", 553 "CONFLICTS", 554 ].indexOf(A.H.get(ref)); 555 return idx < 0 ? 0 : idx + 1; 556 }, 557 558 "store_ImportResults": (ptr: Pointer, ref: heap.Ref<any>) => { 559 const x = A.H.get<any>(ref); 560 561 if (typeof x === "undefined") { 562 A.store.Bool(ptr + 17, false); 563 A.store.Enum(ptr + 0, -1); 564 A.store.Bool(ptr + 16, false); 565 A.store.Int32(ptr + 4, 0); 566 A.store.Ref(ptr + 8, undefined); 567 A.store.Ref(ptr + 12, undefined); 568 } else { 569 A.store.Bool(ptr + 17, true); 570 A.store.Enum( 571 ptr + 0, 572 [ 573 "UNKNOWN_ERROR", 574 "SUCCESS", 575 "IO_ERROR", 576 "BAD_FORMAT", 577 "DISMISSED", 578 "MAX_FILE_SIZE", 579 "IMPORT_ALREADY_ACTIVE", 580 "NUM_PASSWORDS_EXCEEDED", 581 "CONFLICTS", 582 ].indexOf(x["status"] as string) 583 ); 584 A.store.Bool(ptr + 16, "numberImported" in x ? true : false); 585 A.store.Int32(ptr + 4, x["numberImported"] === undefined ? 0 : (x["numberImported"] as number)); 586 A.store.Ref(ptr + 8, x["displayedEntries"]); 587 A.store.Ref(ptr + 12, x["fileName"]); 588 } 589 }, 590 "load_ImportResults": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 591 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 592 593 x["status"] = A.load.Enum(ptr + 0, [ 594 "UNKNOWN_ERROR", 595 "SUCCESS", 596 "IO_ERROR", 597 "BAD_FORMAT", 598 "DISMISSED", 599 "MAX_FILE_SIZE", 600 "IMPORT_ALREADY_ACTIVE", 601 "NUM_PASSWORDS_EXCEEDED", 602 "CONFLICTS", 603 ]); 604 if (A.load.Bool(ptr + 16)) { 605 x["numberImported"] = A.load.Int32(ptr + 4); 606 } else { 607 delete x["numberImported"]; 608 } 609 x["displayedEntries"] = A.load.Ref(ptr + 8, undefined); 610 x["fileName"] = A.load.Ref(ptr + 12, undefined); 611 return create === A.H.TRUE ? A.H.push(x) : ref; 612 }, 613 "constof_PasswordCheckState": (ref: heap.Ref<string>): number => { 614 const idx = [ 615 "IDLE", 616 "RUNNING", 617 "CANCELED", 618 "OFFLINE", 619 "SIGNED_OUT", 620 "NO_PASSWORDS", 621 "QUOTA_LIMIT", 622 "OTHER_ERROR", 623 ].indexOf(A.H.get(ref)); 624 return idx < 0 ? 0 : idx + 1; 625 }, 626 627 "store_PasswordCheckStatus": (ptr: Pointer, ref: heap.Ref<any>) => { 628 const x = A.H.get<any>(ref); 629 630 if (typeof x === "undefined") { 631 A.store.Bool(ptr + 23, false); 632 A.store.Enum(ptr + 0, -1); 633 A.store.Bool(ptr + 20, false); 634 A.store.Int32(ptr + 4, 0); 635 A.store.Bool(ptr + 21, false); 636 A.store.Int32(ptr + 8, 0); 637 A.store.Bool(ptr + 22, false); 638 A.store.Int32(ptr + 12, 0); 639 A.store.Ref(ptr + 16, undefined); 640 } else { 641 A.store.Bool(ptr + 23, true); 642 A.store.Enum( 643 ptr + 0, 644 [ 645 "IDLE", 646 "RUNNING", 647 "CANCELED", 648 "OFFLINE", 649 "SIGNED_OUT", 650 "NO_PASSWORDS", 651 "QUOTA_LIMIT", 652 "OTHER_ERROR", 653 ].indexOf(x["state"] as string) 654 ); 655 A.store.Bool(ptr + 20, "totalNumberOfPasswords" in x ? true : false); 656 A.store.Int32(ptr + 4, x["totalNumberOfPasswords"] === undefined ? 0 : (x["totalNumberOfPasswords"] as number)); 657 A.store.Bool(ptr + 21, "alreadyProcessed" in x ? true : false); 658 A.store.Int32(ptr + 8, x["alreadyProcessed"] === undefined ? 0 : (x["alreadyProcessed"] as number)); 659 A.store.Bool(ptr + 22, "remainingInQueue" in x ? true : false); 660 A.store.Int32(ptr + 12, x["remainingInQueue"] === undefined ? 0 : (x["remainingInQueue"] as number)); 661 A.store.Ref(ptr + 16, x["elapsedTimeSinceLastCheck"]); 662 } 663 }, 664 "load_PasswordCheckStatus": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 665 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 666 667 x["state"] = A.load.Enum(ptr + 0, [ 668 "IDLE", 669 "RUNNING", 670 "CANCELED", 671 "OFFLINE", 672 "SIGNED_OUT", 673 "NO_PASSWORDS", 674 "QUOTA_LIMIT", 675 "OTHER_ERROR", 676 ]); 677 if (A.load.Bool(ptr + 20)) { 678 x["totalNumberOfPasswords"] = A.load.Int32(ptr + 4); 679 } else { 680 delete x["totalNumberOfPasswords"]; 681 } 682 if (A.load.Bool(ptr + 21)) { 683 x["alreadyProcessed"] = A.load.Int32(ptr + 8); 684 } else { 685 delete x["alreadyProcessed"]; 686 } 687 if (A.load.Bool(ptr + 22)) { 688 x["remainingInQueue"] = A.load.Int32(ptr + 12); 689 } else { 690 delete x["remainingInQueue"]; 691 } 692 x["elapsedTimeSinceLastCheck"] = A.load.Ref(ptr + 16, undefined); 693 return create === A.H.TRUE ? A.H.push(x) : ref; 694 }, 695 696 "store_PasswordExportProgress": (ptr: Pointer, ref: heap.Ref<any>) => { 697 const x = A.H.get<any>(ref); 698 699 if (typeof x === "undefined") { 700 A.store.Bool(ptr + 12, false); 701 A.store.Enum(ptr + 0, -1); 702 A.store.Ref(ptr + 4, undefined); 703 A.store.Ref(ptr + 8, undefined); 704 } else { 705 A.store.Bool(ptr + 12, true); 706 A.store.Enum( 707 ptr + 0, 708 ["NOT_STARTED", "IN_PROGRESS", "SUCCEEDED", "FAILED_CANCELLED", "FAILED_WRITE_FAILED"].indexOf( 709 x["status"] as string 710 ) 711 ); 712 A.store.Ref(ptr + 4, x["filePath"]); 713 A.store.Ref(ptr + 8, x["folderName"]); 714 } 715 }, 716 "load_PasswordExportProgress": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 717 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 718 719 x["status"] = A.load.Enum(ptr + 0, [ 720 "NOT_STARTED", 721 "IN_PROGRESS", 722 "SUCCEEDED", 723 "FAILED_CANCELLED", 724 "FAILED_WRITE_FAILED", 725 ]); 726 x["filePath"] = A.load.Ref(ptr + 4, undefined); 727 x["folderName"] = A.load.Ref(ptr + 8, undefined); 728 return create === A.H.TRUE ? A.H.push(x) : ref; 729 }, 730 "constof_PlaintextReason": (ref: heap.Ref<string>): number => { 731 const idx = ["VIEW", "COPY", "EDIT"].indexOf(A.H.get(ref)); 732 return idx < 0 ? 0 : idx + 1; 733 }, 734 "has_AddPassword": (): heap.Ref<boolean> => { 735 if (WEBEXT?.passwordsPrivate && "addPassword" in WEBEXT?.passwordsPrivate) { 736 return A.H.TRUE; 737 } 738 return A.H.FALSE; 739 }, 740 "func_AddPassword": (fn: Pointer): void => { 741 A.store.Ref(fn, WEBEXT.passwordsPrivate.addPassword); 742 }, 743 "call_AddPassword": (retPtr: Pointer, options: Pointer): void => { 744 const options_ffi = {}; 745 746 options_ffi["url"] = A.load.Ref(options + 0, undefined); 747 options_ffi["username"] = A.load.Ref(options + 4, undefined); 748 options_ffi["password"] = A.load.Ref(options + 8, undefined); 749 options_ffi["note"] = A.load.Ref(options + 12, undefined); 750 if (A.load.Bool(options + 17)) { 751 options_ffi["useAccountStore"] = A.load.Bool(options + 16); 752 } 753 754 const _ret = WEBEXT.passwordsPrivate.addPassword(options_ffi); 755 A.store.Ref(retPtr, _ret); 756 }, 757 "try_AddPassword": (retPtr: Pointer, errPtr: Pointer, options: Pointer): heap.Ref<boolean> => { 758 try { 759 const options_ffi = {}; 760 761 options_ffi["url"] = A.load.Ref(options + 0, undefined); 762 options_ffi["username"] = A.load.Ref(options + 4, undefined); 763 options_ffi["password"] = A.load.Ref(options + 8, undefined); 764 options_ffi["note"] = A.load.Ref(options + 12, undefined); 765 if (A.load.Bool(options + 17)) { 766 options_ffi["useAccountStore"] = A.load.Bool(options + 16); 767 } 768 769 const _ret = WEBEXT.passwordsPrivate.addPassword(options_ffi); 770 A.store.Ref(retPtr, _ret); 771 return A.H.TRUE; 772 } catch (err: any) { 773 A.store.Ref(errPtr, err); 774 return A.H.FALSE; 775 } 776 }, 777 "has_ChangeCredential": (): heap.Ref<boolean> => { 778 if (WEBEXT?.passwordsPrivate && "changeCredential" in WEBEXT?.passwordsPrivate) { 779 return A.H.TRUE; 780 } 781 return A.H.FALSE; 782 }, 783 "func_ChangeCredential": (fn: Pointer): void => { 784 A.store.Ref(fn, WEBEXT.passwordsPrivate.changeCredential); 785 }, 786 "call_ChangeCredential": (retPtr: Pointer, credential: Pointer): void => { 787 const credential_ffi = {}; 788 789 credential_ffi["affiliatedDomains"] = A.load.Ref(credential + 0, undefined); 790 credential_ffi["username"] = A.load.Ref(credential + 4, undefined); 791 credential_ffi["displayName"] = A.load.Ref(credential + 8, undefined); 792 credential_ffi["password"] = A.load.Ref(credential + 12, undefined); 793 credential_ffi["federationText"] = A.load.Ref(credential + 16, undefined); 794 if (A.load.Bool(credential + 60)) { 795 credential_ffi["id"] = A.load.Int32(credential + 20); 796 } 797 credential_ffi["storedIn"] = A.load.Enum(credential + 24, ["DEVICE", "ACCOUNT", "DEVICE_AND_ACCOUNT"]); 798 if (A.load.Bool(credential + 61)) { 799 credential_ffi["isPasskey"] = A.load.Bool(credential + 28); 800 } 801 credential_ffi["note"] = A.load.Ref(credential + 32, undefined); 802 credential_ffi["changePasswordUrl"] = A.load.Ref(credential + 36, undefined); 803 if (A.load.Bool(credential + 40 + 19)) { 804 credential_ffi["compromisedInfo"] = {}; 805 if (A.load.Bool(credential + 40 + 17)) { 806 credential_ffi["compromisedInfo"]["compromiseTime"] = A.load.Float64(credential + 40 + 0); 807 } 808 credential_ffi["compromisedInfo"]["elapsedTimeSinceCompromise"] = A.load.Ref(credential + 40 + 8, undefined); 809 credential_ffi["compromisedInfo"]["compromiseTypes"] = A.load.Ref(credential + 40 + 12, undefined); 810 if (A.load.Bool(credential + 40 + 18)) { 811 credential_ffi["compromisedInfo"]["isMuted"] = A.load.Bool(credential + 40 + 16); 812 } 813 } 814 815 const _ret = WEBEXT.passwordsPrivate.changeCredential(credential_ffi); 816 A.store.Ref(retPtr, _ret); 817 }, 818 "try_ChangeCredential": (retPtr: Pointer, errPtr: Pointer, credential: Pointer): heap.Ref<boolean> => { 819 try { 820 const credential_ffi = {}; 821 822 credential_ffi["affiliatedDomains"] = A.load.Ref(credential + 0, undefined); 823 credential_ffi["username"] = A.load.Ref(credential + 4, undefined); 824 credential_ffi["displayName"] = A.load.Ref(credential + 8, undefined); 825 credential_ffi["password"] = A.load.Ref(credential + 12, undefined); 826 credential_ffi["federationText"] = A.load.Ref(credential + 16, undefined); 827 if (A.load.Bool(credential + 60)) { 828 credential_ffi["id"] = A.load.Int32(credential + 20); 829 } 830 credential_ffi["storedIn"] = A.load.Enum(credential + 24, ["DEVICE", "ACCOUNT", "DEVICE_AND_ACCOUNT"]); 831 if (A.load.Bool(credential + 61)) { 832 credential_ffi["isPasskey"] = A.load.Bool(credential + 28); 833 } 834 credential_ffi["note"] = A.load.Ref(credential + 32, undefined); 835 credential_ffi["changePasswordUrl"] = A.load.Ref(credential + 36, undefined); 836 if (A.load.Bool(credential + 40 + 19)) { 837 credential_ffi["compromisedInfo"] = {}; 838 if (A.load.Bool(credential + 40 + 17)) { 839 credential_ffi["compromisedInfo"]["compromiseTime"] = A.load.Float64(credential + 40 + 0); 840 } 841 credential_ffi["compromisedInfo"]["elapsedTimeSinceCompromise"] = A.load.Ref(credential + 40 + 8, undefined); 842 credential_ffi["compromisedInfo"]["compromiseTypes"] = A.load.Ref(credential + 40 + 12, undefined); 843 if (A.load.Bool(credential + 40 + 18)) { 844 credential_ffi["compromisedInfo"]["isMuted"] = A.load.Bool(credential + 40 + 16); 845 } 846 } 847 848 const _ret = WEBEXT.passwordsPrivate.changeCredential(credential_ffi); 849 A.store.Ref(retPtr, _ret); 850 return A.H.TRUE; 851 } catch (err: any) { 852 A.store.Ref(errPtr, err); 853 return A.H.FALSE; 854 } 855 }, 856 "has_ContinueImport": (): heap.Ref<boolean> => { 857 if (WEBEXT?.passwordsPrivate && "continueImport" in WEBEXT?.passwordsPrivate) { 858 return A.H.TRUE; 859 } 860 return A.H.FALSE; 861 }, 862 "func_ContinueImport": (fn: Pointer): void => { 863 A.store.Ref(fn, WEBEXT.passwordsPrivate.continueImport); 864 }, 865 "call_ContinueImport": (retPtr: Pointer, selectedIds: heap.Ref<object>): void => { 866 const _ret = WEBEXT.passwordsPrivate.continueImport(A.H.get<object>(selectedIds)); 867 A.store.Ref(retPtr, _ret); 868 }, 869 "try_ContinueImport": (retPtr: Pointer, errPtr: Pointer, selectedIds: heap.Ref<object>): heap.Ref<boolean> => { 870 try { 871 const _ret = WEBEXT.passwordsPrivate.continueImport(A.H.get<object>(selectedIds)); 872 A.store.Ref(retPtr, _ret); 873 return A.H.TRUE; 874 } catch (err: any) { 875 A.store.Ref(errPtr, err); 876 return A.H.FALSE; 877 } 878 }, 879 "has_ExportPasswords": (): heap.Ref<boolean> => { 880 if (WEBEXT?.passwordsPrivate && "exportPasswords" in WEBEXT?.passwordsPrivate) { 881 return A.H.TRUE; 882 } 883 return A.H.FALSE; 884 }, 885 "func_ExportPasswords": (fn: Pointer): void => { 886 A.store.Ref(fn, WEBEXT.passwordsPrivate.exportPasswords); 887 }, 888 "call_ExportPasswords": (retPtr: Pointer): void => { 889 const _ret = WEBEXT.passwordsPrivate.exportPasswords(); 890 A.store.Ref(retPtr, _ret); 891 }, 892 "try_ExportPasswords": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 893 try { 894 const _ret = WEBEXT.passwordsPrivate.exportPasswords(); 895 A.store.Ref(retPtr, _ret); 896 return A.H.TRUE; 897 } catch (err: any) { 898 A.store.Ref(errPtr, err); 899 return A.H.FALSE; 900 } 901 }, 902 "has_ExtendAuthValidity": (): heap.Ref<boolean> => { 903 if (WEBEXT?.passwordsPrivate && "extendAuthValidity" in WEBEXT?.passwordsPrivate) { 904 return A.H.TRUE; 905 } 906 return A.H.FALSE; 907 }, 908 "func_ExtendAuthValidity": (fn: Pointer): void => { 909 A.store.Ref(fn, WEBEXT.passwordsPrivate.extendAuthValidity); 910 }, 911 "call_ExtendAuthValidity": (retPtr: Pointer): void => { 912 const _ret = WEBEXT.passwordsPrivate.extendAuthValidity(); 913 A.store.Ref(retPtr, _ret); 914 }, 915 "try_ExtendAuthValidity": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 916 try { 917 const _ret = WEBEXT.passwordsPrivate.extendAuthValidity(); 918 A.store.Ref(retPtr, _ret); 919 return A.H.TRUE; 920 } catch (err: any) { 921 A.store.Ref(errPtr, err); 922 return A.H.FALSE; 923 } 924 }, 925 "has_FetchFamilyMembers": (): heap.Ref<boolean> => { 926 if (WEBEXT?.passwordsPrivate && "fetchFamilyMembers" in WEBEXT?.passwordsPrivate) { 927 return A.H.TRUE; 928 } 929 return A.H.FALSE; 930 }, 931 "func_FetchFamilyMembers": (fn: Pointer): void => { 932 A.store.Ref(fn, WEBEXT.passwordsPrivate.fetchFamilyMembers); 933 }, 934 "call_FetchFamilyMembers": (retPtr: Pointer): void => { 935 const _ret = WEBEXT.passwordsPrivate.fetchFamilyMembers(); 936 A.store.Ref(retPtr, _ret); 937 }, 938 "try_FetchFamilyMembers": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 939 try { 940 const _ret = WEBEXT.passwordsPrivate.fetchFamilyMembers(); 941 A.store.Ref(retPtr, _ret); 942 return A.H.TRUE; 943 } catch (err: any) { 944 A.store.Ref(errPtr, err); 945 return A.H.FALSE; 946 } 947 }, 948 "has_GetCredentialGroups": (): heap.Ref<boolean> => { 949 if (WEBEXT?.passwordsPrivate && "getCredentialGroups" in WEBEXT?.passwordsPrivate) { 950 return A.H.TRUE; 951 } 952 return A.H.FALSE; 953 }, 954 "func_GetCredentialGroups": (fn: Pointer): void => { 955 A.store.Ref(fn, WEBEXT.passwordsPrivate.getCredentialGroups); 956 }, 957 "call_GetCredentialGroups": (retPtr: Pointer): void => { 958 const _ret = WEBEXT.passwordsPrivate.getCredentialGroups(); 959 A.store.Ref(retPtr, _ret); 960 }, 961 "try_GetCredentialGroups": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 962 try { 963 const _ret = WEBEXT.passwordsPrivate.getCredentialGroups(); 964 A.store.Ref(retPtr, _ret); 965 return A.H.TRUE; 966 } catch (err: any) { 967 A.store.Ref(errPtr, err); 968 return A.H.FALSE; 969 } 970 }, 971 "has_GetCredentialsWithReusedPassword": (): heap.Ref<boolean> => { 972 if (WEBEXT?.passwordsPrivate && "getCredentialsWithReusedPassword" in WEBEXT?.passwordsPrivate) { 973 return A.H.TRUE; 974 } 975 return A.H.FALSE; 976 }, 977 "func_GetCredentialsWithReusedPassword": (fn: Pointer): void => { 978 A.store.Ref(fn, WEBEXT.passwordsPrivate.getCredentialsWithReusedPassword); 979 }, 980 "call_GetCredentialsWithReusedPassword": (retPtr: Pointer): void => { 981 const _ret = WEBEXT.passwordsPrivate.getCredentialsWithReusedPassword(); 982 A.store.Ref(retPtr, _ret); 983 }, 984 "try_GetCredentialsWithReusedPassword": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 985 try { 986 const _ret = WEBEXT.passwordsPrivate.getCredentialsWithReusedPassword(); 987 A.store.Ref(retPtr, _ret); 988 return A.H.TRUE; 989 } catch (err: any) { 990 A.store.Ref(errPtr, err); 991 return A.H.FALSE; 992 } 993 }, 994 "has_GetInsecureCredentials": (): heap.Ref<boolean> => { 995 if (WEBEXT?.passwordsPrivate && "getInsecureCredentials" in WEBEXT?.passwordsPrivate) { 996 return A.H.TRUE; 997 } 998 return A.H.FALSE; 999 }, 1000 "func_GetInsecureCredentials": (fn: Pointer): void => { 1001 A.store.Ref(fn, WEBEXT.passwordsPrivate.getInsecureCredentials); 1002 }, 1003 "call_GetInsecureCredentials": (retPtr: Pointer): void => { 1004 const _ret = WEBEXT.passwordsPrivate.getInsecureCredentials(); 1005 A.store.Ref(retPtr, _ret); 1006 }, 1007 "try_GetInsecureCredentials": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 1008 try { 1009 const _ret = WEBEXT.passwordsPrivate.getInsecureCredentials(); 1010 A.store.Ref(retPtr, _ret); 1011 return A.H.TRUE; 1012 } catch (err: any) { 1013 A.store.Ref(errPtr, err); 1014 return A.H.FALSE; 1015 } 1016 }, 1017 "has_GetPasswordCheckStatus": (): heap.Ref<boolean> => { 1018 if (WEBEXT?.passwordsPrivate && "getPasswordCheckStatus" in WEBEXT?.passwordsPrivate) { 1019 return A.H.TRUE; 1020 } 1021 return A.H.FALSE; 1022 }, 1023 "func_GetPasswordCheckStatus": (fn: Pointer): void => { 1024 A.store.Ref(fn, WEBEXT.passwordsPrivate.getPasswordCheckStatus); 1025 }, 1026 "call_GetPasswordCheckStatus": (retPtr: Pointer): void => { 1027 const _ret = WEBEXT.passwordsPrivate.getPasswordCheckStatus(); 1028 A.store.Ref(retPtr, _ret); 1029 }, 1030 "try_GetPasswordCheckStatus": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 1031 try { 1032 const _ret = WEBEXT.passwordsPrivate.getPasswordCheckStatus(); 1033 A.store.Ref(retPtr, _ret); 1034 return A.H.TRUE; 1035 } catch (err: any) { 1036 A.store.Ref(errPtr, err); 1037 return A.H.FALSE; 1038 } 1039 }, 1040 "has_GetPasswordExceptionList": (): heap.Ref<boolean> => { 1041 if (WEBEXT?.passwordsPrivate && "getPasswordExceptionList" in WEBEXT?.passwordsPrivate) { 1042 return A.H.TRUE; 1043 } 1044 return A.H.FALSE; 1045 }, 1046 "func_GetPasswordExceptionList": (fn: Pointer): void => { 1047 A.store.Ref(fn, WEBEXT.passwordsPrivate.getPasswordExceptionList); 1048 }, 1049 "call_GetPasswordExceptionList": (retPtr: Pointer): void => { 1050 const _ret = WEBEXT.passwordsPrivate.getPasswordExceptionList(); 1051 A.store.Ref(retPtr, _ret); 1052 }, 1053 "try_GetPasswordExceptionList": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 1054 try { 1055 const _ret = WEBEXT.passwordsPrivate.getPasswordExceptionList(); 1056 A.store.Ref(retPtr, _ret); 1057 return A.H.TRUE; 1058 } catch (err: any) { 1059 A.store.Ref(errPtr, err); 1060 return A.H.FALSE; 1061 } 1062 }, 1063 "has_GetSavedPasswordList": (): heap.Ref<boolean> => { 1064 if (WEBEXT?.passwordsPrivate && "getSavedPasswordList" in WEBEXT?.passwordsPrivate) { 1065 return A.H.TRUE; 1066 } 1067 return A.H.FALSE; 1068 }, 1069 "func_GetSavedPasswordList": (fn: Pointer): void => { 1070 A.store.Ref(fn, WEBEXT.passwordsPrivate.getSavedPasswordList); 1071 }, 1072 "call_GetSavedPasswordList": (retPtr: Pointer): void => { 1073 const _ret = WEBEXT.passwordsPrivate.getSavedPasswordList(); 1074 A.store.Ref(retPtr, _ret); 1075 }, 1076 "try_GetSavedPasswordList": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 1077 try { 1078 const _ret = WEBEXT.passwordsPrivate.getSavedPasswordList(); 1079 A.store.Ref(retPtr, _ret); 1080 return A.H.TRUE; 1081 } catch (err: any) { 1082 A.store.Ref(errPtr, err); 1083 return A.H.FALSE; 1084 } 1085 }, 1086 "has_GetUrlCollection": (): heap.Ref<boolean> => { 1087 if (WEBEXT?.passwordsPrivate && "getUrlCollection" in WEBEXT?.passwordsPrivate) { 1088 return A.H.TRUE; 1089 } 1090 return A.H.FALSE; 1091 }, 1092 "func_GetUrlCollection": (fn: Pointer): void => { 1093 A.store.Ref(fn, WEBEXT.passwordsPrivate.getUrlCollection); 1094 }, 1095 "call_GetUrlCollection": (retPtr: Pointer, url: heap.Ref<object>): void => { 1096 const _ret = WEBEXT.passwordsPrivate.getUrlCollection(A.H.get<object>(url)); 1097 A.store.Ref(retPtr, _ret); 1098 }, 1099 "try_GetUrlCollection": (retPtr: Pointer, errPtr: Pointer, url: heap.Ref<object>): heap.Ref<boolean> => { 1100 try { 1101 const _ret = WEBEXT.passwordsPrivate.getUrlCollection(A.H.get<object>(url)); 1102 A.store.Ref(retPtr, _ret); 1103 return A.H.TRUE; 1104 } catch (err: any) { 1105 A.store.Ref(errPtr, err); 1106 return A.H.FALSE; 1107 } 1108 }, 1109 "has_ImportPasswords": (): heap.Ref<boolean> => { 1110 if (WEBEXT?.passwordsPrivate && "importPasswords" in WEBEXT?.passwordsPrivate) { 1111 return A.H.TRUE; 1112 } 1113 return A.H.FALSE; 1114 }, 1115 "func_ImportPasswords": (fn: Pointer): void => { 1116 A.store.Ref(fn, WEBEXT.passwordsPrivate.importPasswords); 1117 }, 1118 "call_ImportPasswords": (retPtr: Pointer, toStore: number): void => { 1119 const _ret = WEBEXT.passwordsPrivate.importPasswords( 1120 toStore > 0 && toStore <= 3 ? ["DEVICE", "ACCOUNT", "DEVICE_AND_ACCOUNT"][toStore - 1] : undefined 1121 ); 1122 A.store.Ref(retPtr, _ret); 1123 }, 1124 "try_ImportPasswords": (retPtr: Pointer, errPtr: Pointer, toStore: number): heap.Ref<boolean> => { 1125 try { 1126 const _ret = WEBEXT.passwordsPrivate.importPasswords( 1127 toStore > 0 && toStore <= 3 ? ["DEVICE", "ACCOUNT", "DEVICE_AND_ACCOUNT"][toStore - 1] : undefined 1128 ); 1129 A.store.Ref(retPtr, _ret); 1130 return A.H.TRUE; 1131 } catch (err: any) { 1132 A.store.Ref(errPtr, err); 1133 return A.H.FALSE; 1134 } 1135 }, 1136 "has_IsAccountStoreDefault": (): heap.Ref<boolean> => { 1137 if (WEBEXT?.passwordsPrivate && "isAccountStoreDefault" in WEBEXT?.passwordsPrivate) { 1138 return A.H.TRUE; 1139 } 1140 return A.H.FALSE; 1141 }, 1142 "func_IsAccountStoreDefault": (fn: Pointer): void => { 1143 A.store.Ref(fn, WEBEXT.passwordsPrivate.isAccountStoreDefault); 1144 }, 1145 "call_IsAccountStoreDefault": (retPtr: Pointer): void => { 1146 const _ret = WEBEXT.passwordsPrivate.isAccountStoreDefault(); 1147 A.store.Ref(retPtr, _ret); 1148 }, 1149 "try_IsAccountStoreDefault": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 1150 try { 1151 const _ret = WEBEXT.passwordsPrivate.isAccountStoreDefault(); 1152 A.store.Ref(retPtr, _ret); 1153 return A.H.TRUE; 1154 } catch (err: any) { 1155 A.store.Ref(errPtr, err); 1156 return A.H.FALSE; 1157 } 1158 }, 1159 "has_IsOptedInForAccountStorage": (): heap.Ref<boolean> => { 1160 if (WEBEXT?.passwordsPrivate && "isOptedInForAccountStorage" in WEBEXT?.passwordsPrivate) { 1161 return A.H.TRUE; 1162 } 1163 return A.H.FALSE; 1164 }, 1165 "func_IsOptedInForAccountStorage": (fn: Pointer): void => { 1166 A.store.Ref(fn, WEBEXT.passwordsPrivate.isOptedInForAccountStorage); 1167 }, 1168 "call_IsOptedInForAccountStorage": (retPtr: Pointer): void => { 1169 const _ret = WEBEXT.passwordsPrivate.isOptedInForAccountStorage(); 1170 A.store.Ref(retPtr, _ret); 1171 }, 1172 "try_IsOptedInForAccountStorage": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 1173 try { 1174 const _ret = WEBEXT.passwordsPrivate.isOptedInForAccountStorage(); 1175 A.store.Ref(retPtr, _ret); 1176 return A.H.TRUE; 1177 } catch (err: any) { 1178 A.store.Ref(errPtr, err); 1179 return A.H.FALSE; 1180 } 1181 }, 1182 "has_MovePasswordsToAccount": (): heap.Ref<boolean> => { 1183 if (WEBEXT?.passwordsPrivate && "movePasswordsToAccount" in WEBEXT?.passwordsPrivate) { 1184 return A.H.TRUE; 1185 } 1186 return A.H.FALSE; 1187 }, 1188 "func_MovePasswordsToAccount": (fn: Pointer): void => { 1189 A.store.Ref(fn, WEBEXT.passwordsPrivate.movePasswordsToAccount); 1190 }, 1191 "call_MovePasswordsToAccount": (retPtr: Pointer, ids: heap.Ref<object>): void => { 1192 const _ret = WEBEXT.passwordsPrivate.movePasswordsToAccount(A.H.get<object>(ids)); 1193 }, 1194 "try_MovePasswordsToAccount": (retPtr: Pointer, errPtr: Pointer, ids: heap.Ref<object>): heap.Ref<boolean> => { 1195 try { 1196 const _ret = WEBEXT.passwordsPrivate.movePasswordsToAccount(A.H.get<object>(ids)); 1197 return A.H.TRUE; 1198 } catch (err: any) { 1199 A.store.Ref(errPtr, err); 1200 return A.H.FALSE; 1201 } 1202 }, 1203 "has_MuteInsecureCredential": (): heap.Ref<boolean> => { 1204 if (WEBEXT?.passwordsPrivate && "muteInsecureCredential" in WEBEXT?.passwordsPrivate) { 1205 return A.H.TRUE; 1206 } 1207 return A.H.FALSE; 1208 }, 1209 "func_MuteInsecureCredential": (fn: Pointer): void => { 1210 A.store.Ref(fn, WEBEXT.passwordsPrivate.muteInsecureCredential); 1211 }, 1212 "call_MuteInsecureCredential": (retPtr: Pointer, credential: Pointer): void => { 1213 const credential_ffi = {}; 1214 1215 credential_ffi["affiliatedDomains"] = A.load.Ref(credential + 0, undefined); 1216 credential_ffi["username"] = A.load.Ref(credential + 4, undefined); 1217 credential_ffi["displayName"] = A.load.Ref(credential + 8, undefined); 1218 credential_ffi["password"] = A.load.Ref(credential + 12, undefined); 1219 credential_ffi["federationText"] = A.load.Ref(credential + 16, undefined); 1220 if (A.load.Bool(credential + 60)) { 1221 credential_ffi["id"] = A.load.Int32(credential + 20); 1222 } 1223 credential_ffi["storedIn"] = A.load.Enum(credential + 24, ["DEVICE", "ACCOUNT", "DEVICE_AND_ACCOUNT"]); 1224 if (A.load.Bool(credential + 61)) { 1225 credential_ffi["isPasskey"] = A.load.Bool(credential + 28); 1226 } 1227 credential_ffi["note"] = A.load.Ref(credential + 32, undefined); 1228 credential_ffi["changePasswordUrl"] = A.load.Ref(credential + 36, undefined); 1229 if (A.load.Bool(credential + 40 + 19)) { 1230 credential_ffi["compromisedInfo"] = {}; 1231 if (A.load.Bool(credential + 40 + 17)) { 1232 credential_ffi["compromisedInfo"]["compromiseTime"] = A.load.Float64(credential + 40 + 0); 1233 } 1234 credential_ffi["compromisedInfo"]["elapsedTimeSinceCompromise"] = A.load.Ref(credential + 40 + 8, undefined); 1235 credential_ffi["compromisedInfo"]["compromiseTypes"] = A.load.Ref(credential + 40 + 12, undefined); 1236 if (A.load.Bool(credential + 40 + 18)) { 1237 credential_ffi["compromisedInfo"]["isMuted"] = A.load.Bool(credential + 40 + 16); 1238 } 1239 } 1240 1241 const _ret = WEBEXT.passwordsPrivate.muteInsecureCredential(credential_ffi); 1242 A.store.Ref(retPtr, _ret); 1243 }, 1244 "try_MuteInsecureCredential": (retPtr: Pointer, errPtr: Pointer, credential: Pointer): heap.Ref<boolean> => { 1245 try { 1246 const credential_ffi = {}; 1247 1248 credential_ffi["affiliatedDomains"] = A.load.Ref(credential + 0, undefined); 1249 credential_ffi["username"] = A.load.Ref(credential + 4, undefined); 1250 credential_ffi["displayName"] = A.load.Ref(credential + 8, undefined); 1251 credential_ffi["password"] = A.load.Ref(credential + 12, undefined); 1252 credential_ffi["federationText"] = A.load.Ref(credential + 16, undefined); 1253 if (A.load.Bool(credential + 60)) { 1254 credential_ffi["id"] = A.load.Int32(credential + 20); 1255 } 1256 credential_ffi["storedIn"] = A.load.Enum(credential + 24, ["DEVICE", "ACCOUNT", "DEVICE_AND_ACCOUNT"]); 1257 if (A.load.Bool(credential + 61)) { 1258 credential_ffi["isPasskey"] = A.load.Bool(credential + 28); 1259 } 1260 credential_ffi["note"] = A.load.Ref(credential + 32, undefined); 1261 credential_ffi["changePasswordUrl"] = A.load.Ref(credential + 36, undefined); 1262 if (A.load.Bool(credential + 40 + 19)) { 1263 credential_ffi["compromisedInfo"] = {}; 1264 if (A.load.Bool(credential + 40 + 17)) { 1265 credential_ffi["compromisedInfo"]["compromiseTime"] = A.load.Float64(credential + 40 + 0); 1266 } 1267 credential_ffi["compromisedInfo"]["elapsedTimeSinceCompromise"] = A.load.Ref(credential + 40 + 8, undefined); 1268 credential_ffi["compromisedInfo"]["compromiseTypes"] = A.load.Ref(credential + 40 + 12, undefined); 1269 if (A.load.Bool(credential + 40 + 18)) { 1270 credential_ffi["compromisedInfo"]["isMuted"] = A.load.Bool(credential + 40 + 16); 1271 } 1272 } 1273 1274 const _ret = WEBEXT.passwordsPrivate.muteInsecureCredential(credential_ffi); 1275 A.store.Ref(retPtr, _ret); 1276 return A.H.TRUE; 1277 } catch (err: any) { 1278 A.store.Ref(errPtr, err); 1279 return A.H.FALSE; 1280 } 1281 }, 1282 "has_OnAccountStorageOptInStateChanged": (): heap.Ref<boolean> => { 1283 if ( 1284 WEBEXT?.passwordsPrivate?.onAccountStorageOptInStateChanged && 1285 "addListener" in WEBEXT?.passwordsPrivate?.onAccountStorageOptInStateChanged 1286 ) { 1287 return A.H.TRUE; 1288 } 1289 return A.H.FALSE; 1290 }, 1291 "func_OnAccountStorageOptInStateChanged": (fn: Pointer): void => { 1292 A.store.Ref(fn, WEBEXT.passwordsPrivate.onAccountStorageOptInStateChanged.addListener); 1293 }, 1294 "call_OnAccountStorageOptInStateChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1295 const _ret = WEBEXT.passwordsPrivate.onAccountStorageOptInStateChanged.addListener(A.H.get<object>(callback)); 1296 }, 1297 "try_OnAccountStorageOptInStateChanged": ( 1298 retPtr: Pointer, 1299 errPtr: Pointer, 1300 callback: heap.Ref<object> 1301 ): heap.Ref<boolean> => { 1302 try { 1303 const _ret = WEBEXT.passwordsPrivate.onAccountStorageOptInStateChanged.addListener(A.H.get<object>(callback)); 1304 return A.H.TRUE; 1305 } catch (err: any) { 1306 A.store.Ref(errPtr, err); 1307 return A.H.FALSE; 1308 } 1309 }, 1310 "has_OffAccountStorageOptInStateChanged": (): heap.Ref<boolean> => { 1311 if ( 1312 WEBEXT?.passwordsPrivate?.onAccountStorageOptInStateChanged && 1313 "removeListener" in WEBEXT?.passwordsPrivate?.onAccountStorageOptInStateChanged 1314 ) { 1315 return A.H.TRUE; 1316 } 1317 return A.H.FALSE; 1318 }, 1319 "func_OffAccountStorageOptInStateChanged": (fn: Pointer): void => { 1320 A.store.Ref(fn, WEBEXT.passwordsPrivate.onAccountStorageOptInStateChanged.removeListener); 1321 }, 1322 "call_OffAccountStorageOptInStateChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1323 const _ret = WEBEXT.passwordsPrivate.onAccountStorageOptInStateChanged.removeListener(A.H.get<object>(callback)); 1324 }, 1325 "try_OffAccountStorageOptInStateChanged": ( 1326 retPtr: Pointer, 1327 errPtr: Pointer, 1328 callback: heap.Ref<object> 1329 ): heap.Ref<boolean> => { 1330 try { 1331 const _ret = WEBEXT.passwordsPrivate.onAccountStorageOptInStateChanged.removeListener( 1332 A.H.get<object>(callback) 1333 ); 1334 return A.H.TRUE; 1335 } catch (err: any) { 1336 A.store.Ref(errPtr, err); 1337 return A.H.FALSE; 1338 } 1339 }, 1340 "has_HasOnAccountStorageOptInStateChanged": (): heap.Ref<boolean> => { 1341 if ( 1342 WEBEXT?.passwordsPrivate?.onAccountStorageOptInStateChanged && 1343 "hasListener" in WEBEXT?.passwordsPrivate?.onAccountStorageOptInStateChanged 1344 ) { 1345 return A.H.TRUE; 1346 } 1347 return A.H.FALSE; 1348 }, 1349 "func_HasOnAccountStorageOptInStateChanged": (fn: Pointer): void => { 1350 A.store.Ref(fn, WEBEXT.passwordsPrivate.onAccountStorageOptInStateChanged.hasListener); 1351 }, 1352 "call_HasOnAccountStorageOptInStateChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1353 const _ret = WEBEXT.passwordsPrivate.onAccountStorageOptInStateChanged.hasListener(A.H.get<object>(callback)); 1354 A.store.Bool(retPtr, _ret); 1355 }, 1356 "try_HasOnAccountStorageOptInStateChanged": ( 1357 retPtr: Pointer, 1358 errPtr: Pointer, 1359 callback: heap.Ref<object> 1360 ): heap.Ref<boolean> => { 1361 try { 1362 const _ret = WEBEXT.passwordsPrivate.onAccountStorageOptInStateChanged.hasListener(A.H.get<object>(callback)); 1363 A.store.Bool(retPtr, _ret); 1364 return A.H.TRUE; 1365 } catch (err: any) { 1366 A.store.Ref(errPtr, err); 1367 return A.H.FALSE; 1368 } 1369 }, 1370 "has_OnInsecureCredentialsChanged": (): heap.Ref<boolean> => { 1371 if ( 1372 WEBEXT?.passwordsPrivate?.onInsecureCredentialsChanged && 1373 "addListener" in WEBEXT?.passwordsPrivate?.onInsecureCredentialsChanged 1374 ) { 1375 return A.H.TRUE; 1376 } 1377 return A.H.FALSE; 1378 }, 1379 "func_OnInsecureCredentialsChanged": (fn: Pointer): void => { 1380 A.store.Ref(fn, WEBEXT.passwordsPrivate.onInsecureCredentialsChanged.addListener); 1381 }, 1382 "call_OnInsecureCredentialsChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1383 const _ret = WEBEXT.passwordsPrivate.onInsecureCredentialsChanged.addListener(A.H.get<object>(callback)); 1384 }, 1385 "try_OnInsecureCredentialsChanged": ( 1386 retPtr: Pointer, 1387 errPtr: Pointer, 1388 callback: heap.Ref<object> 1389 ): heap.Ref<boolean> => { 1390 try { 1391 const _ret = WEBEXT.passwordsPrivate.onInsecureCredentialsChanged.addListener(A.H.get<object>(callback)); 1392 return A.H.TRUE; 1393 } catch (err: any) { 1394 A.store.Ref(errPtr, err); 1395 return A.H.FALSE; 1396 } 1397 }, 1398 "has_OffInsecureCredentialsChanged": (): heap.Ref<boolean> => { 1399 if ( 1400 WEBEXT?.passwordsPrivate?.onInsecureCredentialsChanged && 1401 "removeListener" in WEBEXT?.passwordsPrivate?.onInsecureCredentialsChanged 1402 ) { 1403 return A.H.TRUE; 1404 } 1405 return A.H.FALSE; 1406 }, 1407 "func_OffInsecureCredentialsChanged": (fn: Pointer): void => { 1408 A.store.Ref(fn, WEBEXT.passwordsPrivate.onInsecureCredentialsChanged.removeListener); 1409 }, 1410 "call_OffInsecureCredentialsChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1411 const _ret = WEBEXT.passwordsPrivate.onInsecureCredentialsChanged.removeListener(A.H.get<object>(callback)); 1412 }, 1413 "try_OffInsecureCredentialsChanged": ( 1414 retPtr: Pointer, 1415 errPtr: Pointer, 1416 callback: heap.Ref<object> 1417 ): heap.Ref<boolean> => { 1418 try { 1419 const _ret = WEBEXT.passwordsPrivate.onInsecureCredentialsChanged.removeListener(A.H.get<object>(callback)); 1420 return A.H.TRUE; 1421 } catch (err: any) { 1422 A.store.Ref(errPtr, err); 1423 return A.H.FALSE; 1424 } 1425 }, 1426 "has_HasOnInsecureCredentialsChanged": (): heap.Ref<boolean> => { 1427 if ( 1428 WEBEXT?.passwordsPrivate?.onInsecureCredentialsChanged && 1429 "hasListener" in WEBEXT?.passwordsPrivate?.onInsecureCredentialsChanged 1430 ) { 1431 return A.H.TRUE; 1432 } 1433 return A.H.FALSE; 1434 }, 1435 "func_HasOnInsecureCredentialsChanged": (fn: Pointer): void => { 1436 A.store.Ref(fn, WEBEXT.passwordsPrivate.onInsecureCredentialsChanged.hasListener); 1437 }, 1438 "call_HasOnInsecureCredentialsChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1439 const _ret = WEBEXT.passwordsPrivate.onInsecureCredentialsChanged.hasListener(A.H.get<object>(callback)); 1440 A.store.Bool(retPtr, _ret); 1441 }, 1442 "try_HasOnInsecureCredentialsChanged": ( 1443 retPtr: Pointer, 1444 errPtr: Pointer, 1445 callback: heap.Ref<object> 1446 ): heap.Ref<boolean> => { 1447 try { 1448 const _ret = WEBEXT.passwordsPrivate.onInsecureCredentialsChanged.hasListener(A.H.get<object>(callback)); 1449 A.store.Bool(retPtr, _ret); 1450 return A.H.TRUE; 1451 } catch (err: any) { 1452 A.store.Ref(errPtr, err); 1453 return A.H.FALSE; 1454 } 1455 }, 1456 "has_OnPasswordCheckStatusChanged": (): heap.Ref<boolean> => { 1457 if ( 1458 WEBEXT?.passwordsPrivate?.onPasswordCheckStatusChanged && 1459 "addListener" in WEBEXT?.passwordsPrivate?.onPasswordCheckStatusChanged 1460 ) { 1461 return A.H.TRUE; 1462 } 1463 return A.H.FALSE; 1464 }, 1465 "func_OnPasswordCheckStatusChanged": (fn: Pointer): void => { 1466 A.store.Ref(fn, WEBEXT.passwordsPrivate.onPasswordCheckStatusChanged.addListener); 1467 }, 1468 "call_OnPasswordCheckStatusChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1469 const _ret = WEBEXT.passwordsPrivate.onPasswordCheckStatusChanged.addListener(A.H.get<object>(callback)); 1470 }, 1471 "try_OnPasswordCheckStatusChanged": ( 1472 retPtr: Pointer, 1473 errPtr: Pointer, 1474 callback: heap.Ref<object> 1475 ): heap.Ref<boolean> => { 1476 try { 1477 const _ret = WEBEXT.passwordsPrivate.onPasswordCheckStatusChanged.addListener(A.H.get<object>(callback)); 1478 return A.H.TRUE; 1479 } catch (err: any) { 1480 A.store.Ref(errPtr, err); 1481 return A.H.FALSE; 1482 } 1483 }, 1484 "has_OffPasswordCheckStatusChanged": (): heap.Ref<boolean> => { 1485 if ( 1486 WEBEXT?.passwordsPrivate?.onPasswordCheckStatusChanged && 1487 "removeListener" in WEBEXT?.passwordsPrivate?.onPasswordCheckStatusChanged 1488 ) { 1489 return A.H.TRUE; 1490 } 1491 return A.H.FALSE; 1492 }, 1493 "func_OffPasswordCheckStatusChanged": (fn: Pointer): void => { 1494 A.store.Ref(fn, WEBEXT.passwordsPrivate.onPasswordCheckStatusChanged.removeListener); 1495 }, 1496 "call_OffPasswordCheckStatusChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1497 const _ret = WEBEXT.passwordsPrivate.onPasswordCheckStatusChanged.removeListener(A.H.get<object>(callback)); 1498 }, 1499 "try_OffPasswordCheckStatusChanged": ( 1500 retPtr: Pointer, 1501 errPtr: Pointer, 1502 callback: heap.Ref<object> 1503 ): heap.Ref<boolean> => { 1504 try { 1505 const _ret = WEBEXT.passwordsPrivate.onPasswordCheckStatusChanged.removeListener(A.H.get<object>(callback)); 1506 return A.H.TRUE; 1507 } catch (err: any) { 1508 A.store.Ref(errPtr, err); 1509 return A.H.FALSE; 1510 } 1511 }, 1512 "has_HasOnPasswordCheckStatusChanged": (): heap.Ref<boolean> => { 1513 if ( 1514 WEBEXT?.passwordsPrivate?.onPasswordCheckStatusChanged && 1515 "hasListener" in WEBEXT?.passwordsPrivate?.onPasswordCheckStatusChanged 1516 ) { 1517 return A.H.TRUE; 1518 } 1519 return A.H.FALSE; 1520 }, 1521 "func_HasOnPasswordCheckStatusChanged": (fn: Pointer): void => { 1522 A.store.Ref(fn, WEBEXT.passwordsPrivate.onPasswordCheckStatusChanged.hasListener); 1523 }, 1524 "call_HasOnPasswordCheckStatusChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1525 const _ret = WEBEXT.passwordsPrivate.onPasswordCheckStatusChanged.hasListener(A.H.get<object>(callback)); 1526 A.store.Bool(retPtr, _ret); 1527 }, 1528 "try_HasOnPasswordCheckStatusChanged": ( 1529 retPtr: Pointer, 1530 errPtr: Pointer, 1531 callback: heap.Ref<object> 1532 ): heap.Ref<boolean> => { 1533 try { 1534 const _ret = WEBEXT.passwordsPrivate.onPasswordCheckStatusChanged.hasListener(A.H.get<object>(callback)); 1535 A.store.Bool(retPtr, _ret); 1536 return A.H.TRUE; 1537 } catch (err: any) { 1538 A.store.Ref(errPtr, err); 1539 return A.H.FALSE; 1540 } 1541 }, 1542 "has_OnPasswordExceptionsListChanged": (): heap.Ref<boolean> => { 1543 if ( 1544 WEBEXT?.passwordsPrivate?.onPasswordExceptionsListChanged && 1545 "addListener" in WEBEXT?.passwordsPrivate?.onPasswordExceptionsListChanged 1546 ) { 1547 return A.H.TRUE; 1548 } 1549 return A.H.FALSE; 1550 }, 1551 "func_OnPasswordExceptionsListChanged": (fn: Pointer): void => { 1552 A.store.Ref(fn, WEBEXT.passwordsPrivate.onPasswordExceptionsListChanged.addListener); 1553 }, 1554 "call_OnPasswordExceptionsListChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1555 const _ret = WEBEXT.passwordsPrivate.onPasswordExceptionsListChanged.addListener(A.H.get<object>(callback)); 1556 }, 1557 "try_OnPasswordExceptionsListChanged": ( 1558 retPtr: Pointer, 1559 errPtr: Pointer, 1560 callback: heap.Ref<object> 1561 ): heap.Ref<boolean> => { 1562 try { 1563 const _ret = WEBEXT.passwordsPrivate.onPasswordExceptionsListChanged.addListener(A.H.get<object>(callback)); 1564 return A.H.TRUE; 1565 } catch (err: any) { 1566 A.store.Ref(errPtr, err); 1567 return A.H.FALSE; 1568 } 1569 }, 1570 "has_OffPasswordExceptionsListChanged": (): heap.Ref<boolean> => { 1571 if ( 1572 WEBEXT?.passwordsPrivate?.onPasswordExceptionsListChanged && 1573 "removeListener" in WEBEXT?.passwordsPrivate?.onPasswordExceptionsListChanged 1574 ) { 1575 return A.H.TRUE; 1576 } 1577 return A.H.FALSE; 1578 }, 1579 "func_OffPasswordExceptionsListChanged": (fn: Pointer): void => { 1580 A.store.Ref(fn, WEBEXT.passwordsPrivate.onPasswordExceptionsListChanged.removeListener); 1581 }, 1582 "call_OffPasswordExceptionsListChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1583 const _ret = WEBEXT.passwordsPrivate.onPasswordExceptionsListChanged.removeListener(A.H.get<object>(callback)); 1584 }, 1585 "try_OffPasswordExceptionsListChanged": ( 1586 retPtr: Pointer, 1587 errPtr: Pointer, 1588 callback: heap.Ref<object> 1589 ): heap.Ref<boolean> => { 1590 try { 1591 const _ret = WEBEXT.passwordsPrivate.onPasswordExceptionsListChanged.removeListener(A.H.get<object>(callback)); 1592 return A.H.TRUE; 1593 } catch (err: any) { 1594 A.store.Ref(errPtr, err); 1595 return A.H.FALSE; 1596 } 1597 }, 1598 "has_HasOnPasswordExceptionsListChanged": (): heap.Ref<boolean> => { 1599 if ( 1600 WEBEXT?.passwordsPrivate?.onPasswordExceptionsListChanged && 1601 "hasListener" in WEBEXT?.passwordsPrivate?.onPasswordExceptionsListChanged 1602 ) { 1603 return A.H.TRUE; 1604 } 1605 return A.H.FALSE; 1606 }, 1607 "func_HasOnPasswordExceptionsListChanged": (fn: Pointer): void => { 1608 A.store.Ref(fn, WEBEXT.passwordsPrivate.onPasswordExceptionsListChanged.hasListener); 1609 }, 1610 "call_HasOnPasswordExceptionsListChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1611 const _ret = WEBEXT.passwordsPrivate.onPasswordExceptionsListChanged.hasListener(A.H.get<object>(callback)); 1612 A.store.Bool(retPtr, _ret); 1613 }, 1614 "try_HasOnPasswordExceptionsListChanged": ( 1615 retPtr: Pointer, 1616 errPtr: Pointer, 1617 callback: heap.Ref<object> 1618 ): heap.Ref<boolean> => { 1619 try { 1620 const _ret = WEBEXT.passwordsPrivate.onPasswordExceptionsListChanged.hasListener(A.H.get<object>(callback)); 1621 A.store.Bool(retPtr, _ret); 1622 return A.H.TRUE; 1623 } catch (err: any) { 1624 A.store.Ref(errPtr, err); 1625 return A.H.FALSE; 1626 } 1627 }, 1628 "has_OnPasswordManagerAuthTimeout": (): heap.Ref<boolean> => { 1629 if ( 1630 WEBEXT?.passwordsPrivate?.onPasswordManagerAuthTimeout && 1631 "addListener" in WEBEXT?.passwordsPrivate?.onPasswordManagerAuthTimeout 1632 ) { 1633 return A.H.TRUE; 1634 } 1635 return A.H.FALSE; 1636 }, 1637 "func_OnPasswordManagerAuthTimeout": (fn: Pointer): void => { 1638 A.store.Ref(fn, WEBEXT.passwordsPrivate.onPasswordManagerAuthTimeout.addListener); 1639 }, 1640 "call_OnPasswordManagerAuthTimeout": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1641 const _ret = WEBEXT.passwordsPrivate.onPasswordManagerAuthTimeout.addListener(A.H.get<object>(callback)); 1642 }, 1643 "try_OnPasswordManagerAuthTimeout": ( 1644 retPtr: Pointer, 1645 errPtr: Pointer, 1646 callback: heap.Ref<object> 1647 ): heap.Ref<boolean> => { 1648 try { 1649 const _ret = WEBEXT.passwordsPrivate.onPasswordManagerAuthTimeout.addListener(A.H.get<object>(callback)); 1650 return A.H.TRUE; 1651 } catch (err: any) { 1652 A.store.Ref(errPtr, err); 1653 return A.H.FALSE; 1654 } 1655 }, 1656 "has_OffPasswordManagerAuthTimeout": (): heap.Ref<boolean> => { 1657 if ( 1658 WEBEXT?.passwordsPrivate?.onPasswordManagerAuthTimeout && 1659 "removeListener" in WEBEXT?.passwordsPrivate?.onPasswordManagerAuthTimeout 1660 ) { 1661 return A.H.TRUE; 1662 } 1663 return A.H.FALSE; 1664 }, 1665 "func_OffPasswordManagerAuthTimeout": (fn: Pointer): void => { 1666 A.store.Ref(fn, WEBEXT.passwordsPrivate.onPasswordManagerAuthTimeout.removeListener); 1667 }, 1668 "call_OffPasswordManagerAuthTimeout": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1669 const _ret = WEBEXT.passwordsPrivate.onPasswordManagerAuthTimeout.removeListener(A.H.get<object>(callback)); 1670 }, 1671 "try_OffPasswordManagerAuthTimeout": ( 1672 retPtr: Pointer, 1673 errPtr: Pointer, 1674 callback: heap.Ref<object> 1675 ): heap.Ref<boolean> => { 1676 try { 1677 const _ret = WEBEXT.passwordsPrivate.onPasswordManagerAuthTimeout.removeListener(A.H.get<object>(callback)); 1678 return A.H.TRUE; 1679 } catch (err: any) { 1680 A.store.Ref(errPtr, err); 1681 return A.H.FALSE; 1682 } 1683 }, 1684 "has_HasOnPasswordManagerAuthTimeout": (): heap.Ref<boolean> => { 1685 if ( 1686 WEBEXT?.passwordsPrivate?.onPasswordManagerAuthTimeout && 1687 "hasListener" in WEBEXT?.passwordsPrivate?.onPasswordManagerAuthTimeout 1688 ) { 1689 return A.H.TRUE; 1690 } 1691 return A.H.FALSE; 1692 }, 1693 "func_HasOnPasswordManagerAuthTimeout": (fn: Pointer): void => { 1694 A.store.Ref(fn, WEBEXT.passwordsPrivate.onPasswordManagerAuthTimeout.hasListener); 1695 }, 1696 "call_HasOnPasswordManagerAuthTimeout": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1697 const _ret = WEBEXT.passwordsPrivate.onPasswordManagerAuthTimeout.hasListener(A.H.get<object>(callback)); 1698 A.store.Bool(retPtr, _ret); 1699 }, 1700 "try_HasOnPasswordManagerAuthTimeout": ( 1701 retPtr: Pointer, 1702 errPtr: Pointer, 1703 callback: heap.Ref<object> 1704 ): heap.Ref<boolean> => { 1705 try { 1706 const _ret = WEBEXT.passwordsPrivate.onPasswordManagerAuthTimeout.hasListener(A.H.get<object>(callback)); 1707 A.store.Bool(retPtr, _ret); 1708 return A.H.TRUE; 1709 } catch (err: any) { 1710 A.store.Ref(errPtr, err); 1711 return A.H.FALSE; 1712 } 1713 }, 1714 "has_OnPasswordsFileExportProgress": (): heap.Ref<boolean> => { 1715 if ( 1716 WEBEXT?.passwordsPrivate?.onPasswordsFileExportProgress && 1717 "addListener" in WEBEXT?.passwordsPrivate?.onPasswordsFileExportProgress 1718 ) { 1719 return A.H.TRUE; 1720 } 1721 return A.H.FALSE; 1722 }, 1723 "func_OnPasswordsFileExportProgress": (fn: Pointer): void => { 1724 A.store.Ref(fn, WEBEXT.passwordsPrivate.onPasswordsFileExportProgress.addListener); 1725 }, 1726 "call_OnPasswordsFileExportProgress": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1727 const _ret = WEBEXT.passwordsPrivate.onPasswordsFileExportProgress.addListener(A.H.get<object>(callback)); 1728 }, 1729 "try_OnPasswordsFileExportProgress": ( 1730 retPtr: Pointer, 1731 errPtr: Pointer, 1732 callback: heap.Ref<object> 1733 ): heap.Ref<boolean> => { 1734 try { 1735 const _ret = WEBEXT.passwordsPrivate.onPasswordsFileExportProgress.addListener(A.H.get<object>(callback)); 1736 return A.H.TRUE; 1737 } catch (err: any) { 1738 A.store.Ref(errPtr, err); 1739 return A.H.FALSE; 1740 } 1741 }, 1742 "has_OffPasswordsFileExportProgress": (): heap.Ref<boolean> => { 1743 if ( 1744 WEBEXT?.passwordsPrivate?.onPasswordsFileExportProgress && 1745 "removeListener" in WEBEXT?.passwordsPrivate?.onPasswordsFileExportProgress 1746 ) { 1747 return A.H.TRUE; 1748 } 1749 return A.H.FALSE; 1750 }, 1751 "func_OffPasswordsFileExportProgress": (fn: Pointer): void => { 1752 A.store.Ref(fn, WEBEXT.passwordsPrivate.onPasswordsFileExportProgress.removeListener); 1753 }, 1754 "call_OffPasswordsFileExportProgress": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1755 const _ret = WEBEXT.passwordsPrivate.onPasswordsFileExportProgress.removeListener(A.H.get<object>(callback)); 1756 }, 1757 "try_OffPasswordsFileExportProgress": ( 1758 retPtr: Pointer, 1759 errPtr: Pointer, 1760 callback: heap.Ref<object> 1761 ): heap.Ref<boolean> => { 1762 try { 1763 const _ret = WEBEXT.passwordsPrivate.onPasswordsFileExportProgress.removeListener(A.H.get<object>(callback)); 1764 return A.H.TRUE; 1765 } catch (err: any) { 1766 A.store.Ref(errPtr, err); 1767 return A.H.FALSE; 1768 } 1769 }, 1770 "has_HasOnPasswordsFileExportProgress": (): heap.Ref<boolean> => { 1771 if ( 1772 WEBEXT?.passwordsPrivate?.onPasswordsFileExportProgress && 1773 "hasListener" in WEBEXT?.passwordsPrivate?.onPasswordsFileExportProgress 1774 ) { 1775 return A.H.TRUE; 1776 } 1777 return A.H.FALSE; 1778 }, 1779 "func_HasOnPasswordsFileExportProgress": (fn: Pointer): void => { 1780 A.store.Ref(fn, WEBEXT.passwordsPrivate.onPasswordsFileExportProgress.hasListener); 1781 }, 1782 "call_HasOnPasswordsFileExportProgress": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1783 const _ret = WEBEXT.passwordsPrivate.onPasswordsFileExportProgress.hasListener(A.H.get<object>(callback)); 1784 A.store.Bool(retPtr, _ret); 1785 }, 1786 "try_HasOnPasswordsFileExportProgress": ( 1787 retPtr: Pointer, 1788 errPtr: Pointer, 1789 callback: heap.Ref<object> 1790 ): heap.Ref<boolean> => { 1791 try { 1792 const _ret = WEBEXT.passwordsPrivate.onPasswordsFileExportProgress.hasListener(A.H.get<object>(callback)); 1793 A.store.Bool(retPtr, _ret); 1794 return A.H.TRUE; 1795 } catch (err: any) { 1796 A.store.Ref(errPtr, err); 1797 return A.H.FALSE; 1798 } 1799 }, 1800 "has_OnSavedPasswordsListChanged": (): heap.Ref<boolean> => { 1801 if ( 1802 WEBEXT?.passwordsPrivate?.onSavedPasswordsListChanged && 1803 "addListener" in WEBEXT?.passwordsPrivate?.onSavedPasswordsListChanged 1804 ) { 1805 return A.H.TRUE; 1806 } 1807 return A.H.FALSE; 1808 }, 1809 "func_OnSavedPasswordsListChanged": (fn: Pointer): void => { 1810 A.store.Ref(fn, WEBEXT.passwordsPrivate.onSavedPasswordsListChanged.addListener); 1811 }, 1812 "call_OnSavedPasswordsListChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1813 const _ret = WEBEXT.passwordsPrivate.onSavedPasswordsListChanged.addListener(A.H.get<object>(callback)); 1814 }, 1815 "try_OnSavedPasswordsListChanged": ( 1816 retPtr: Pointer, 1817 errPtr: Pointer, 1818 callback: heap.Ref<object> 1819 ): heap.Ref<boolean> => { 1820 try { 1821 const _ret = WEBEXT.passwordsPrivate.onSavedPasswordsListChanged.addListener(A.H.get<object>(callback)); 1822 return A.H.TRUE; 1823 } catch (err: any) { 1824 A.store.Ref(errPtr, err); 1825 return A.H.FALSE; 1826 } 1827 }, 1828 "has_OffSavedPasswordsListChanged": (): heap.Ref<boolean> => { 1829 if ( 1830 WEBEXT?.passwordsPrivate?.onSavedPasswordsListChanged && 1831 "removeListener" in WEBEXT?.passwordsPrivate?.onSavedPasswordsListChanged 1832 ) { 1833 return A.H.TRUE; 1834 } 1835 return A.H.FALSE; 1836 }, 1837 "func_OffSavedPasswordsListChanged": (fn: Pointer): void => { 1838 A.store.Ref(fn, WEBEXT.passwordsPrivate.onSavedPasswordsListChanged.removeListener); 1839 }, 1840 "call_OffSavedPasswordsListChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1841 const _ret = WEBEXT.passwordsPrivate.onSavedPasswordsListChanged.removeListener(A.H.get<object>(callback)); 1842 }, 1843 "try_OffSavedPasswordsListChanged": ( 1844 retPtr: Pointer, 1845 errPtr: Pointer, 1846 callback: heap.Ref<object> 1847 ): heap.Ref<boolean> => { 1848 try { 1849 const _ret = WEBEXT.passwordsPrivate.onSavedPasswordsListChanged.removeListener(A.H.get<object>(callback)); 1850 return A.H.TRUE; 1851 } catch (err: any) { 1852 A.store.Ref(errPtr, err); 1853 return A.H.FALSE; 1854 } 1855 }, 1856 "has_HasOnSavedPasswordsListChanged": (): heap.Ref<boolean> => { 1857 if ( 1858 WEBEXT?.passwordsPrivate?.onSavedPasswordsListChanged && 1859 "hasListener" in WEBEXT?.passwordsPrivate?.onSavedPasswordsListChanged 1860 ) { 1861 return A.H.TRUE; 1862 } 1863 return A.H.FALSE; 1864 }, 1865 "func_HasOnSavedPasswordsListChanged": (fn: Pointer): void => { 1866 A.store.Ref(fn, WEBEXT.passwordsPrivate.onSavedPasswordsListChanged.hasListener); 1867 }, 1868 "call_HasOnSavedPasswordsListChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1869 const _ret = WEBEXT.passwordsPrivate.onSavedPasswordsListChanged.hasListener(A.H.get<object>(callback)); 1870 A.store.Bool(retPtr, _ret); 1871 }, 1872 "try_HasOnSavedPasswordsListChanged": ( 1873 retPtr: Pointer, 1874 errPtr: Pointer, 1875 callback: heap.Ref<object> 1876 ): heap.Ref<boolean> => { 1877 try { 1878 const _ret = WEBEXT.passwordsPrivate.onSavedPasswordsListChanged.hasListener(A.H.get<object>(callback)); 1879 A.store.Bool(retPtr, _ret); 1880 return A.H.TRUE; 1881 } catch (err: any) { 1882 A.store.Ref(errPtr, err); 1883 return A.H.FALSE; 1884 } 1885 }, 1886 "has_OptInForAccountStorage": (): heap.Ref<boolean> => { 1887 if (WEBEXT?.passwordsPrivate && "optInForAccountStorage" in WEBEXT?.passwordsPrivate) { 1888 return A.H.TRUE; 1889 } 1890 return A.H.FALSE; 1891 }, 1892 "func_OptInForAccountStorage": (fn: Pointer): void => { 1893 A.store.Ref(fn, WEBEXT.passwordsPrivate.optInForAccountStorage); 1894 }, 1895 "call_OptInForAccountStorage": (retPtr: Pointer, optIn: heap.Ref<boolean>): void => { 1896 const _ret = WEBEXT.passwordsPrivate.optInForAccountStorage(optIn === A.H.TRUE); 1897 }, 1898 "try_OptInForAccountStorage": (retPtr: Pointer, errPtr: Pointer, optIn: heap.Ref<boolean>): heap.Ref<boolean> => { 1899 try { 1900 const _ret = WEBEXT.passwordsPrivate.optInForAccountStorage(optIn === A.H.TRUE); 1901 return A.H.TRUE; 1902 } catch (err: any) { 1903 A.store.Ref(errPtr, err); 1904 return A.H.FALSE; 1905 } 1906 }, 1907 "has_RecordPasswordsPageAccessInSettings": (): heap.Ref<boolean> => { 1908 if (WEBEXT?.passwordsPrivate && "recordPasswordsPageAccessInSettings" in WEBEXT?.passwordsPrivate) { 1909 return A.H.TRUE; 1910 } 1911 return A.H.FALSE; 1912 }, 1913 "func_RecordPasswordsPageAccessInSettings": (fn: Pointer): void => { 1914 A.store.Ref(fn, WEBEXT.passwordsPrivate.recordPasswordsPageAccessInSettings); 1915 }, 1916 "call_RecordPasswordsPageAccessInSettings": (retPtr: Pointer): void => { 1917 const _ret = WEBEXT.passwordsPrivate.recordPasswordsPageAccessInSettings(); 1918 }, 1919 "try_RecordPasswordsPageAccessInSettings": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 1920 try { 1921 const _ret = WEBEXT.passwordsPrivate.recordPasswordsPageAccessInSettings(); 1922 return A.H.TRUE; 1923 } catch (err: any) { 1924 A.store.Ref(errPtr, err); 1925 return A.H.FALSE; 1926 } 1927 }, 1928 "has_RemoveCredential": (): heap.Ref<boolean> => { 1929 if (WEBEXT?.passwordsPrivate && "removeCredential" in WEBEXT?.passwordsPrivate) { 1930 return A.H.TRUE; 1931 } 1932 return A.H.FALSE; 1933 }, 1934 "func_RemoveCredential": (fn: Pointer): void => { 1935 A.store.Ref(fn, WEBEXT.passwordsPrivate.removeCredential); 1936 }, 1937 "call_RemoveCredential": (retPtr: Pointer, id: number, fromStores: number): void => { 1938 const _ret = WEBEXT.passwordsPrivate.removeCredential( 1939 id, 1940 fromStores > 0 && fromStores <= 3 ? ["DEVICE", "ACCOUNT", "DEVICE_AND_ACCOUNT"][fromStores - 1] : undefined 1941 ); 1942 }, 1943 "try_RemoveCredential": (retPtr: Pointer, errPtr: Pointer, id: number, fromStores: number): heap.Ref<boolean> => { 1944 try { 1945 const _ret = WEBEXT.passwordsPrivate.removeCredential( 1946 id, 1947 fromStores > 0 && fromStores <= 3 ? ["DEVICE", "ACCOUNT", "DEVICE_AND_ACCOUNT"][fromStores - 1] : undefined 1948 ); 1949 return A.H.TRUE; 1950 } catch (err: any) { 1951 A.store.Ref(errPtr, err); 1952 return A.H.FALSE; 1953 } 1954 }, 1955 "has_RemovePasswordException": (): heap.Ref<boolean> => { 1956 if (WEBEXT?.passwordsPrivate && "removePasswordException" in WEBEXT?.passwordsPrivate) { 1957 return A.H.TRUE; 1958 } 1959 return A.H.FALSE; 1960 }, 1961 "func_RemovePasswordException": (fn: Pointer): void => { 1962 A.store.Ref(fn, WEBEXT.passwordsPrivate.removePasswordException); 1963 }, 1964 "call_RemovePasswordException": (retPtr: Pointer, id: number): void => { 1965 const _ret = WEBEXT.passwordsPrivate.removePasswordException(id); 1966 }, 1967 "try_RemovePasswordException": (retPtr: Pointer, errPtr: Pointer, id: number): heap.Ref<boolean> => { 1968 try { 1969 const _ret = WEBEXT.passwordsPrivate.removePasswordException(id); 1970 return A.H.TRUE; 1971 } catch (err: any) { 1972 A.store.Ref(errPtr, err); 1973 return A.H.FALSE; 1974 } 1975 }, 1976 "has_RequestCredentialsDetails": (): heap.Ref<boolean> => { 1977 if (WEBEXT?.passwordsPrivate && "requestCredentialsDetails" in WEBEXT?.passwordsPrivate) { 1978 return A.H.TRUE; 1979 } 1980 return A.H.FALSE; 1981 }, 1982 "func_RequestCredentialsDetails": (fn: Pointer): void => { 1983 A.store.Ref(fn, WEBEXT.passwordsPrivate.requestCredentialsDetails); 1984 }, 1985 "call_RequestCredentialsDetails": (retPtr: Pointer, ids: heap.Ref<object>): void => { 1986 const _ret = WEBEXT.passwordsPrivate.requestCredentialsDetails(A.H.get<object>(ids)); 1987 A.store.Ref(retPtr, _ret); 1988 }, 1989 "try_RequestCredentialsDetails": (retPtr: Pointer, errPtr: Pointer, ids: heap.Ref<object>): heap.Ref<boolean> => { 1990 try { 1991 const _ret = WEBEXT.passwordsPrivate.requestCredentialsDetails(A.H.get<object>(ids)); 1992 A.store.Ref(retPtr, _ret); 1993 return A.H.TRUE; 1994 } catch (err: any) { 1995 A.store.Ref(errPtr, err); 1996 return A.H.FALSE; 1997 } 1998 }, 1999 "has_RequestExportProgressStatus": (): heap.Ref<boolean> => { 2000 if (WEBEXT?.passwordsPrivate && "requestExportProgressStatus" in WEBEXT?.passwordsPrivate) { 2001 return A.H.TRUE; 2002 } 2003 return A.H.FALSE; 2004 }, 2005 "func_RequestExportProgressStatus": (fn: Pointer): void => { 2006 A.store.Ref(fn, WEBEXT.passwordsPrivate.requestExportProgressStatus); 2007 }, 2008 "call_RequestExportProgressStatus": (retPtr: Pointer): void => { 2009 const _ret = WEBEXT.passwordsPrivate.requestExportProgressStatus(); 2010 A.store.Ref(retPtr, _ret); 2011 }, 2012 "try_RequestExportProgressStatus": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 2013 try { 2014 const _ret = WEBEXT.passwordsPrivate.requestExportProgressStatus(); 2015 A.store.Ref(retPtr, _ret); 2016 return A.H.TRUE; 2017 } catch (err: any) { 2018 A.store.Ref(errPtr, err); 2019 return A.H.FALSE; 2020 } 2021 }, 2022 "has_RequestPlaintextPassword": (): heap.Ref<boolean> => { 2023 if (WEBEXT?.passwordsPrivate && "requestPlaintextPassword" in WEBEXT?.passwordsPrivate) { 2024 return A.H.TRUE; 2025 } 2026 return A.H.FALSE; 2027 }, 2028 "func_RequestPlaintextPassword": (fn: Pointer): void => { 2029 A.store.Ref(fn, WEBEXT.passwordsPrivate.requestPlaintextPassword); 2030 }, 2031 "call_RequestPlaintextPassword": (retPtr: Pointer, id: number, reason: number): void => { 2032 const _ret = WEBEXT.passwordsPrivate.requestPlaintextPassword( 2033 id, 2034 reason > 0 && reason <= 3 ? ["VIEW", "COPY", "EDIT"][reason - 1] : undefined 2035 ); 2036 A.store.Ref(retPtr, _ret); 2037 }, 2038 "try_RequestPlaintextPassword": ( 2039 retPtr: Pointer, 2040 errPtr: Pointer, 2041 id: number, 2042 reason: number 2043 ): heap.Ref<boolean> => { 2044 try { 2045 const _ret = WEBEXT.passwordsPrivate.requestPlaintextPassword( 2046 id, 2047 reason > 0 && reason <= 3 ? ["VIEW", "COPY", "EDIT"][reason - 1] : undefined 2048 ); 2049 A.store.Ref(retPtr, _ret); 2050 return A.H.TRUE; 2051 } catch (err: any) { 2052 A.store.Ref(errPtr, err); 2053 return A.H.FALSE; 2054 } 2055 }, 2056 "has_ResetImporter": (): heap.Ref<boolean> => { 2057 if (WEBEXT?.passwordsPrivate && "resetImporter" in WEBEXT?.passwordsPrivate) { 2058 return A.H.TRUE; 2059 } 2060 return A.H.FALSE; 2061 }, 2062 "func_ResetImporter": (fn: Pointer): void => { 2063 A.store.Ref(fn, WEBEXT.passwordsPrivate.resetImporter); 2064 }, 2065 "call_ResetImporter": (retPtr: Pointer, deleteFile: heap.Ref<boolean>): void => { 2066 const _ret = WEBEXT.passwordsPrivate.resetImporter(deleteFile === A.H.TRUE); 2067 A.store.Ref(retPtr, _ret); 2068 }, 2069 "try_ResetImporter": (retPtr: Pointer, errPtr: Pointer, deleteFile: heap.Ref<boolean>): heap.Ref<boolean> => { 2070 try { 2071 const _ret = WEBEXT.passwordsPrivate.resetImporter(deleteFile === A.H.TRUE); 2072 A.store.Ref(retPtr, _ret); 2073 return A.H.TRUE; 2074 } catch (err: any) { 2075 A.store.Ref(errPtr, err); 2076 return A.H.FALSE; 2077 } 2078 }, 2079 "has_SharePassword": (): heap.Ref<boolean> => { 2080 if (WEBEXT?.passwordsPrivate && "sharePassword" in WEBEXT?.passwordsPrivate) { 2081 return A.H.TRUE; 2082 } 2083 return A.H.FALSE; 2084 }, 2085 "func_SharePassword": (fn: Pointer): void => { 2086 A.store.Ref(fn, WEBEXT.passwordsPrivate.sharePassword); 2087 }, 2088 "call_SharePassword": (retPtr: Pointer, id: number, recipients: heap.Ref<object>): void => { 2089 const _ret = WEBEXT.passwordsPrivate.sharePassword(id, A.H.get<object>(recipients)); 2090 A.store.Ref(retPtr, _ret); 2091 }, 2092 "try_SharePassword": ( 2093 retPtr: Pointer, 2094 errPtr: Pointer, 2095 id: number, 2096 recipients: heap.Ref<object> 2097 ): heap.Ref<boolean> => { 2098 try { 2099 const _ret = WEBEXT.passwordsPrivate.sharePassword(id, A.H.get<object>(recipients)); 2100 A.store.Ref(retPtr, _ret); 2101 return A.H.TRUE; 2102 } catch (err: any) { 2103 A.store.Ref(errPtr, err); 2104 return A.H.FALSE; 2105 } 2106 }, 2107 "has_ShowAddShortcutDialog": (): heap.Ref<boolean> => { 2108 if (WEBEXT?.passwordsPrivate && "showAddShortcutDialog" in WEBEXT?.passwordsPrivate) { 2109 return A.H.TRUE; 2110 } 2111 return A.H.FALSE; 2112 }, 2113 "func_ShowAddShortcutDialog": (fn: Pointer): void => { 2114 A.store.Ref(fn, WEBEXT.passwordsPrivate.showAddShortcutDialog); 2115 }, 2116 "call_ShowAddShortcutDialog": (retPtr: Pointer): void => { 2117 const _ret = WEBEXT.passwordsPrivate.showAddShortcutDialog(); 2118 }, 2119 "try_ShowAddShortcutDialog": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 2120 try { 2121 const _ret = WEBEXT.passwordsPrivate.showAddShortcutDialog(); 2122 return A.H.TRUE; 2123 } catch (err: any) { 2124 A.store.Ref(errPtr, err); 2125 return A.H.FALSE; 2126 } 2127 }, 2128 "has_ShowExportedFileInShell": (): heap.Ref<boolean> => { 2129 if (WEBEXT?.passwordsPrivate && "showExportedFileInShell" in WEBEXT?.passwordsPrivate) { 2130 return A.H.TRUE; 2131 } 2132 return A.H.FALSE; 2133 }, 2134 "func_ShowExportedFileInShell": (fn: Pointer): void => { 2135 A.store.Ref(fn, WEBEXT.passwordsPrivate.showExportedFileInShell); 2136 }, 2137 "call_ShowExportedFileInShell": (retPtr: Pointer, file_path: heap.Ref<object>): void => { 2138 const _ret = WEBEXT.passwordsPrivate.showExportedFileInShell(A.H.get<object>(file_path)); 2139 }, 2140 "try_ShowExportedFileInShell": ( 2141 retPtr: Pointer, 2142 errPtr: Pointer, 2143 file_path: heap.Ref<object> 2144 ): heap.Ref<boolean> => { 2145 try { 2146 const _ret = WEBEXT.passwordsPrivate.showExportedFileInShell(A.H.get<object>(file_path)); 2147 return A.H.TRUE; 2148 } catch (err: any) { 2149 A.store.Ref(errPtr, err); 2150 return A.H.FALSE; 2151 } 2152 }, 2153 "has_StartPasswordCheck": (): heap.Ref<boolean> => { 2154 if (WEBEXT?.passwordsPrivate && "startPasswordCheck" in WEBEXT?.passwordsPrivate) { 2155 return A.H.TRUE; 2156 } 2157 return A.H.FALSE; 2158 }, 2159 "func_StartPasswordCheck": (fn: Pointer): void => { 2160 A.store.Ref(fn, WEBEXT.passwordsPrivate.startPasswordCheck); 2161 }, 2162 "call_StartPasswordCheck": (retPtr: Pointer): void => { 2163 const _ret = WEBEXT.passwordsPrivate.startPasswordCheck(); 2164 A.store.Ref(retPtr, _ret); 2165 }, 2166 "try_StartPasswordCheck": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 2167 try { 2168 const _ret = WEBEXT.passwordsPrivate.startPasswordCheck(); 2169 A.store.Ref(retPtr, _ret); 2170 return A.H.TRUE; 2171 } catch (err: any) { 2172 A.store.Ref(errPtr, err); 2173 return A.H.FALSE; 2174 } 2175 }, 2176 "has_SwitchBiometricAuthBeforeFillingState": (): heap.Ref<boolean> => { 2177 if (WEBEXT?.passwordsPrivate && "switchBiometricAuthBeforeFillingState" in WEBEXT?.passwordsPrivate) { 2178 return A.H.TRUE; 2179 } 2180 return A.H.FALSE; 2181 }, 2182 "func_SwitchBiometricAuthBeforeFillingState": (fn: Pointer): void => { 2183 A.store.Ref(fn, WEBEXT.passwordsPrivate.switchBiometricAuthBeforeFillingState); 2184 }, 2185 "call_SwitchBiometricAuthBeforeFillingState": (retPtr: Pointer): void => { 2186 const _ret = WEBEXT.passwordsPrivate.switchBiometricAuthBeforeFillingState(); 2187 }, 2188 "try_SwitchBiometricAuthBeforeFillingState": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 2189 try { 2190 const _ret = WEBEXT.passwordsPrivate.switchBiometricAuthBeforeFillingState(); 2191 return A.H.TRUE; 2192 } catch (err: any) { 2193 A.store.Ref(errPtr, err); 2194 return A.H.FALSE; 2195 } 2196 }, 2197 "has_UndoRemoveSavedPasswordOrException": (): heap.Ref<boolean> => { 2198 if (WEBEXT?.passwordsPrivate && "undoRemoveSavedPasswordOrException" in WEBEXT?.passwordsPrivate) { 2199 return A.H.TRUE; 2200 } 2201 return A.H.FALSE; 2202 }, 2203 "func_UndoRemoveSavedPasswordOrException": (fn: Pointer): void => { 2204 A.store.Ref(fn, WEBEXT.passwordsPrivate.undoRemoveSavedPasswordOrException); 2205 }, 2206 "call_UndoRemoveSavedPasswordOrException": (retPtr: Pointer): void => { 2207 const _ret = WEBEXT.passwordsPrivate.undoRemoveSavedPasswordOrException(); 2208 }, 2209 "try_UndoRemoveSavedPasswordOrException": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 2210 try { 2211 const _ret = WEBEXT.passwordsPrivate.undoRemoveSavedPasswordOrException(); 2212 return A.H.TRUE; 2213 } catch (err: any) { 2214 A.store.Ref(errPtr, err); 2215 return A.H.FALSE; 2216 } 2217 }, 2218 "has_UnmuteInsecureCredential": (): heap.Ref<boolean> => { 2219 if (WEBEXT?.passwordsPrivate && "unmuteInsecureCredential" in WEBEXT?.passwordsPrivate) { 2220 return A.H.TRUE; 2221 } 2222 return A.H.FALSE; 2223 }, 2224 "func_UnmuteInsecureCredential": (fn: Pointer): void => { 2225 A.store.Ref(fn, WEBEXT.passwordsPrivate.unmuteInsecureCredential); 2226 }, 2227 "call_UnmuteInsecureCredential": (retPtr: Pointer, credential: Pointer): void => { 2228 const credential_ffi = {}; 2229 2230 credential_ffi["affiliatedDomains"] = A.load.Ref(credential + 0, undefined); 2231 credential_ffi["username"] = A.load.Ref(credential + 4, undefined); 2232 credential_ffi["displayName"] = A.load.Ref(credential + 8, undefined); 2233 credential_ffi["password"] = A.load.Ref(credential + 12, undefined); 2234 credential_ffi["federationText"] = A.load.Ref(credential + 16, undefined); 2235 if (A.load.Bool(credential + 60)) { 2236 credential_ffi["id"] = A.load.Int32(credential + 20); 2237 } 2238 credential_ffi["storedIn"] = A.load.Enum(credential + 24, ["DEVICE", "ACCOUNT", "DEVICE_AND_ACCOUNT"]); 2239 if (A.load.Bool(credential + 61)) { 2240 credential_ffi["isPasskey"] = A.load.Bool(credential + 28); 2241 } 2242 credential_ffi["note"] = A.load.Ref(credential + 32, undefined); 2243 credential_ffi["changePasswordUrl"] = A.load.Ref(credential + 36, undefined); 2244 if (A.load.Bool(credential + 40 + 19)) { 2245 credential_ffi["compromisedInfo"] = {}; 2246 if (A.load.Bool(credential + 40 + 17)) { 2247 credential_ffi["compromisedInfo"]["compromiseTime"] = A.load.Float64(credential + 40 + 0); 2248 } 2249 credential_ffi["compromisedInfo"]["elapsedTimeSinceCompromise"] = A.load.Ref(credential + 40 + 8, undefined); 2250 credential_ffi["compromisedInfo"]["compromiseTypes"] = A.load.Ref(credential + 40 + 12, undefined); 2251 if (A.load.Bool(credential + 40 + 18)) { 2252 credential_ffi["compromisedInfo"]["isMuted"] = A.load.Bool(credential + 40 + 16); 2253 } 2254 } 2255 2256 const _ret = WEBEXT.passwordsPrivate.unmuteInsecureCredential(credential_ffi); 2257 A.store.Ref(retPtr, _ret); 2258 }, 2259 "try_UnmuteInsecureCredential": (retPtr: Pointer, errPtr: Pointer, credential: Pointer): heap.Ref<boolean> => { 2260 try { 2261 const credential_ffi = {}; 2262 2263 credential_ffi["affiliatedDomains"] = A.load.Ref(credential + 0, undefined); 2264 credential_ffi["username"] = A.load.Ref(credential + 4, undefined); 2265 credential_ffi["displayName"] = A.load.Ref(credential + 8, undefined); 2266 credential_ffi["password"] = A.load.Ref(credential + 12, undefined); 2267 credential_ffi["federationText"] = A.load.Ref(credential + 16, undefined); 2268 if (A.load.Bool(credential + 60)) { 2269 credential_ffi["id"] = A.load.Int32(credential + 20); 2270 } 2271 credential_ffi["storedIn"] = A.load.Enum(credential + 24, ["DEVICE", "ACCOUNT", "DEVICE_AND_ACCOUNT"]); 2272 if (A.load.Bool(credential + 61)) { 2273 credential_ffi["isPasskey"] = A.load.Bool(credential + 28); 2274 } 2275 credential_ffi["note"] = A.load.Ref(credential + 32, undefined); 2276 credential_ffi["changePasswordUrl"] = A.load.Ref(credential + 36, undefined); 2277 if (A.load.Bool(credential + 40 + 19)) { 2278 credential_ffi["compromisedInfo"] = {}; 2279 if (A.load.Bool(credential + 40 + 17)) { 2280 credential_ffi["compromisedInfo"]["compromiseTime"] = A.load.Float64(credential + 40 + 0); 2281 } 2282 credential_ffi["compromisedInfo"]["elapsedTimeSinceCompromise"] = A.load.Ref(credential + 40 + 8, undefined); 2283 credential_ffi["compromisedInfo"]["compromiseTypes"] = A.load.Ref(credential + 40 + 12, undefined); 2284 if (A.load.Bool(credential + 40 + 18)) { 2285 credential_ffi["compromisedInfo"]["isMuted"] = A.load.Bool(credential + 40 + 16); 2286 } 2287 } 2288 2289 const _ret = WEBEXT.passwordsPrivate.unmuteInsecureCredential(credential_ffi); 2290 A.store.Ref(retPtr, _ret); 2291 return A.H.TRUE; 2292 } catch (err: any) { 2293 A.store.Ref(errPtr, err); 2294 return A.H.FALSE; 2295 } 2296 }, 2297 }; 2298 });