github.com/primecitizens/pcz/std@v0.2.1/plat/js/webext/autofillprivate/bindings/ffi_bindings.ts (about) 1 import { importModule, Application, heap, Pointer } from "@ffi"; 2 3 importModule("plat/js/webext/autofillprivate", (A: Application) => { 4 const WEBEXT = typeof globalThis.browser === "undefined" ? globalThis.chrome : globalThis.browser; 5 6 return { 7 "store_AccountInfo": (ptr: Pointer, ref: heap.Ref<any>) => { 8 const x = A.H.get<any>(ref); 9 10 if (typeof x === "undefined") { 11 A.store.Bool(ptr + 8, false); 12 A.store.Ref(ptr + 0, undefined); 13 A.store.Bool(ptr + 6, false); 14 A.store.Bool(ptr + 4, false); 15 A.store.Bool(ptr + 7, false); 16 A.store.Bool(ptr + 5, false); 17 } else { 18 A.store.Bool(ptr + 8, true); 19 A.store.Ref(ptr + 0, x["email"]); 20 A.store.Bool(ptr + 6, "isSyncEnabledForAutofillProfiles" in x ? true : false); 21 A.store.Bool(ptr + 4, x["isSyncEnabledForAutofillProfiles"] ? true : false); 22 A.store.Bool(ptr + 7, "isEligibleForAddressAccountStorage" in x ? true : false); 23 A.store.Bool(ptr + 5, x["isEligibleForAddressAccountStorage"] ? true : false); 24 } 25 }, 26 "load_AccountInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 27 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 28 29 x["email"] = A.load.Ref(ptr + 0, undefined); 30 if (A.load.Bool(ptr + 6)) { 31 x["isSyncEnabledForAutofillProfiles"] = A.load.Bool(ptr + 4); 32 } else { 33 delete x["isSyncEnabledForAutofillProfiles"]; 34 } 35 if (A.load.Bool(ptr + 7)) { 36 x["isEligibleForAddressAccountStorage"] = A.load.Bool(ptr + 5); 37 } else { 38 delete x["isEligibleForAddressAccountStorage"]; 39 } 40 return create === A.H.TRUE ? A.H.push(x) : ref; 41 }, 42 "constof_ServerFieldType": (ref: heap.Ref<string>): number => { 43 const idx = [ 44 "NO_SERVER_DATA", 45 "UNKNOWN_TYPE", 46 "EMPTY_TYPE", 47 "NAME_FIRST", 48 "NAME_MIDDLE", 49 "NAME_LAST", 50 "NAME_MIDDLE_INITIAL", 51 "NAME_FULL", 52 "NAME_SUFFIX", 53 "EMAIL_ADDRESS", 54 "PHONE_HOME_NUMBER", 55 "PHONE_HOME_CITY_CODE", 56 "PHONE_HOME_COUNTRY_CODE", 57 "PHONE_HOME_CITY_AND_NUMBER", 58 "PHONE_HOME_WHOLE_NUMBER", 59 "ADDRESS_HOME_LINE1", 60 "ADDRESS_HOME_LINE2", 61 "ADDRESS_HOME_APT_NUM", 62 "ADDRESS_HOME_CITY", 63 "ADDRESS_HOME_STATE", 64 "ADDRESS_HOME_ZIP", 65 "ADDRESS_HOME_COUNTRY", 66 "CREDIT_CARD_NAME_FULL", 67 "CREDIT_CARD_NUMBER", 68 "CREDIT_CARD_EXP_MONTH", 69 "CREDIT_CARD_EXP_2_DIGIT_YEAR", 70 "CREDIT_CARD_EXP_4_DIGIT_YEAR", 71 "CREDIT_CARD_EXP_DATE_2_DIGIT_YEAR", 72 "CREDIT_CARD_EXP_DATE_4_DIGIT_YEAR", 73 "CREDIT_CARD_TYPE", 74 "CREDIT_CARD_VERIFICATION_CODE", 75 "COMPANY_NAME", 76 "FIELD_WITH_DEFAULT_VALUE", 77 "MERCHANT_EMAIL_SIGNUP", 78 "MERCHANT_PROMO_CODE", 79 "PASSWORD", 80 "ACCOUNT_CREATION_PASSWORD", 81 "ADDRESS_HOME_STREET_ADDRESS", 82 "ADDRESS_HOME_SORTING_CODE", 83 "ADDRESS_HOME_DEPENDENT_LOCALITY", 84 "ADDRESS_HOME_LINE3", 85 "NOT_ACCOUNT_CREATION_PASSWORD", 86 "USERNAME", 87 "USERNAME_AND_EMAIL_ADDRESS", 88 "NEW_PASSWORD", 89 "PROBABLY_NEW_PASSWORD", 90 "NOT_NEW_PASSWORD", 91 "CREDIT_CARD_NAME_FIRST", 92 "CREDIT_CARD_NAME_LAST", 93 "PHONE_HOME_EXTENSION", 94 "CONFIRMATION_PASSWORD", 95 "AMBIGUOUS_TYPE", 96 "SEARCH_TERM", 97 "PRICE", 98 "NOT_PASSWORD", 99 "SINGLE_USERNAME", 100 "NOT_USERNAME", 101 "UPI_VPA", 102 "ADDRESS_HOME_STREET_NAME", 103 "ADDRESS_HOME_HOUSE_NUMBER", 104 "ADDRESS_HOME_SUBPREMISE", 105 "ADDRESS_HOME_OTHER_SUBUNIT", 106 "NAME_LAST_FIRST", 107 "NAME_LAST_CONJUNCTION", 108 "NAME_LAST_SECOND", 109 "NAME_HONORIFIC_PREFIX", 110 "ADDRESS_HOME_ADDRESS", 111 "ADDRESS_HOME_ADDRESS_WITH_NAME", 112 "ADDRESS_HOME_FLOOR", 113 "NAME_FULL_WITH_HONORIFIC_PREFIX", 114 "BIRTHDATE_DAY", 115 "BIRTHDATE_MONTH", 116 "BIRTHDATE_4_DIGIT_YEAR", 117 "PHONE_HOME_CITY_CODE_WITH_TRUNK_PREFIX", 118 "PHONE_HOME_CITY_AND_NUMBER_WITHOUT_TRUNK_PREFIX", 119 "PHONE_HOME_NUMBER_PREFIX", 120 "PHONE_HOME_NUMBER_SUFFIX", 121 "IBAN_VALUE", 122 "CREDIT_CARD_STANDALONE_VERIFICATION_CODE", 123 "NUMERIC_QUANTITY", 124 "ONE_TIME_CODE", 125 "DELIVERY_INSTRUCTIONS", 126 "ADDRESS_HOME_OVERFLOW", 127 "ADDRESS_HOME_LANDMARK", 128 "ADDRESS_HOME_OVERFLOW_AND_LANDMARK", 129 "ADDRESS_HOME_ADMIN_LEVEL2", 130 "ADDRESS_HOME_STREET_LOCATION", 131 "ADDRESS_HOME_BETWEEN_STREETS", 132 "ADDRESS_HOME_BETWEEN_STREETS_OR_LANDMARK", 133 "ADDRESS_HOME_BETWEEN_STREETS_1", 134 "ADDRESS_HOME_BETWEEN_STREETS_2", 135 "SINGLE_USERNAME_FORGOT_PASSWORD", 136 "MAX_VALID_FIELD_TYPE", 137 ].indexOf(A.H.get(ref)); 138 return idx < 0 ? 0 : idx + 1; 139 }, 140 141 "store_AddressComponent": (ptr: Pointer, ref: heap.Ref<any>) => { 142 const x = A.H.get<any>(ref); 143 144 if (typeof x === "undefined") { 145 A.store.Bool(ptr + 18, false); 146 A.store.Enum(ptr + 0, -1); 147 A.store.Ref(ptr + 4, undefined); 148 A.store.Bool(ptr + 16, false); 149 A.store.Bool(ptr + 8, false); 150 A.store.Bool(ptr + 17, false); 151 A.store.Bool(ptr + 9, false); 152 A.store.Ref(ptr + 12, undefined); 153 } else { 154 A.store.Bool(ptr + 18, true); 155 A.store.Enum( 156 ptr + 0, 157 [ 158 "NO_SERVER_DATA", 159 "UNKNOWN_TYPE", 160 "EMPTY_TYPE", 161 "NAME_FIRST", 162 "NAME_MIDDLE", 163 "NAME_LAST", 164 "NAME_MIDDLE_INITIAL", 165 "NAME_FULL", 166 "NAME_SUFFIX", 167 "EMAIL_ADDRESS", 168 "PHONE_HOME_NUMBER", 169 "PHONE_HOME_CITY_CODE", 170 "PHONE_HOME_COUNTRY_CODE", 171 "PHONE_HOME_CITY_AND_NUMBER", 172 "PHONE_HOME_WHOLE_NUMBER", 173 "ADDRESS_HOME_LINE1", 174 "ADDRESS_HOME_LINE2", 175 "ADDRESS_HOME_APT_NUM", 176 "ADDRESS_HOME_CITY", 177 "ADDRESS_HOME_STATE", 178 "ADDRESS_HOME_ZIP", 179 "ADDRESS_HOME_COUNTRY", 180 "CREDIT_CARD_NAME_FULL", 181 "CREDIT_CARD_NUMBER", 182 "CREDIT_CARD_EXP_MONTH", 183 "CREDIT_CARD_EXP_2_DIGIT_YEAR", 184 "CREDIT_CARD_EXP_4_DIGIT_YEAR", 185 "CREDIT_CARD_EXP_DATE_2_DIGIT_YEAR", 186 "CREDIT_CARD_EXP_DATE_4_DIGIT_YEAR", 187 "CREDIT_CARD_TYPE", 188 "CREDIT_CARD_VERIFICATION_CODE", 189 "COMPANY_NAME", 190 "FIELD_WITH_DEFAULT_VALUE", 191 "MERCHANT_EMAIL_SIGNUP", 192 "MERCHANT_PROMO_CODE", 193 "PASSWORD", 194 "ACCOUNT_CREATION_PASSWORD", 195 "ADDRESS_HOME_STREET_ADDRESS", 196 "ADDRESS_HOME_SORTING_CODE", 197 "ADDRESS_HOME_DEPENDENT_LOCALITY", 198 "ADDRESS_HOME_LINE3", 199 "NOT_ACCOUNT_CREATION_PASSWORD", 200 "USERNAME", 201 "USERNAME_AND_EMAIL_ADDRESS", 202 "NEW_PASSWORD", 203 "PROBABLY_NEW_PASSWORD", 204 "NOT_NEW_PASSWORD", 205 "CREDIT_CARD_NAME_FIRST", 206 "CREDIT_CARD_NAME_LAST", 207 "PHONE_HOME_EXTENSION", 208 "CONFIRMATION_PASSWORD", 209 "AMBIGUOUS_TYPE", 210 "SEARCH_TERM", 211 "PRICE", 212 "NOT_PASSWORD", 213 "SINGLE_USERNAME", 214 "NOT_USERNAME", 215 "UPI_VPA", 216 "ADDRESS_HOME_STREET_NAME", 217 "ADDRESS_HOME_HOUSE_NUMBER", 218 "ADDRESS_HOME_SUBPREMISE", 219 "ADDRESS_HOME_OTHER_SUBUNIT", 220 "NAME_LAST_FIRST", 221 "NAME_LAST_CONJUNCTION", 222 "NAME_LAST_SECOND", 223 "NAME_HONORIFIC_PREFIX", 224 "ADDRESS_HOME_ADDRESS", 225 "ADDRESS_HOME_ADDRESS_WITH_NAME", 226 "ADDRESS_HOME_FLOOR", 227 "NAME_FULL_WITH_HONORIFIC_PREFIX", 228 "BIRTHDATE_DAY", 229 "BIRTHDATE_MONTH", 230 "BIRTHDATE_4_DIGIT_YEAR", 231 "PHONE_HOME_CITY_CODE_WITH_TRUNK_PREFIX", 232 "PHONE_HOME_CITY_AND_NUMBER_WITHOUT_TRUNK_PREFIX", 233 "PHONE_HOME_NUMBER_PREFIX", 234 "PHONE_HOME_NUMBER_SUFFIX", 235 "IBAN_VALUE", 236 "CREDIT_CARD_STANDALONE_VERIFICATION_CODE", 237 "NUMERIC_QUANTITY", 238 "ONE_TIME_CODE", 239 "DELIVERY_INSTRUCTIONS", 240 "ADDRESS_HOME_OVERFLOW", 241 "ADDRESS_HOME_LANDMARK", 242 "ADDRESS_HOME_OVERFLOW_AND_LANDMARK", 243 "ADDRESS_HOME_ADMIN_LEVEL2", 244 "ADDRESS_HOME_STREET_LOCATION", 245 "ADDRESS_HOME_BETWEEN_STREETS", 246 "ADDRESS_HOME_BETWEEN_STREETS_OR_LANDMARK", 247 "ADDRESS_HOME_BETWEEN_STREETS_1", 248 "ADDRESS_HOME_BETWEEN_STREETS_2", 249 "SINGLE_USERNAME_FORGOT_PASSWORD", 250 "MAX_VALID_FIELD_TYPE", 251 ].indexOf(x["field"] as string) 252 ); 253 A.store.Ref(ptr + 4, x["fieldName"]); 254 A.store.Bool(ptr + 16, "isLongField" in x ? true : false); 255 A.store.Bool(ptr + 8, x["isLongField"] ? true : false); 256 A.store.Bool(ptr + 17, "isRequired" in x ? true : false); 257 A.store.Bool(ptr + 9, x["isRequired"] ? true : false); 258 A.store.Ref(ptr + 12, x["placeholder"]); 259 } 260 }, 261 "load_AddressComponent": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 262 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 263 264 x["field"] = A.load.Enum(ptr + 0, [ 265 "NO_SERVER_DATA", 266 "UNKNOWN_TYPE", 267 "EMPTY_TYPE", 268 "NAME_FIRST", 269 "NAME_MIDDLE", 270 "NAME_LAST", 271 "NAME_MIDDLE_INITIAL", 272 "NAME_FULL", 273 "NAME_SUFFIX", 274 "EMAIL_ADDRESS", 275 "PHONE_HOME_NUMBER", 276 "PHONE_HOME_CITY_CODE", 277 "PHONE_HOME_COUNTRY_CODE", 278 "PHONE_HOME_CITY_AND_NUMBER", 279 "PHONE_HOME_WHOLE_NUMBER", 280 "ADDRESS_HOME_LINE1", 281 "ADDRESS_HOME_LINE2", 282 "ADDRESS_HOME_APT_NUM", 283 "ADDRESS_HOME_CITY", 284 "ADDRESS_HOME_STATE", 285 "ADDRESS_HOME_ZIP", 286 "ADDRESS_HOME_COUNTRY", 287 "CREDIT_CARD_NAME_FULL", 288 "CREDIT_CARD_NUMBER", 289 "CREDIT_CARD_EXP_MONTH", 290 "CREDIT_CARD_EXP_2_DIGIT_YEAR", 291 "CREDIT_CARD_EXP_4_DIGIT_YEAR", 292 "CREDIT_CARD_EXP_DATE_2_DIGIT_YEAR", 293 "CREDIT_CARD_EXP_DATE_4_DIGIT_YEAR", 294 "CREDIT_CARD_TYPE", 295 "CREDIT_CARD_VERIFICATION_CODE", 296 "COMPANY_NAME", 297 "FIELD_WITH_DEFAULT_VALUE", 298 "MERCHANT_EMAIL_SIGNUP", 299 "MERCHANT_PROMO_CODE", 300 "PASSWORD", 301 "ACCOUNT_CREATION_PASSWORD", 302 "ADDRESS_HOME_STREET_ADDRESS", 303 "ADDRESS_HOME_SORTING_CODE", 304 "ADDRESS_HOME_DEPENDENT_LOCALITY", 305 "ADDRESS_HOME_LINE3", 306 "NOT_ACCOUNT_CREATION_PASSWORD", 307 "USERNAME", 308 "USERNAME_AND_EMAIL_ADDRESS", 309 "NEW_PASSWORD", 310 "PROBABLY_NEW_PASSWORD", 311 "NOT_NEW_PASSWORD", 312 "CREDIT_CARD_NAME_FIRST", 313 "CREDIT_CARD_NAME_LAST", 314 "PHONE_HOME_EXTENSION", 315 "CONFIRMATION_PASSWORD", 316 "AMBIGUOUS_TYPE", 317 "SEARCH_TERM", 318 "PRICE", 319 "NOT_PASSWORD", 320 "SINGLE_USERNAME", 321 "NOT_USERNAME", 322 "UPI_VPA", 323 "ADDRESS_HOME_STREET_NAME", 324 "ADDRESS_HOME_HOUSE_NUMBER", 325 "ADDRESS_HOME_SUBPREMISE", 326 "ADDRESS_HOME_OTHER_SUBUNIT", 327 "NAME_LAST_FIRST", 328 "NAME_LAST_CONJUNCTION", 329 "NAME_LAST_SECOND", 330 "NAME_HONORIFIC_PREFIX", 331 "ADDRESS_HOME_ADDRESS", 332 "ADDRESS_HOME_ADDRESS_WITH_NAME", 333 "ADDRESS_HOME_FLOOR", 334 "NAME_FULL_WITH_HONORIFIC_PREFIX", 335 "BIRTHDATE_DAY", 336 "BIRTHDATE_MONTH", 337 "BIRTHDATE_4_DIGIT_YEAR", 338 "PHONE_HOME_CITY_CODE_WITH_TRUNK_PREFIX", 339 "PHONE_HOME_CITY_AND_NUMBER_WITHOUT_TRUNK_PREFIX", 340 "PHONE_HOME_NUMBER_PREFIX", 341 "PHONE_HOME_NUMBER_SUFFIX", 342 "IBAN_VALUE", 343 "CREDIT_CARD_STANDALONE_VERIFICATION_CODE", 344 "NUMERIC_QUANTITY", 345 "ONE_TIME_CODE", 346 "DELIVERY_INSTRUCTIONS", 347 "ADDRESS_HOME_OVERFLOW", 348 "ADDRESS_HOME_LANDMARK", 349 "ADDRESS_HOME_OVERFLOW_AND_LANDMARK", 350 "ADDRESS_HOME_ADMIN_LEVEL2", 351 "ADDRESS_HOME_STREET_LOCATION", 352 "ADDRESS_HOME_BETWEEN_STREETS", 353 "ADDRESS_HOME_BETWEEN_STREETS_OR_LANDMARK", 354 "ADDRESS_HOME_BETWEEN_STREETS_1", 355 "ADDRESS_HOME_BETWEEN_STREETS_2", 356 "SINGLE_USERNAME_FORGOT_PASSWORD", 357 "MAX_VALID_FIELD_TYPE", 358 ]); 359 x["fieldName"] = A.load.Ref(ptr + 4, undefined); 360 if (A.load.Bool(ptr + 16)) { 361 x["isLongField"] = A.load.Bool(ptr + 8); 362 } else { 363 delete x["isLongField"]; 364 } 365 if (A.load.Bool(ptr + 17)) { 366 x["isRequired"] = A.load.Bool(ptr + 9); 367 } else { 368 delete x["isRequired"]; 369 } 370 x["placeholder"] = A.load.Ref(ptr + 12, undefined); 371 return create === A.H.TRUE ? A.H.push(x) : ref; 372 }, 373 374 "store_AddressComponentRow": (ptr: Pointer, ref: heap.Ref<any>) => { 375 const x = A.H.get<any>(ref); 376 377 if (typeof x === "undefined") { 378 A.store.Bool(ptr + 4, false); 379 A.store.Ref(ptr + 0, undefined); 380 } else { 381 A.store.Bool(ptr + 4, true); 382 A.store.Ref(ptr + 0, x["row"]); 383 } 384 }, 385 "load_AddressComponentRow": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 386 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 387 388 x["row"] = A.load.Ref(ptr + 0, undefined); 389 return create === A.H.TRUE ? A.H.push(x) : ref; 390 }, 391 392 "store_AddressComponents": (ptr: Pointer, ref: heap.Ref<any>) => { 393 const x = A.H.get<any>(ref); 394 395 if (typeof x === "undefined") { 396 A.store.Bool(ptr + 8, false); 397 A.store.Ref(ptr + 0, undefined); 398 A.store.Ref(ptr + 4, undefined); 399 } else { 400 A.store.Bool(ptr + 8, true); 401 A.store.Ref(ptr + 0, x["components"]); 402 A.store.Ref(ptr + 4, x["languageCode"]); 403 } 404 }, 405 "load_AddressComponents": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 406 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 407 408 x["components"] = A.load.Ref(ptr + 0, undefined); 409 x["languageCode"] = A.load.Ref(ptr + 4, undefined); 410 return create === A.H.TRUE ? A.H.push(x) : ref; 411 }, 412 413 "store_AddressField": (ptr: Pointer, ref: heap.Ref<any>) => { 414 const x = A.H.get<any>(ref); 415 416 if (typeof x === "undefined") { 417 A.store.Bool(ptr + 8, false); 418 A.store.Enum(ptr + 0, -1); 419 A.store.Ref(ptr + 4, undefined); 420 } else { 421 A.store.Bool(ptr + 8, true); 422 A.store.Enum( 423 ptr + 0, 424 [ 425 "NO_SERVER_DATA", 426 "UNKNOWN_TYPE", 427 "EMPTY_TYPE", 428 "NAME_FIRST", 429 "NAME_MIDDLE", 430 "NAME_LAST", 431 "NAME_MIDDLE_INITIAL", 432 "NAME_FULL", 433 "NAME_SUFFIX", 434 "EMAIL_ADDRESS", 435 "PHONE_HOME_NUMBER", 436 "PHONE_HOME_CITY_CODE", 437 "PHONE_HOME_COUNTRY_CODE", 438 "PHONE_HOME_CITY_AND_NUMBER", 439 "PHONE_HOME_WHOLE_NUMBER", 440 "ADDRESS_HOME_LINE1", 441 "ADDRESS_HOME_LINE2", 442 "ADDRESS_HOME_APT_NUM", 443 "ADDRESS_HOME_CITY", 444 "ADDRESS_HOME_STATE", 445 "ADDRESS_HOME_ZIP", 446 "ADDRESS_HOME_COUNTRY", 447 "CREDIT_CARD_NAME_FULL", 448 "CREDIT_CARD_NUMBER", 449 "CREDIT_CARD_EXP_MONTH", 450 "CREDIT_CARD_EXP_2_DIGIT_YEAR", 451 "CREDIT_CARD_EXP_4_DIGIT_YEAR", 452 "CREDIT_CARD_EXP_DATE_2_DIGIT_YEAR", 453 "CREDIT_CARD_EXP_DATE_4_DIGIT_YEAR", 454 "CREDIT_CARD_TYPE", 455 "CREDIT_CARD_VERIFICATION_CODE", 456 "COMPANY_NAME", 457 "FIELD_WITH_DEFAULT_VALUE", 458 "MERCHANT_EMAIL_SIGNUP", 459 "MERCHANT_PROMO_CODE", 460 "PASSWORD", 461 "ACCOUNT_CREATION_PASSWORD", 462 "ADDRESS_HOME_STREET_ADDRESS", 463 "ADDRESS_HOME_SORTING_CODE", 464 "ADDRESS_HOME_DEPENDENT_LOCALITY", 465 "ADDRESS_HOME_LINE3", 466 "NOT_ACCOUNT_CREATION_PASSWORD", 467 "USERNAME", 468 "USERNAME_AND_EMAIL_ADDRESS", 469 "NEW_PASSWORD", 470 "PROBABLY_NEW_PASSWORD", 471 "NOT_NEW_PASSWORD", 472 "CREDIT_CARD_NAME_FIRST", 473 "CREDIT_CARD_NAME_LAST", 474 "PHONE_HOME_EXTENSION", 475 "CONFIRMATION_PASSWORD", 476 "AMBIGUOUS_TYPE", 477 "SEARCH_TERM", 478 "PRICE", 479 "NOT_PASSWORD", 480 "SINGLE_USERNAME", 481 "NOT_USERNAME", 482 "UPI_VPA", 483 "ADDRESS_HOME_STREET_NAME", 484 "ADDRESS_HOME_HOUSE_NUMBER", 485 "ADDRESS_HOME_SUBPREMISE", 486 "ADDRESS_HOME_OTHER_SUBUNIT", 487 "NAME_LAST_FIRST", 488 "NAME_LAST_CONJUNCTION", 489 "NAME_LAST_SECOND", 490 "NAME_HONORIFIC_PREFIX", 491 "ADDRESS_HOME_ADDRESS", 492 "ADDRESS_HOME_ADDRESS_WITH_NAME", 493 "ADDRESS_HOME_FLOOR", 494 "NAME_FULL_WITH_HONORIFIC_PREFIX", 495 "BIRTHDATE_DAY", 496 "BIRTHDATE_MONTH", 497 "BIRTHDATE_4_DIGIT_YEAR", 498 "PHONE_HOME_CITY_CODE_WITH_TRUNK_PREFIX", 499 "PHONE_HOME_CITY_AND_NUMBER_WITHOUT_TRUNK_PREFIX", 500 "PHONE_HOME_NUMBER_PREFIX", 501 "PHONE_HOME_NUMBER_SUFFIX", 502 "IBAN_VALUE", 503 "CREDIT_CARD_STANDALONE_VERIFICATION_CODE", 504 "NUMERIC_QUANTITY", 505 "ONE_TIME_CODE", 506 "DELIVERY_INSTRUCTIONS", 507 "ADDRESS_HOME_OVERFLOW", 508 "ADDRESS_HOME_LANDMARK", 509 "ADDRESS_HOME_OVERFLOW_AND_LANDMARK", 510 "ADDRESS_HOME_ADMIN_LEVEL2", 511 "ADDRESS_HOME_STREET_LOCATION", 512 "ADDRESS_HOME_BETWEEN_STREETS", 513 "ADDRESS_HOME_BETWEEN_STREETS_OR_LANDMARK", 514 "ADDRESS_HOME_BETWEEN_STREETS_1", 515 "ADDRESS_HOME_BETWEEN_STREETS_2", 516 "SINGLE_USERNAME_FORGOT_PASSWORD", 517 "MAX_VALID_FIELD_TYPE", 518 ].indexOf(x["type"] as string) 519 ); 520 A.store.Ref(ptr + 4, x["value"]); 521 } 522 }, 523 "load_AddressField": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 524 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 525 526 x["type"] = A.load.Enum(ptr + 0, [ 527 "NO_SERVER_DATA", 528 "UNKNOWN_TYPE", 529 "EMPTY_TYPE", 530 "NAME_FIRST", 531 "NAME_MIDDLE", 532 "NAME_LAST", 533 "NAME_MIDDLE_INITIAL", 534 "NAME_FULL", 535 "NAME_SUFFIX", 536 "EMAIL_ADDRESS", 537 "PHONE_HOME_NUMBER", 538 "PHONE_HOME_CITY_CODE", 539 "PHONE_HOME_COUNTRY_CODE", 540 "PHONE_HOME_CITY_AND_NUMBER", 541 "PHONE_HOME_WHOLE_NUMBER", 542 "ADDRESS_HOME_LINE1", 543 "ADDRESS_HOME_LINE2", 544 "ADDRESS_HOME_APT_NUM", 545 "ADDRESS_HOME_CITY", 546 "ADDRESS_HOME_STATE", 547 "ADDRESS_HOME_ZIP", 548 "ADDRESS_HOME_COUNTRY", 549 "CREDIT_CARD_NAME_FULL", 550 "CREDIT_CARD_NUMBER", 551 "CREDIT_CARD_EXP_MONTH", 552 "CREDIT_CARD_EXP_2_DIGIT_YEAR", 553 "CREDIT_CARD_EXP_4_DIGIT_YEAR", 554 "CREDIT_CARD_EXP_DATE_2_DIGIT_YEAR", 555 "CREDIT_CARD_EXP_DATE_4_DIGIT_YEAR", 556 "CREDIT_CARD_TYPE", 557 "CREDIT_CARD_VERIFICATION_CODE", 558 "COMPANY_NAME", 559 "FIELD_WITH_DEFAULT_VALUE", 560 "MERCHANT_EMAIL_SIGNUP", 561 "MERCHANT_PROMO_CODE", 562 "PASSWORD", 563 "ACCOUNT_CREATION_PASSWORD", 564 "ADDRESS_HOME_STREET_ADDRESS", 565 "ADDRESS_HOME_SORTING_CODE", 566 "ADDRESS_HOME_DEPENDENT_LOCALITY", 567 "ADDRESS_HOME_LINE3", 568 "NOT_ACCOUNT_CREATION_PASSWORD", 569 "USERNAME", 570 "USERNAME_AND_EMAIL_ADDRESS", 571 "NEW_PASSWORD", 572 "PROBABLY_NEW_PASSWORD", 573 "NOT_NEW_PASSWORD", 574 "CREDIT_CARD_NAME_FIRST", 575 "CREDIT_CARD_NAME_LAST", 576 "PHONE_HOME_EXTENSION", 577 "CONFIRMATION_PASSWORD", 578 "AMBIGUOUS_TYPE", 579 "SEARCH_TERM", 580 "PRICE", 581 "NOT_PASSWORD", 582 "SINGLE_USERNAME", 583 "NOT_USERNAME", 584 "UPI_VPA", 585 "ADDRESS_HOME_STREET_NAME", 586 "ADDRESS_HOME_HOUSE_NUMBER", 587 "ADDRESS_HOME_SUBPREMISE", 588 "ADDRESS_HOME_OTHER_SUBUNIT", 589 "NAME_LAST_FIRST", 590 "NAME_LAST_CONJUNCTION", 591 "NAME_LAST_SECOND", 592 "NAME_HONORIFIC_PREFIX", 593 "ADDRESS_HOME_ADDRESS", 594 "ADDRESS_HOME_ADDRESS_WITH_NAME", 595 "ADDRESS_HOME_FLOOR", 596 "NAME_FULL_WITH_HONORIFIC_PREFIX", 597 "BIRTHDATE_DAY", 598 "BIRTHDATE_MONTH", 599 "BIRTHDATE_4_DIGIT_YEAR", 600 "PHONE_HOME_CITY_CODE_WITH_TRUNK_PREFIX", 601 "PHONE_HOME_CITY_AND_NUMBER_WITHOUT_TRUNK_PREFIX", 602 "PHONE_HOME_NUMBER_PREFIX", 603 "PHONE_HOME_NUMBER_SUFFIX", 604 "IBAN_VALUE", 605 "CREDIT_CARD_STANDALONE_VERIFICATION_CODE", 606 "NUMERIC_QUANTITY", 607 "ONE_TIME_CODE", 608 "DELIVERY_INSTRUCTIONS", 609 "ADDRESS_HOME_OVERFLOW", 610 "ADDRESS_HOME_LANDMARK", 611 "ADDRESS_HOME_OVERFLOW_AND_LANDMARK", 612 "ADDRESS_HOME_ADMIN_LEVEL2", 613 "ADDRESS_HOME_STREET_LOCATION", 614 "ADDRESS_HOME_BETWEEN_STREETS", 615 "ADDRESS_HOME_BETWEEN_STREETS_OR_LANDMARK", 616 "ADDRESS_HOME_BETWEEN_STREETS_1", 617 "ADDRESS_HOME_BETWEEN_STREETS_2", 618 "SINGLE_USERNAME_FORGOT_PASSWORD", 619 "MAX_VALID_FIELD_TYPE", 620 ]); 621 x["value"] = A.load.Ref(ptr + 4, undefined); 622 return create === A.H.TRUE ? A.H.push(x) : ref; 623 }, 624 "constof_AddressSource": (ref: heap.Ref<string>): number => { 625 const idx = ["LOCAL_OR_SYNCABLE", "ACCOUNT"].indexOf(A.H.get(ref)); 626 return idx < 0 ? 0 : idx + 1; 627 }, 628 629 "store_AutofillMetadata": (ptr: Pointer, ref: heap.Ref<any>) => { 630 const x = A.H.get<any>(ref); 631 632 if (typeof x === "undefined") { 633 A.store.Bool(ptr + 22, false); 634 A.store.Ref(ptr + 0, undefined); 635 A.store.Ref(ptr + 4, undefined); 636 A.store.Enum(ptr + 8, -1); 637 A.store.Bool(ptr + 17, false); 638 A.store.Bool(ptr + 12, false); 639 A.store.Bool(ptr + 18, false); 640 A.store.Bool(ptr + 13, false); 641 A.store.Bool(ptr + 19, false); 642 A.store.Bool(ptr + 14, false); 643 A.store.Bool(ptr + 20, false); 644 A.store.Bool(ptr + 15, false); 645 A.store.Bool(ptr + 21, false); 646 A.store.Bool(ptr + 16, false); 647 } else { 648 A.store.Bool(ptr + 22, true); 649 A.store.Ref(ptr + 0, x["summaryLabel"]); 650 A.store.Ref(ptr + 4, x["summarySublabel"]); 651 A.store.Enum(ptr + 8, ["LOCAL_OR_SYNCABLE", "ACCOUNT"].indexOf(x["source"] as string)); 652 A.store.Bool(ptr + 17, "isLocal" in x ? true : false); 653 A.store.Bool(ptr + 12, x["isLocal"] ? true : false); 654 A.store.Bool(ptr + 18, "isCached" in x ? true : false); 655 A.store.Bool(ptr + 13, x["isCached"] ? true : false); 656 A.store.Bool(ptr + 19, "isMigratable" in x ? true : false); 657 A.store.Bool(ptr + 14, x["isMigratable"] ? true : false); 658 A.store.Bool(ptr + 20, "isVirtualCardEnrollmentEligible" in x ? true : false); 659 A.store.Bool(ptr + 15, x["isVirtualCardEnrollmentEligible"] ? true : false); 660 A.store.Bool(ptr + 21, "isVirtualCardEnrolled" in x ? true : false); 661 A.store.Bool(ptr + 16, x["isVirtualCardEnrolled"] ? true : false); 662 } 663 }, 664 "load_AutofillMetadata": (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["summaryLabel"] = A.load.Ref(ptr + 0, undefined); 668 x["summarySublabel"] = A.load.Ref(ptr + 4, undefined); 669 x["source"] = A.load.Enum(ptr + 8, ["LOCAL_OR_SYNCABLE", "ACCOUNT"]); 670 if (A.load.Bool(ptr + 17)) { 671 x["isLocal"] = A.load.Bool(ptr + 12); 672 } else { 673 delete x["isLocal"]; 674 } 675 if (A.load.Bool(ptr + 18)) { 676 x["isCached"] = A.load.Bool(ptr + 13); 677 } else { 678 delete x["isCached"]; 679 } 680 if (A.load.Bool(ptr + 19)) { 681 x["isMigratable"] = A.load.Bool(ptr + 14); 682 } else { 683 delete x["isMigratable"]; 684 } 685 if (A.load.Bool(ptr + 20)) { 686 x["isVirtualCardEnrollmentEligible"] = A.load.Bool(ptr + 15); 687 } else { 688 delete x["isVirtualCardEnrollmentEligible"]; 689 } 690 if (A.load.Bool(ptr + 21)) { 691 x["isVirtualCardEnrolled"] = A.load.Bool(ptr + 16); 692 } else { 693 delete x["isVirtualCardEnrolled"]; 694 } 695 return create === A.H.TRUE ? A.H.push(x) : ref; 696 }, 697 698 "store_AddressEntry": (ptr: Pointer, ref: heap.Ref<any>) => { 699 const x = A.H.get<any>(ref); 700 701 if (typeof x === "undefined") { 702 A.store.Bool(ptr + 35, false); 703 A.store.Ref(ptr + 0, undefined); 704 A.store.Ref(ptr + 4, undefined); 705 A.store.Ref(ptr + 8, undefined); 706 707 A.store.Bool(ptr + 12 + 22, false); 708 A.store.Ref(ptr + 12 + 0, undefined); 709 A.store.Ref(ptr + 12 + 4, undefined); 710 A.store.Enum(ptr + 12 + 8, -1); 711 A.store.Bool(ptr + 12 + 17, false); 712 A.store.Bool(ptr + 12 + 12, false); 713 A.store.Bool(ptr + 12 + 18, false); 714 A.store.Bool(ptr + 12 + 13, false); 715 A.store.Bool(ptr + 12 + 19, false); 716 A.store.Bool(ptr + 12 + 14, false); 717 A.store.Bool(ptr + 12 + 20, false); 718 A.store.Bool(ptr + 12 + 15, false); 719 A.store.Bool(ptr + 12 + 21, false); 720 A.store.Bool(ptr + 12 + 16, false); 721 } else { 722 A.store.Bool(ptr + 35, true); 723 A.store.Ref(ptr + 0, x["guid"]); 724 A.store.Ref(ptr + 4, x["fields"]); 725 A.store.Ref(ptr + 8, x["languageCode"]); 726 727 if (typeof x["metadata"] === "undefined") { 728 A.store.Bool(ptr + 12 + 22, false); 729 A.store.Ref(ptr + 12 + 0, undefined); 730 A.store.Ref(ptr + 12 + 4, undefined); 731 A.store.Enum(ptr + 12 + 8, -1); 732 A.store.Bool(ptr + 12 + 17, false); 733 A.store.Bool(ptr + 12 + 12, false); 734 A.store.Bool(ptr + 12 + 18, false); 735 A.store.Bool(ptr + 12 + 13, false); 736 A.store.Bool(ptr + 12 + 19, false); 737 A.store.Bool(ptr + 12 + 14, false); 738 A.store.Bool(ptr + 12 + 20, false); 739 A.store.Bool(ptr + 12 + 15, false); 740 A.store.Bool(ptr + 12 + 21, false); 741 A.store.Bool(ptr + 12 + 16, false); 742 } else { 743 A.store.Bool(ptr + 12 + 22, true); 744 A.store.Ref(ptr + 12 + 0, x["metadata"]["summaryLabel"]); 745 A.store.Ref(ptr + 12 + 4, x["metadata"]["summarySublabel"]); 746 A.store.Enum(ptr + 12 + 8, ["LOCAL_OR_SYNCABLE", "ACCOUNT"].indexOf(x["metadata"]["source"] as string)); 747 A.store.Bool(ptr + 12 + 17, "isLocal" in x["metadata"] ? true : false); 748 A.store.Bool(ptr + 12 + 12, x["metadata"]["isLocal"] ? true : false); 749 A.store.Bool(ptr + 12 + 18, "isCached" in x["metadata"] ? true : false); 750 A.store.Bool(ptr + 12 + 13, x["metadata"]["isCached"] ? true : false); 751 A.store.Bool(ptr + 12 + 19, "isMigratable" in x["metadata"] ? true : false); 752 A.store.Bool(ptr + 12 + 14, x["metadata"]["isMigratable"] ? true : false); 753 A.store.Bool(ptr + 12 + 20, "isVirtualCardEnrollmentEligible" in x["metadata"] ? true : false); 754 A.store.Bool(ptr + 12 + 15, x["metadata"]["isVirtualCardEnrollmentEligible"] ? true : false); 755 A.store.Bool(ptr + 12 + 21, "isVirtualCardEnrolled" in x["metadata"] ? true : false); 756 A.store.Bool(ptr + 12 + 16, x["metadata"]["isVirtualCardEnrolled"] ? true : false); 757 } 758 } 759 }, 760 "load_AddressEntry": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 761 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 762 763 x["guid"] = A.load.Ref(ptr + 0, undefined); 764 x["fields"] = A.load.Ref(ptr + 4, undefined); 765 x["languageCode"] = A.load.Ref(ptr + 8, undefined); 766 if (A.load.Bool(ptr + 12 + 22)) { 767 x["metadata"] = {}; 768 x["metadata"]["summaryLabel"] = A.load.Ref(ptr + 12 + 0, undefined); 769 x["metadata"]["summarySublabel"] = A.load.Ref(ptr + 12 + 4, undefined); 770 x["metadata"]["source"] = A.load.Enum(ptr + 12 + 8, ["LOCAL_OR_SYNCABLE", "ACCOUNT"]); 771 if (A.load.Bool(ptr + 12 + 17)) { 772 x["metadata"]["isLocal"] = A.load.Bool(ptr + 12 + 12); 773 } else { 774 delete x["metadata"]["isLocal"]; 775 } 776 if (A.load.Bool(ptr + 12 + 18)) { 777 x["metadata"]["isCached"] = A.load.Bool(ptr + 12 + 13); 778 } else { 779 delete x["metadata"]["isCached"]; 780 } 781 if (A.load.Bool(ptr + 12 + 19)) { 782 x["metadata"]["isMigratable"] = A.load.Bool(ptr + 12 + 14); 783 } else { 784 delete x["metadata"]["isMigratable"]; 785 } 786 if (A.load.Bool(ptr + 12 + 20)) { 787 x["metadata"]["isVirtualCardEnrollmentEligible"] = A.load.Bool(ptr + 12 + 15); 788 } else { 789 delete x["metadata"]["isVirtualCardEnrollmentEligible"]; 790 } 791 if (A.load.Bool(ptr + 12 + 21)) { 792 x["metadata"]["isVirtualCardEnrolled"] = A.load.Bool(ptr + 12 + 16); 793 } else { 794 delete x["metadata"]["isVirtualCardEnrolled"]; 795 } 796 } else { 797 delete x["metadata"]; 798 } 799 return create === A.H.TRUE ? A.H.push(x) : ref; 800 }, 801 802 "store_CountryEntry": (ptr: Pointer, ref: heap.Ref<any>) => { 803 const x = A.H.get<any>(ref); 804 805 if (typeof x === "undefined") { 806 A.store.Bool(ptr + 8, false); 807 A.store.Ref(ptr + 0, undefined); 808 A.store.Ref(ptr + 4, undefined); 809 } else { 810 A.store.Bool(ptr + 8, true); 811 A.store.Ref(ptr + 0, x["name"]); 812 A.store.Ref(ptr + 4, x["countryCode"]); 813 } 814 }, 815 "load_CountryEntry": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 816 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 817 818 x["name"] = A.load.Ref(ptr + 0, undefined); 819 x["countryCode"] = A.load.Ref(ptr + 4, undefined); 820 return create === A.H.TRUE ? A.H.push(x) : ref; 821 }, 822 823 "store_CreditCardEntry": (ptr: Pointer, ref: heap.Ref<any>) => { 824 const x = A.H.get<any>(ref); 825 826 if (typeof x === "undefined") { 827 A.store.Bool(ptr + 55, false); 828 A.store.Ref(ptr + 0, undefined); 829 A.store.Ref(ptr + 4, undefined); 830 A.store.Ref(ptr + 8, undefined); 831 A.store.Ref(ptr + 12, undefined); 832 A.store.Ref(ptr + 16, undefined); 833 A.store.Ref(ptr + 20, undefined); 834 A.store.Ref(ptr + 24, undefined); 835 A.store.Ref(ptr + 28, undefined); 836 837 A.store.Bool(ptr + 32 + 22, false); 838 A.store.Ref(ptr + 32 + 0, undefined); 839 A.store.Ref(ptr + 32 + 4, undefined); 840 A.store.Enum(ptr + 32 + 8, -1); 841 A.store.Bool(ptr + 32 + 17, false); 842 A.store.Bool(ptr + 32 + 12, false); 843 A.store.Bool(ptr + 32 + 18, false); 844 A.store.Bool(ptr + 32 + 13, false); 845 A.store.Bool(ptr + 32 + 19, false); 846 A.store.Bool(ptr + 32 + 14, false); 847 A.store.Bool(ptr + 32 + 20, false); 848 A.store.Bool(ptr + 32 + 15, false); 849 A.store.Bool(ptr + 32 + 21, false); 850 A.store.Bool(ptr + 32 + 16, false); 851 } else { 852 A.store.Bool(ptr + 55, true); 853 A.store.Ref(ptr + 0, x["guid"]); 854 A.store.Ref(ptr + 4, x["name"]); 855 A.store.Ref(ptr + 8, x["cardNumber"]); 856 A.store.Ref(ptr + 12, x["expirationMonth"]); 857 A.store.Ref(ptr + 16, x["expirationYear"]); 858 A.store.Ref(ptr + 20, x["nickname"]); 859 A.store.Ref(ptr + 24, x["network"]); 860 A.store.Ref(ptr + 28, x["imageSrc"]); 861 862 if (typeof x["metadata"] === "undefined") { 863 A.store.Bool(ptr + 32 + 22, false); 864 A.store.Ref(ptr + 32 + 0, undefined); 865 A.store.Ref(ptr + 32 + 4, undefined); 866 A.store.Enum(ptr + 32 + 8, -1); 867 A.store.Bool(ptr + 32 + 17, false); 868 A.store.Bool(ptr + 32 + 12, false); 869 A.store.Bool(ptr + 32 + 18, false); 870 A.store.Bool(ptr + 32 + 13, false); 871 A.store.Bool(ptr + 32 + 19, false); 872 A.store.Bool(ptr + 32 + 14, false); 873 A.store.Bool(ptr + 32 + 20, false); 874 A.store.Bool(ptr + 32 + 15, false); 875 A.store.Bool(ptr + 32 + 21, false); 876 A.store.Bool(ptr + 32 + 16, false); 877 } else { 878 A.store.Bool(ptr + 32 + 22, true); 879 A.store.Ref(ptr + 32 + 0, x["metadata"]["summaryLabel"]); 880 A.store.Ref(ptr + 32 + 4, x["metadata"]["summarySublabel"]); 881 A.store.Enum(ptr + 32 + 8, ["LOCAL_OR_SYNCABLE", "ACCOUNT"].indexOf(x["metadata"]["source"] as string)); 882 A.store.Bool(ptr + 32 + 17, "isLocal" in x["metadata"] ? true : false); 883 A.store.Bool(ptr + 32 + 12, x["metadata"]["isLocal"] ? true : false); 884 A.store.Bool(ptr + 32 + 18, "isCached" in x["metadata"] ? true : false); 885 A.store.Bool(ptr + 32 + 13, x["metadata"]["isCached"] ? true : false); 886 A.store.Bool(ptr + 32 + 19, "isMigratable" in x["metadata"] ? true : false); 887 A.store.Bool(ptr + 32 + 14, x["metadata"]["isMigratable"] ? true : false); 888 A.store.Bool(ptr + 32 + 20, "isVirtualCardEnrollmentEligible" in x["metadata"] ? true : false); 889 A.store.Bool(ptr + 32 + 15, x["metadata"]["isVirtualCardEnrollmentEligible"] ? true : false); 890 A.store.Bool(ptr + 32 + 21, "isVirtualCardEnrolled" in x["metadata"] ? true : false); 891 A.store.Bool(ptr + 32 + 16, x["metadata"]["isVirtualCardEnrolled"] ? true : false); 892 } 893 } 894 }, 895 "load_CreditCardEntry": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 896 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 897 898 x["guid"] = A.load.Ref(ptr + 0, undefined); 899 x["name"] = A.load.Ref(ptr + 4, undefined); 900 x["cardNumber"] = A.load.Ref(ptr + 8, undefined); 901 x["expirationMonth"] = A.load.Ref(ptr + 12, undefined); 902 x["expirationYear"] = A.load.Ref(ptr + 16, undefined); 903 x["nickname"] = A.load.Ref(ptr + 20, undefined); 904 x["network"] = A.load.Ref(ptr + 24, undefined); 905 x["imageSrc"] = A.load.Ref(ptr + 28, undefined); 906 if (A.load.Bool(ptr + 32 + 22)) { 907 x["metadata"] = {}; 908 x["metadata"]["summaryLabel"] = A.load.Ref(ptr + 32 + 0, undefined); 909 x["metadata"]["summarySublabel"] = A.load.Ref(ptr + 32 + 4, undefined); 910 x["metadata"]["source"] = A.load.Enum(ptr + 32 + 8, ["LOCAL_OR_SYNCABLE", "ACCOUNT"]); 911 if (A.load.Bool(ptr + 32 + 17)) { 912 x["metadata"]["isLocal"] = A.load.Bool(ptr + 32 + 12); 913 } else { 914 delete x["metadata"]["isLocal"]; 915 } 916 if (A.load.Bool(ptr + 32 + 18)) { 917 x["metadata"]["isCached"] = A.load.Bool(ptr + 32 + 13); 918 } else { 919 delete x["metadata"]["isCached"]; 920 } 921 if (A.load.Bool(ptr + 32 + 19)) { 922 x["metadata"]["isMigratable"] = A.load.Bool(ptr + 32 + 14); 923 } else { 924 delete x["metadata"]["isMigratable"]; 925 } 926 if (A.load.Bool(ptr + 32 + 20)) { 927 x["metadata"]["isVirtualCardEnrollmentEligible"] = A.load.Bool(ptr + 32 + 15); 928 } else { 929 delete x["metadata"]["isVirtualCardEnrollmentEligible"]; 930 } 931 if (A.load.Bool(ptr + 32 + 21)) { 932 x["metadata"]["isVirtualCardEnrolled"] = A.load.Bool(ptr + 32 + 16); 933 } else { 934 delete x["metadata"]["isVirtualCardEnrolled"]; 935 } 936 } else { 937 delete x["metadata"]; 938 } 939 return create === A.H.TRUE ? A.H.push(x) : ref; 940 }, 941 942 "store_IbanEntry": (ptr: Pointer, ref: heap.Ref<any>) => { 943 const x = A.H.get<any>(ref); 944 945 if (typeof x === "undefined") { 946 A.store.Bool(ptr + 35, false); 947 A.store.Ref(ptr + 0, undefined); 948 A.store.Ref(ptr + 4, undefined); 949 A.store.Ref(ptr + 8, undefined); 950 951 A.store.Bool(ptr + 12 + 22, false); 952 A.store.Ref(ptr + 12 + 0, undefined); 953 A.store.Ref(ptr + 12 + 4, undefined); 954 A.store.Enum(ptr + 12 + 8, -1); 955 A.store.Bool(ptr + 12 + 17, false); 956 A.store.Bool(ptr + 12 + 12, false); 957 A.store.Bool(ptr + 12 + 18, false); 958 A.store.Bool(ptr + 12 + 13, false); 959 A.store.Bool(ptr + 12 + 19, false); 960 A.store.Bool(ptr + 12 + 14, false); 961 A.store.Bool(ptr + 12 + 20, false); 962 A.store.Bool(ptr + 12 + 15, false); 963 A.store.Bool(ptr + 12 + 21, false); 964 A.store.Bool(ptr + 12 + 16, false); 965 } else { 966 A.store.Bool(ptr + 35, true); 967 A.store.Ref(ptr + 0, x["guid"]); 968 A.store.Ref(ptr + 4, x["value"]); 969 A.store.Ref(ptr + 8, x["nickname"]); 970 971 if (typeof x["metadata"] === "undefined") { 972 A.store.Bool(ptr + 12 + 22, false); 973 A.store.Ref(ptr + 12 + 0, undefined); 974 A.store.Ref(ptr + 12 + 4, undefined); 975 A.store.Enum(ptr + 12 + 8, -1); 976 A.store.Bool(ptr + 12 + 17, false); 977 A.store.Bool(ptr + 12 + 12, false); 978 A.store.Bool(ptr + 12 + 18, false); 979 A.store.Bool(ptr + 12 + 13, false); 980 A.store.Bool(ptr + 12 + 19, false); 981 A.store.Bool(ptr + 12 + 14, false); 982 A.store.Bool(ptr + 12 + 20, false); 983 A.store.Bool(ptr + 12 + 15, false); 984 A.store.Bool(ptr + 12 + 21, false); 985 A.store.Bool(ptr + 12 + 16, false); 986 } else { 987 A.store.Bool(ptr + 12 + 22, true); 988 A.store.Ref(ptr + 12 + 0, x["metadata"]["summaryLabel"]); 989 A.store.Ref(ptr + 12 + 4, x["metadata"]["summarySublabel"]); 990 A.store.Enum(ptr + 12 + 8, ["LOCAL_OR_SYNCABLE", "ACCOUNT"].indexOf(x["metadata"]["source"] as string)); 991 A.store.Bool(ptr + 12 + 17, "isLocal" in x["metadata"] ? true : false); 992 A.store.Bool(ptr + 12 + 12, x["metadata"]["isLocal"] ? true : false); 993 A.store.Bool(ptr + 12 + 18, "isCached" in x["metadata"] ? true : false); 994 A.store.Bool(ptr + 12 + 13, x["metadata"]["isCached"] ? true : false); 995 A.store.Bool(ptr + 12 + 19, "isMigratable" in x["metadata"] ? true : false); 996 A.store.Bool(ptr + 12 + 14, x["metadata"]["isMigratable"] ? true : false); 997 A.store.Bool(ptr + 12 + 20, "isVirtualCardEnrollmentEligible" in x["metadata"] ? true : false); 998 A.store.Bool(ptr + 12 + 15, x["metadata"]["isVirtualCardEnrollmentEligible"] ? true : false); 999 A.store.Bool(ptr + 12 + 21, "isVirtualCardEnrolled" in x["metadata"] ? true : false); 1000 A.store.Bool(ptr + 12 + 16, x["metadata"]["isVirtualCardEnrolled"] ? true : false); 1001 } 1002 } 1003 }, 1004 "load_IbanEntry": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 1005 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 1006 1007 x["guid"] = A.load.Ref(ptr + 0, undefined); 1008 x["value"] = A.load.Ref(ptr + 4, undefined); 1009 x["nickname"] = A.load.Ref(ptr + 8, undefined); 1010 if (A.load.Bool(ptr + 12 + 22)) { 1011 x["metadata"] = {}; 1012 x["metadata"]["summaryLabel"] = A.load.Ref(ptr + 12 + 0, undefined); 1013 x["metadata"]["summarySublabel"] = A.load.Ref(ptr + 12 + 4, undefined); 1014 x["metadata"]["source"] = A.load.Enum(ptr + 12 + 8, ["LOCAL_OR_SYNCABLE", "ACCOUNT"]); 1015 if (A.load.Bool(ptr + 12 + 17)) { 1016 x["metadata"]["isLocal"] = A.load.Bool(ptr + 12 + 12); 1017 } else { 1018 delete x["metadata"]["isLocal"]; 1019 } 1020 if (A.load.Bool(ptr + 12 + 18)) { 1021 x["metadata"]["isCached"] = A.load.Bool(ptr + 12 + 13); 1022 } else { 1023 delete x["metadata"]["isCached"]; 1024 } 1025 if (A.load.Bool(ptr + 12 + 19)) { 1026 x["metadata"]["isMigratable"] = A.load.Bool(ptr + 12 + 14); 1027 } else { 1028 delete x["metadata"]["isMigratable"]; 1029 } 1030 if (A.load.Bool(ptr + 12 + 20)) { 1031 x["metadata"]["isVirtualCardEnrollmentEligible"] = A.load.Bool(ptr + 12 + 15); 1032 } else { 1033 delete x["metadata"]["isVirtualCardEnrollmentEligible"]; 1034 } 1035 if (A.load.Bool(ptr + 12 + 21)) { 1036 x["metadata"]["isVirtualCardEnrolled"] = A.load.Bool(ptr + 12 + 16); 1037 } else { 1038 delete x["metadata"]["isVirtualCardEnrolled"]; 1039 } 1040 } else { 1041 delete x["metadata"]; 1042 } 1043 return create === A.H.TRUE ? A.H.push(x) : ref; 1044 }, 1045 "has_AddVirtualCard": (): heap.Ref<boolean> => { 1046 if (WEBEXT?.autofillPrivate && "addVirtualCard" in WEBEXT?.autofillPrivate) { 1047 return A.H.TRUE; 1048 } 1049 return A.H.FALSE; 1050 }, 1051 "func_AddVirtualCard": (fn: Pointer): void => { 1052 A.store.Ref(fn, WEBEXT.autofillPrivate.addVirtualCard); 1053 }, 1054 "call_AddVirtualCard": (retPtr: Pointer, cardId: heap.Ref<object>): void => { 1055 const _ret = WEBEXT.autofillPrivate.addVirtualCard(A.H.get<object>(cardId)); 1056 }, 1057 "try_AddVirtualCard": (retPtr: Pointer, errPtr: Pointer, cardId: heap.Ref<object>): heap.Ref<boolean> => { 1058 try { 1059 const _ret = WEBEXT.autofillPrivate.addVirtualCard(A.H.get<object>(cardId)); 1060 return A.H.TRUE; 1061 } catch (err: any) { 1062 A.store.Ref(errPtr, err); 1063 return A.H.FALSE; 1064 } 1065 }, 1066 "has_AuthenticateUserAndFlipMandatoryAuthToggle": (): heap.Ref<boolean> => { 1067 if (WEBEXT?.autofillPrivate && "authenticateUserAndFlipMandatoryAuthToggle" in WEBEXT?.autofillPrivate) { 1068 return A.H.TRUE; 1069 } 1070 return A.H.FALSE; 1071 }, 1072 "func_AuthenticateUserAndFlipMandatoryAuthToggle": (fn: Pointer): void => { 1073 A.store.Ref(fn, WEBEXT.autofillPrivate.authenticateUserAndFlipMandatoryAuthToggle); 1074 }, 1075 "call_AuthenticateUserAndFlipMandatoryAuthToggle": (retPtr: Pointer): void => { 1076 const _ret = WEBEXT.autofillPrivate.authenticateUserAndFlipMandatoryAuthToggle(); 1077 }, 1078 "try_AuthenticateUserAndFlipMandatoryAuthToggle": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 1079 try { 1080 const _ret = WEBEXT.autofillPrivate.authenticateUserAndFlipMandatoryAuthToggle(); 1081 return A.H.TRUE; 1082 } catch (err: any) { 1083 A.store.Ref(errPtr, err); 1084 return A.H.FALSE; 1085 } 1086 }, 1087 "has_AuthenticateUserToEditLocalCard": (): heap.Ref<boolean> => { 1088 if (WEBEXT?.autofillPrivate && "authenticateUserToEditLocalCard" in WEBEXT?.autofillPrivate) { 1089 return A.H.TRUE; 1090 } 1091 return A.H.FALSE; 1092 }, 1093 "func_AuthenticateUserToEditLocalCard": (fn: Pointer): void => { 1094 A.store.Ref(fn, WEBEXT.autofillPrivate.authenticateUserToEditLocalCard); 1095 }, 1096 "call_AuthenticateUserToEditLocalCard": (retPtr: Pointer): void => { 1097 const _ret = WEBEXT.autofillPrivate.authenticateUserToEditLocalCard(); 1098 A.store.Ref(retPtr, _ret); 1099 }, 1100 "try_AuthenticateUserToEditLocalCard": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 1101 try { 1102 const _ret = WEBEXT.autofillPrivate.authenticateUserToEditLocalCard(); 1103 A.store.Ref(retPtr, _ret); 1104 return A.H.TRUE; 1105 } catch (err: any) { 1106 A.store.Ref(errPtr, err); 1107 return A.H.FALSE; 1108 } 1109 }, 1110 "has_CheckIfDeviceAuthAvailable": (): heap.Ref<boolean> => { 1111 if (WEBEXT?.autofillPrivate && "checkIfDeviceAuthAvailable" in WEBEXT?.autofillPrivate) { 1112 return A.H.TRUE; 1113 } 1114 return A.H.FALSE; 1115 }, 1116 "func_CheckIfDeviceAuthAvailable": (fn: Pointer): void => { 1117 A.store.Ref(fn, WEBEXT.autofillPrivate.checkIfDeviceAuthAvailable); 1118 }, 1119 "call_CheckIfDeviceAuthAvailable": (retPtr: Pointer): void => { 1120 const _ret = WEBEXT.autofillPrivate.checkIfDeviceAuthAvailable(); 1121 A.store.Ref(retPtr, _ret); 1122 }, 1123 "try_CheckIfDeviceAuthAvailable": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 1124 try { 1125 const _ret = WEBEXT.autofillPrivate.checkIfDeviceAuthAvailable(); 1126 A.store.Ref(retPtr, _ret); 1127 return A.H.TRUE; 1128 } catch (err: any) { 1129 A.store.Ref(errPtr, err); 1130 return A.H.FALSE; 1131 } 1132 }, 1133 "has_GetAccountInfo": (): heap.Ref<boolean> => { 1134 if (WEBEXT?.autofillPrivate && "getAccountInfo" in WEBEXT?.autofillPrivate) { 1135 return A.H.TRUE; 1136 } 1137 return A.H.FALSE; 1138 }, 1139 "func_GetAccountInfo": (fn: Pointer): void => { 1140 A.store.Ref(fn, WEBEXT.autofillPrivate.getAccountInfo); 1141 }, 1142 "call_GetAccountInfo": (retPtr: Pointer): void => { 1143 const _ret = WEBEXT.autofillPrivate.getAccountInfo(); 1144 A.store.Ref(retPtr, _ret); 1145 }, 1146 "try_GetAccountInfo": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 1147 try { 1148 const _ret = WEBEXT.autofillPrivate.getAccountInfo(); 1149 A.store.Ref(retPtr, _ret); 1150 return A.H.TRUE; 1151 } catch (err: any) { 1152 A.store.Ref(errPtr, err); 1153 return A.H.FALSE; 1154 } 1155 }, 1156 "has_GetAddressComponents": (): heap.Ref<boolean> => { 1157 if (WEBEXT?.autofillPrivate && "getAddressComponents" in WEBEXT?.autofillPrivate) { 1158 return A.H.TRUE; 1159 } 1160 return A.H.FALSE; 1161 }, 1162 "func_GetAddressComponents": (fn: Pointer): void => { 1163 A.store.Ref(fn, WEBEXT.autofillPrivate.getAddressComponents); 1164 }, 1165 "call_GetAddressComponents": (retPtr: Pointer, countryCode: heap.Ref<object>): void => { 1166 const _ret = WEBEXT.autofillPrivate.getAddressComponents(A.H.get<object>(countryCode)); 1167 A.store.Ref(retPtr, _ret); 1168 }, 1169 "try_GetAddressComponents": ( 1170 retPtr: Pointer, 1171 errPtr: Pointer, 1172 countryCode: heap.Ref<object> 1173 ): heap.Ref<boolean> => { 1174 try { 1175 const _ret = WEBEXT.autofillPrivate.getAddressComponents(A.H.get<object>(countryCode)); 1176 A.store.Ref(retPtr, _ret); 1177 return A.H.TRUE; 1178 } catch (err: any) { 1179 A.store.Ref(errPtr, err); 1180 return A.H.FALSE; 1181 } 1182 }, 1183 "has_GetAddressList": (): heap.Ref<boolean> => { 1184 if (WEBEXT?.autofillPrivate && "getAddressList" in WEBEXT?.autofillPrivate) { 1185 return A.H.TRUE; 1186 } 1187 return A.H.FALSE; 1188 }, 1189 "func_GetAddressList": (fn: Pointer): void => { 1190 A.store.Ref(fn, WEBEXT.autofillPrivate.getAddressList); 1191 }, 1192 "call_GetAddressList": (retPtr: Pointer): void => { 1193 const _ret = WEBEXT.autofillPrivate.getAddressList(); 1194 A.store.Ref(retPtr, _ret); 1195 }, 1196 "try_GetAddressList": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 1197 try { 1198 const _ret = WEBEXT.autofillPrivate.getAddressList(); 1199 A.store.Ref(retPtr, _ret); 1200 return A.H.TRUE; 1201 } catch (err: any) { 1202 A.store.Ref(errPtr, err); 1203 return A.H.FALSE; 1204 } 1205 }, 1206 "has_GetCountryList": (): heap.Ref<boolean> => { 1207 if (WEBEXT?.autofillPrivate && "getCountryList" in WEBEXT?.autofillPrivate) { 1208 return A.H.TRUE; 1209 } 1210 return A.H.FALSE; 1211 }, 1212 "func_GetCountryList": (fn: Pointer): void => { 1213 A.store.Ref(fn, WEBEXT.autofillPrivate.getCountryList); 1214 }, 1215 "call_GetCountryList": (retPtr: Pointer): void => { 1216 const _ret = WEBEXT.autofillPrivate.getCountryList(); 1217 A.store.Ref(retPtr, _ret); 1218 }, 1219 "try_GetCountryList": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 1220 try { 1221 const _ret = WEBEXT.autofillPrivate.getCountryList(); 1222 A.store.Ref(retPtr, _ret); 1223 return A.H.TRUE; 1224 } catch (err: any) { 1225 A.store.Ref(errPtr, err); 1226 return A.H.FALSE; 1227 } 1228 }, 1229 "has_GetCreditCardList": (): heap.Ref<boolean> => { 1230 if (WEBEXT?.autofillPrivate && "getCreditCardList" in WEBEXT?.autofillPrivate) { 1231 return A.H.TRUE; 1232 } 1233 return A.H.FALSE; 1234 }, 1235 "func_GetCreditCardList": (fn: Pointer): void => { 1236 A.store.Ref(fn, WEBEXT.autofillPrivate.getCreditCardList); 1237 }, 1238 "call_GetCreditCardList": (retPtr: Pointer): void => { 1239 const _ret = WEBEXT.autofillPrivate.getCreditCardList(); 1240 A.store.Ref(retPtr, _ret); 1241 }, 1242 "try_GetCreditCardList": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 1243 try { 1244 const _ret = WEBEXT.autofillPrivate.getCreditCardList(); 1245 A.store.Ref(retPtr, _ret); 1246 return A.H.TRUE; 1247 } catch (err: any) { 1248 A.store.Ref(errPtr, err); 1249 return A.H.FALSE; 1250 } 1251 }, 1252 "has_GetIbanList": (): heap.Ref<boolean> => { 1253 if (WEBEXT?.autofillPrivate && "getIbanList" in WEBEXT?.autofillPrivate) { 1254 return A.H.TRUE; 1255 } 1256 return A.H.FALSE; 1257 }, 1258 "func_GetIbanList": (fn: Pointer): void => { 1259 A.store.Ref(fn, WEBEXT.autofillPrivate.getIbanList); 1260 }, 1261 "call_GetIbanList": (retPtr: Pointer): void => { 1262 const _ret = WEBEXT.autofillPrivate.getIbanList(); 1263 A.store.Ref(retPtr, _ret); 1264 }, 1265 "try_GetIbanList": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 1266 try { 1267 const _ret = WEBEXT.autofillPrivate.getIbanList(); 1268 A.store.Ref(retPtr, _ret); 1269 return A.H.TRUE; 1270 } catch (err: any) { 1271 A.store.Ref(errPtr, err); 1272 return A.H.FALSE; 1273 } 1274 }, 1275 "has_IsValidIban": (): heap.Ref<boolean> => { 1276 if (WEBEXT?.autofillPrivate && "isValidIban" in WEBEXT?.autofillPrivate) { 1277 return A.H.TRUE; 1278 } 1279 return A.H.FALSE; 1280 }, 1281 "func_IsValidIban": (fn: Pointer): void => { 1282 A.store.Ref(fn, WEBEXT.autofillPrivate.isValidIban); 1283 }, 1284 "call_IsValidIban": (retPtr: Pointer, ibanValue: heap.Ref<object>): void => { 1285 const _ret = WEBEXT.autofillPrivate.isValidIban(A.H.get<object>(ibanValue)); 1286 A.store.Ref(retPtr, _ret); 1287 }, 1288 "try_IsValidIban": (retPtr: Pointer, errPtr: Pointer, ibanValue: heap.Ref<object>): heap.Ref<boolean> => { 1289 try { 1290 const _ret = WEBEXT.autofillPrivate.isValidIban(A.H.get<object>(ibanValue)); 1291 A.store.Ref(retPtr, _ret); 1292 return A.H.TRUE; 1293 } catch (err: any) { 1294 A.store.Ref(errPtr, err); 1295 return A.H.FALSE; 1296 } 1297 }, 1298 "has_LogServerCardLinkClicked": (): heap.Ref<boolean> => { 1299 if (WEBEXT?.autofillPrivate && "logServerCardLinkClicked" in WEBEXT?.autofillPrivate) { 1300 return A.H.TRUE; 1301 } 1302 return A.H.FALSE; 1303 }, 1304 "func_LogServerCardLinkClicked": (fn: Pointer): void => { 1305 A.store.Ref(fn, WEBEXT.autofillPrivate.logServerCardLinkClicked); 1306 }, 1307 "call_LogServerCardLinkClicked": (retPtr: Pointer): void => { 1308 const _ret = WEBEXT.autofillPrivate.logServerCardLinkClicked(); 1309 }, 1310 "try_LogServerCardLinkClicked": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 1311 try { 1312 const _ret = WEBEXT.autofillPrivate.logServerCardLinkClicked(); 1313 return A.H.TRUE; 1314 } catch (err: any) { 1315 A.store.Ref(errPtr, err); 1316 return A.H.FALSE; 1317 } 1318 }, 1319 "has_MaskCreditCard": (): heap.Ref<boolean> => { 1320 if (WEBEXT?.autofillPrivate && "maskCreditCard" in WEBEXT?.autofillPrivate) { 1321 return A.H.TRUE; 1322 } 1323 return A.H.FALSE; 1324 }, 1325 "func_MaskCreditCard": (fn: Pointer): void => { 1326 A.store.Ref(fn, WEBEXT.autofillPrivate.maskCreditCard); 1327 }, 1328 "call_MaskCreditCard": (retPtr: Pointer, guid: heap.Ref<object>): void => { 1329 const _ret = WEBEXT.autofillPrivate.maskCreditCard(A.H.get<object>(guid)); 1330 }, 1331 "try_MaskCreditCard": (retPtr: Pointer, errPtr: Pointer, guid: heap.Ref<object>): heap.Ref<boolean> => { 1332 try { 1333 const _ret = WEBEXT.autofillPrivate.maskCreditCard(A.H.get<object>(guid)); 1334 return A.H.TRUE; 1335 } catch (err: any) { 1336 A.store.Ref(errPtr, err); 1337 return A.H.FALSE; 1338 } 1339 }, 1340 "has_MigrateCreditCards": (): heap.Ref<boolean> => { 1341 if (WEBEXT?.autofillPrivate && "migrateCreditCards" in WEBEXT?.autofillPrivate) { 1342 return A.H.TRUE; 1343 } 1344 return A.H.FALSE; 1345 }, 1346 "func_MigrateCreditCards": (fn: Pointer): void => { 1347 A.store.Ref(fn, WEBEXT.autofillPrivate.migrateCreditCards); 1348 }, 1349 "call_MigrateCreditCards": (retPtr: Pointer): void => { 1350 const _ret = WEBEXT.autofillPrivate.migrateCreditCards(); 1351 }, 1352 "try_MigrateCreditCards": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 1353 try { 1354 const _ret = WEBEXT.autofillPrivate.migrateCreditCards(); 1355 return A.H.TRUE; 1356 } catch (err: any) { 1357 A.store.Ref(errPtr, err); 1358 return A.H.FALSE; 1359 } 1360 }, 1361 "has_OnPersonalDataChanged": (): heap.Ref<boolean> => { 1362 if ( 1363 WEBEXT?.autofillPrivate?.onPersonalDataChanged && 1364 "addListener" in WEBEXT?.autofillPrivate?.onPersonalDataChanged 1365 ) { 1366 return A.H.TRUE; 1367 } 1368 return A.H.FALSE; 1369 }, 1370 "func_OnPersonalDataChanged": (fn: Pointer): void => { 1371 A.store.Ref(fn, WEBEXT.autofillPrivate.onPersonalDataChanged.addListener); 1372 }, 1373 "call_OnPersonalDataChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1374 const _ret = WEBEXT.autofillPrivate.onPersonalDataChanged.addListener(A.H.get<object>(callback)); 1375 }, 1376 "try_OnPersonalDataChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1377 try { 1378 const _ret = WEBEXT.autofillPrivate.onPersonalDataChanged.addListener(A.H.get<object>(callback)); 1379 return A.H.TRUE; 1380 } catch (err: any) { 1381 A.store.Ref(errPtr, err); 1382 return A.H.FALSE; 1383 } 1384 }, 1385 "has_OffPersonalDataChanged": (): heap.Ref<boolean> => { 1386 if ( 1387 WEBEXT?.autofillPrivate?.onPersonalDataChanged && 1388 "removeListener" in WEBEXT?.autofillPrivate?.onPersonalDataChanged 1389 ) { 1390 return A.H.TRUE; 1391 } 1392 return A.H.FALSE; 1393 }, 1394 "func_OffPersonalDataChanged": (fn: Pointer): void => { 1395 A.store.Ref(fn, WEBEXT.autofillPrivate.onPersonalDataChanged.removeListener); 1396 }, 1397 "call_OffPersonalDataChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1398 const _ret = WEBEXT.autofillPrivate.onPersonalDataChanged.removeListener(A.H.get<object>(callback)); 1399 }, 1400 "try_OffPersonalDataChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1401 try { 1402 const _ret = WEBEXT.autofillPrivate.onPersonalDataChanged.removeListener(A.H.get<object>(callback)); 1403 return A.H.TRUE; 1404 } catch (err: any) { 1405 A.store.Ref(errPtr, err); 1406 return A.H.FALSE; 1407 } 1408 }, 1409 "has_HasOnPersonalDataChanged": (): heap.Ref<boolean> => { 1410 if ( 1411 WEBEXT?.autofillPrivate?.onPersonalDataChanged && 1412 "hasListener" in WEBEXT?.autofillPrivate?.onPersonalDataChanged 1413 ) { 1414 return A.H.TRUE; 1415 } 1416 return A.H.FALSE; 1417 }, 1418 "func_HasOnPersonalDataChanged": (fn: Pointer): void => { 1419 A.store.Ref(fn, WEBEXT.autofillPrivate.onPersonalDataChanged.hasListener); 1420 }, 1421 "call_HasOnPersonalDataChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1422 const _ret = WEBEXT.autofillPrivate.onPersonalDataChanged.hasListener(A.H.get<object>(callback)); 1423 A.store.Bool(retPtr, _ret); 1424 }, 1425 "try_HasOnPersonalDataChanged": ( 1426 retPtr: Pointer, 1427 errPtr: Pointer, 1428 callback: heap.Ref<object> 1429 ): heap.Ref<boolean> => { 1430 try { 1431 const _ret = WEBEXT.autofillPrivate.onPersonalDataChanged.hasListener(A.H.get<object>(callback)); 1432 A.store.Bool(retPtr, _ret); 1433 return A.H.TRUE; 1434 } catch (err: any) { 1435 A.store.Ref(errPtr, err); 1436 return A.H.FALSE; 1437 } 1438 }, 1439 "has_RemoveEntry": (): heap.Ref<boolean> => { 1440 if (WEBEXT?.autofillPrivate && "removeEntry" in WEBEXT?.autofillPrivate) { 1441 return A.H.TRUE; 1442 } 1443 return A.H.FALSE; 1444 }, 1445 "func_RemoveEntry": (fn: Pointer): void => { 1446 A.store.Ref(fn, WEBEXT.autofillPrivate.removeEntry); 1447 }, 1448 "call_RemoveEntry": (retPtr: Pointer, guid: heap.Ref<object>): void => { 1449 const _ret = WEBEXT.autofillPrivate.removeEntry(A.H.get<object>(guid)); 1450 }, 1451 "try_RemoveEntry": (retPtr: Pointer, errPtr: Pointer, guid: heap.Ref<object>): heap.Ref<boolean> => { 1452 try { 1453 const _ret = WEBEXT.autofillPrivate.removeEntry(A.H.get<object>(guid)); 1454 return A.H.TRUE; 1455 } catch (err: any) { 1456 A.store.Ref(errPtr, err); 1457 return A.H.FALSE; 1458 } 1459 }, 1460 "has_RemoveVirtualCard": (): heap.Ref<boolean> => { 1461 if (WEBEXT?.autofillPrivate && "removeVirtualCard" in WEBEXT?.autofillPrivate) { 1462 return A.H.TRUE; 1463 } 1464 return A.H.FALSE; 1465 }, 1466 "func_RemoveVirtualCard": (fn: Pointer): void => { 1467 A.store.Ref(fn, WEBEXT.autofillPrivate.removeVirtualCard); 1468 }, 1469 "call_RemoveVirtualCard": (retPtr: Pointer, cardId: heap.Ref<object>): void => { 1470 const _ret = WEBEXT.autofillPrivate.removeVirtualCard(A.H.get<object>(cardId)); 1471 }, 1472 "try_RemoveVirtualCard": (retPtr: Pointer, errPtr: Pointer, cardId: heap.Ref<object>): heap.Ref<boolean> => { 1473 try { 1474 const _ret = WEBEXT.autofillPrivate.removeVirtualCard(A.H.get<object>(cardId)); 1475 return A.H.TRUE; 1476 } catch (err: any) { 1477 A.store.Ref(errPtr, err); 1478 return A.H.FALSE; 1479 } 1480 }, 1481 "has_SaveAddress": (): heap.Ref<boolean> => { 1482 if (WEBEXT?.autofillPrivate && "saveAddress" in WEBEXT?.autofillPrivate) { 1483 return A.H.TRUE; 1484 } 1485 return A.H.FALSE; 1486 }, 1487 "func_SaveAddress": (fn: Pointer): void => { 1488 A.store.Ref(fn, WEBEXT.autofillPrivate.saveAddress); 1489 }, 1490 "call_SaveAddress": (retPtr: Pointer, address: Pointer): void => { 1491 const address_ffi = {}; 1492 1493 address_ffi["guid"] = A.load.Ref(address + 0, undefined); 1494 address_ffi["fields"] = A.load.Ref(address + 4, undefined); 1495 address_ffi["languageCode"] = A.load.Ref(address + 8, undefined); 1496 if (A.load.Bool(address + 12 + 22)) { 1497 address_ffi["metadata"] = {}; 1498 address_ffi["metadata"]["summaryLabel"] = A.load.Ref(address + 12 + 0, undefined); 1499 address_ffi["metadata"]["summarySublabel"] = A.load.Ref(address + 12 + 4, undefined); 1500 address_ffi["metadata"]["source"] = A.load.Enum(address + 12 + 8, ["LOCAL_OR_SYNCABLE", "ACCOUNT"]); 1501 if (A.load.Bool(address + 12 + 17)) { 1502 address_ffi["metadata"]["isLocal"] = A.load.Bool(address + 12 + 12); 1503 } 1504 if (A.load.Bool(address + 12 + 18)) { 1505 address_ffi["metadata"]["isCached"] = A.load.Bool(address + 12 + 13); 1506 } 1507 if (A.load.Bool(address + 12 + 19)) { 1508 address_ffi["metadata"]["isMigratable"] = A.load.Bool(address + 12 + 14); 1509 } 1510 if (A.load.Bool(address + 12 + 20)) { 1511 address_ffi["metadata"]["isVirtualCardEnrollmentEligible"] = A.load.Bool(address + 12 + 15); 1512 } 1513 if (A.load.Bool(address + 12 + 21)) { 1514 address_ffi["metadata"]["isVirtualCardEnrolled"] = A.load.Bool(address + 12 + 16); 1515 } 1516 } 1517 1518 const _ret = WEBEXT.autofillPrivate.saveAddress(address_ffi); 1519 }, 1520 "try_SaveAddress": (retPtr: Pointer, errPtr: Pointer, address: Pointer): heap.Ref<boolean> => { 1521 try { 1522 const address_ffi = {}; 1523 1524 address_ffi["guid"] = A.load.Ref(address + 0, undefined); 1525 address_ffi["fields"] = A.load.Ref(address + 4, undefined); 1526 address_ffi["languageCode"] = A.load.Ref(address + 8, undefined); 1527 if (A.load.Bool(address + 12 + 22)) { 1528 address_ffi["metadata"] = {}; 1529 address_ffi["metadata"]["summaryLabel"] = A.load.Ref(address + 12 + 0, undefined); 1530 address_ffi["metadata"]["summarySublabel"] = A.load.Ref(address + 12 + 4, undefined); 1531 address_ffi["metadata"]["source"] = A.load.Enum(address + 12 + 8, ["LOCAL_OR_SYNCABLE", "ACCOUNT"]); 1532 if (A.load.Bool(address + 12 + 17)) { 1533 address_ffi["metadata"]["isLocal"] = A.load.Bool(address + 12 + 12); 1534 } 1535 if (A.load.Bool(address + 12 + 18)) { 1536 address_ffi["metadata"]["isCached"] = A.load.Bool(address + 12 + 13); 1537 } 1538 if (A.load.Bool(address + 12 + 19)) { 1539 address_ffi["metadata"]["isMigratable"] = A.load.Bool(address + 12 + 14); 1540 } 1541 if (A.load.Bool(address + 12 + 20)) { 1542 address_ffi["metadata"]["isVirtualCardEnrollmentEligible"] = A.load.Bool(address + 12 + 15); 1543 } 1544 if (A.load.Bool(address + 12 + 21)) { 1545 address_ffi["metadata"]["isVirtualCardEnrolled"] = A.load.Bool(address + 12 + 16); 1546 } 1547 } 1548 1549 const _ret = WEBEXT.autofillPrivate.saveAddress(address_ffi); 1550 return A.H.TRUE; 1551 } catch (err: any) { 1552 A.store.Ref(errPtr, err); 1553 return A.H.FALSE; 1554 } 1555 }, 1556 "has_SaveCreditCard": (): heap.Ref<boolean> => { 1557 if (WEBEXT?.autofillPrivate && "saveCreditCard" in WEBEXT?.autofillPrivate) { 1558 return A.H.TRUE; 1559 } 1560 return A.H.FALSE; 1561 }, 1562 "func_SaveCreditCard": (fn: Pointer): void => { 1563 A.store.Ref(fn, WEBEXT.autofillPrivate.saveCreditCard); 1564 }, 1565 "call_SaveCreditCard": (retPtr: Pointer, card: Pointer): void => { 1566 const card_ffi = {}; 1567 1568 card_ffi["guid"] = A.load.Ref(card + 0, undefined); 1569 card_ffi["name"] = A.load.Ref(card + 4, undefined); 1570 card_ffi["cardNumber"] = A.load.Ref(card + 8, undefined); 1571 card_ffi["expirationMonth"] = A.load.Ref(card + 12, undefined); 1572 card_ffi["expirationYear"] = A.load.Ref(card + 16, undefined); 1573 card_ffi["nickname"] = A.load.Ref(card + 20, undefined); 1574 card_ffi["network"] = A.load.Ref(card + 24, undefined); 1575 card_ffi["imageSrc"] = A.load.Ref(card + 28, undefined); 1576 if (A.load.Bool(card + 32 + 22)) { 1577 card_ffi["metadata"] = {}; 1578 card_ffi["metadata"]["summaryLabel"] = A.load.Ref(card + 32 + 0, undefined); 1579 card_ffi["metadata"]["summarySublabel"] = A.load.Ref(card + 32 + 4, undefined); 1580 card_ffi["metadata"]["source"] = A.load.Enum(card + 32 + 8, ["LOCAL_OR_SYNCABLE", "ACCOUNT"]); 1581 if (A.load.Bool(card + 32 + 17)) { 1582 card_ffi["metadata"]["isLocal"] = A.load.Bool(card + 32 + 12); 1583 } 1584 if (A.load.Bool(card + 32 + 18)) { 1585 card_ffi["metadata"]["isCached"] = A.load.Bool(card + 32 + 13); 1586 } 1587 if (A.load.Bool(card + 32 + 19)) { 1588 card_ffi["metadata"]["isMigratable"] = A.load.Bool(card + 32 + 14); 1589 } 1590 if (A.load.Bool(card + 32 + 20)) { 1591 card_ffi["metadata"]["isVirtualCardEnrollmentEligible"] = A.load.Bool(card + 32 + 15); 1592 } 1593 if (A.load.Bool(card + 32 + 21)) { 1594 card_ffi["metadata"]["isVirtualCardEnrolled"] = A.load.Bool(card + 32 + 16); 1595 } 1596 } 1597 1598 const _ret = WEBEXT.autofillPrivate.saveCreditCard(card_ffi); 1599 }, 1600 "try_SaveCreditCard": (retPtr: Pointer, errPtr: Pointer, card: Pointer): heap.Ref<boolean> => { 1601 try { 1602 const card_ffi = {}; 1603 1604 card_ffi["guid"] = A.load.Ref(card + 0, undefined); 1605 card_ffi["name"] = A.load.Ref(card + 4, undefined); 1606 card_ffi["cardNumber"] = A.load.Ref(card + 8, undefined); 1607 card_ffi["expirationMonth"] = A.load.Ref(card + 12, undefined); 1608 card_ffi["expirationYear"] = A.load.Ref(card + 16, undefined); 1609 card_ffi["nickname"] = A.load.Ref(card + 20, undefined); 1610 card_ffi["network"] = A.load.Ref(card + 24, undefined); 1611 card_ffi["imageSrc"] = A.load.Ref(card + 28, undefined); 1612 if (A.load.Bool(card + 32 + 22)) { 1613 card_ffi["metadata"] = {}; 1614 card_ffi["metadata"]["summaryLabel"] = A.load.Ref(card + 32 + 0, undefined); 1615 card_ffi["metadata"]["summarySublabel"] = A.load.Ref(card + 32 + 4, undefined); 1616 card_ffi["metadata"]["source"] = A.load.Enum(card + 32 + 8, ["LOCAL_OR_SYNCABLE", "ACCOUNT"]); 1617 if (A.load.Bool(card + 32 + 17)) { 1618 card_ffi["metadata"]["isLocal"] = A.load.Bool(card + 32 + 12); 1619 } 1620 if (A.load.Bool(card + 32 + 18)) { 1621 card_ffi["metadata"]["isCached"] = A.load.Bool(card + 32 + 13); 1622 } 1623 if (A.load.Bool(card + 32 + 19)) { 1624 card_ffi["metadata"]["isMigratable"] = A.load.Bool(card + 32 + 14); 1625 } 1626 if (A.load.Bool(card + 32 + 20)) { 1627 card_ffi["metadata"]["isVirtualCardEnrollmentEligible"] = A.load.Bool(card + 32 + 15); 1628 } 1629 if (A.load.Bool(card + 32 + 21)) { 1630 card_ffi["metadata"]["isVirtualCardEnrolled"] = A.load.Bool(card + 32 + 16); 1631 } 1632 } 1633 1634 const _ret = WEBEXT.autofillPrivate.saveCreditCard(card_ffi); 1635 return A.H.TRUE; 1636 } catch (err: any) { 1637 A.store.Ref(errPtr, err); 1638 return A.H.FALSE; 1639 } 1640 }, 1641 "has_SaveIban": (): heap.Ref<boolean> => { 1642 if (WEBEXT?.autofillPrivate && "saveIban" in WEBEXT?.autofillPrivate) { 1643 return A.H.TRUE; 1644 } 1645 return A.H.FALSE; 1646 }, 1647 "func_SaveIban": (fn: Pointer): void => { 1648 A.store.Ref(fn, WEBEXT.autofillPrivate.saveIban); 1649 }, 1650 "call_SaveIban": (retPtr: Pointer, iban: Pointer): void => { 1651 const iban_ffi = {}; 1652 1653 iban_ffi["guid"] = A.load.Ref(iban + 0, undefined); 1654 iban_ffi["value"] = A.load.Ref(iban + 4, undefined); 1655 iban_ffi["nickname"] = A.load.Ref(iban + 8, undefined); 1656 if (A.load.Bool(iban + 12 + 22)) { 1657 iban_ffi["metadata"] = {}; 1658 iban_ffi["metadata"]["summaryLabel"] = A.load.Ref(iban + 12 + 0, undefined); 1659 iban_ffi["metadata"]["summarySublabel"] = A.load.Ref(iban + 12 + 4, undefined); 1660 iban_ffi["metadata"]["source"] = A.load.Enum(iban + 12 + 8, ["LOCAL_OR_SYNCABLE", "ACCOUNT"]); 1661 if (A.load.Bool(iban + 12 + 17)) { 1662 iban_ffi["metadata"]["isLocal"] = A.load.Bool(iban + 12 + 12); 1663 } 1664 if (A.load.Bool(iban + 12 + 18)) { 1665 iban_ffi["metadata"]["isCached"] = A.load.Bool(iban + 12 + 13); 1666 } 1667 if (A.load.Bool(iban + 12 + 19)) { 1668 iban_ffi["metadata"]["isMigratable"] = A.load.Bool(iban + 12 + 14); 1669 } 1670 if (A.load.Bool(iban + 12 + 20)) { 1671 iban_ffi["metadata"]["isVirtualCardEnrollmentEligible"] = A.load.Bool(iban + 12 + 15); 1672 } 1673 if (A.load.Bool(iban + 12 + 21)) { 1674 iban_ffi["metadata"]["isVirtualCardEnrolled"] = A.load.Bool(iban + 12 + 16); 1675 } 1676 } 1677 1678 const _ret = WEBEXT.autofillPrivate.saveIban(iban_ffi); 1679 }, 1680 "try_SaveIban": (retPtr: Pointer, errPtr: Pointer, iban: Pointer): heap.Ref<boolean> => { 1681 try { 1682 const iban_ffi = {}; 1683 1684 iban_ffi["guid"] = A.load.Ref(iban + 0, undefined); 1685 iban_ffi["value"] = A.load.Ref(iban + 4, undefined); 1686 iban_ffi["nickname"] = A.load.Ref(iban + 8, undefined); 1687 if (A.load.Bool(iban + 12 + 22)) { 1688 iban_ffi["metadata"] = {}; 1689 iban_ffi["metadata"]["summaryLabel"] = A.load.Ref(iban + 12 + 0, undefined); 1690 iban_ffi["metadata"]["summarySublabel"] = A.load.Ref(iban + 12 + 4, undefined); 1691 iban_ffi["metadata"]["source"] = A.load.Enum(iban + 12 + 8, ["LOCAL_OR_SYNCABLE", "ACCOUNT"]); 1692 if (A.load.Bool(iban + 12 + 17)) { 1693 iban_ffi["metadata"]["isLocal"] = A.load.Bool(iban + 12 + 12); 1694 } 1695 if (A.load.Bool(iban + 12 + 18)) { 1696 iban_ffi["metadata"]["isCached"] = A.load.Bool(iban + 12 + 13); 1697 } 1698 if (A.load.Bool(iban + 12 + 19)) { 1699 iban_ffi["metadata"]["isMigratable"] = A.load.Bool(iban + 12 + 14); 1700 } 1701 if (A.load.Bool(iban + 12 + 20)) { 1702 iban_ffi["metadata"]["isVirtualCardEnrollmentEligible"] = A.load.Bool(iban + 12 + 15); 1703 } 1704 if (A.load.Bool(iban + 12 + 21)) { 1705 iban_ffi["metadata"]["isVirtualCardEnrolled"] = A.load.Bool(iban + 12 + 16); 1706 } 1707 } 1708 1709 const _ret = WEBEXT.autofillPrivate.saveIban(iban_ffi); 1710 return A.H.TRUE; 1711 } catch (err: any) { 1712 A.store.Ref(errPtr, err); 1713 return A.H.FALSE; 1714 } 1715 }, 1716 "has_SetCreditCardFIDOAuthEnabledState": (): heap.Ref<boolean> => { 1717 if (WEBEXT?.autofillPrivate && "setCreditCardFIDOAuthEnabledState" in WEBEXT?.autofillPrivate) { 1718 return A.H.TRUE; 1719 } 1720 return A.H.FALSE; 1721 }, 1722 "func_SetCreditCardFIDOAuthEnabledState": (fn: Pointer): void => { 1723 A.store.Ref(fn, WEBEXT.autofillPrivate.setCreditCardFIDOAuthEnabledState); 1724 }, 1725 "call_SetCreditCardFIDOAuthEnabledState": (retPtr: Pointer, enabled: heap.Ref<boolean>): void => { 1726 const _ret = WEBEXT.autofillPrivate.setCreditCardFIDOAuthEnabledState(enabled === A.H.TRUE); 1727 }, 1728 "try_SetCreditCardFIDOAuthEnabledState": ( 1729 retPtr: Pointer, 1730 errPtr: Pointer, 1731 enabled: heap.Ref<boolean> 1732 ): heap.Ref<boolean> => { 1733 try { 1734 const _ret = WEBEXT.autofillPrivate.setCreditCardFIDOAuthEnabledState(enabled === A.H.TRUE); 1735 return A.H.TRUE; 1736 } catch (err: any) { 1737 A.store.Ref(errPtr, err); 1738 return A.H.FALSE; 1739 } 1740 }, 1741 }; 1742 });