github.com/primecitizens/pcz/std@v0.2.1/plat/js/webext/filemanagerprivate/bindings/ffi_bindings.ts (about) 1 import { importModule, Application, heap, Pointer } from "@ffi"; 2 3 importModule("plat/js/webext/filemanagerprivate", (A: Application) => { 4 const WEBEXT = typeof globalThis.browser === "undefined" ? globalThis.chrome : globalThis.browser; 5 6 return { 7 "store_IconSet": (ptr: Pointer, ref: heap.Ref<any>) => { 8 const x = A.H.get<any>(ref); 9 10 if (typeof x === "undefined") { 11 A.store.Bool(ptr + 8, false); 12 A.store.Ref(ptr + 0, undefined); 13 A.store.Ref(ptr + 4, undefined); 14 } else { 15 A.store.Bool(ptr + 8, true); 16 A.store.Ref(ptr + 0, x["icon16x16Url"]); 17 A.store.Ref(ptr + 4, x["icon32x32Url"]); 18 } 19 }, 20 "load_IconSet": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 21 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 22 23 x["icon16x16Url"] = A.load.Ref(ptr + 0, undefined); 24 x["icon32x32Url"] = A.load.Ref(ptr + 4, undefined); 25 return create === A.H.TRUE ? A.H.push(x) : ref; 26 }, 27 28 "store_AndroidApp": (ptr: Pointer, ref: heap.Ref<any>) => { 29 const x = A.H.get<any>(ref); 30 31 if (typeof x === "undefined") { 32 A.store.Bool(ptr + 21, false); 33 A.store.Ref(ptr + 0, undefined); 34 A.store.Ref(ptr + 4, undefined); 35 A.store.Ref(ptr + 8, undefined); 36 37 A.store.Bool(ptr + 12 + 8, false); 38 A.store.Ref(ptr + 12 + 0, undefined); 39 A.store.Ref(ptr + 12 + 4, undefined); 40 } else { 41 A.store.Bool(ptr + 21, true); 42 A.store.Ref(ptr + 0, x["name"]); 43 A.store.Ref(ptr + 4, x["packageName"]); 44 A.store.Ref(ptr + 8, x["activityName"]); 45 46 if (typeof x["iconSet"] === "undefined") { 47 A.store.Bool(ptr + 12 + 8, false); 48 A.store.Ref(ptr + 12 + 0, undefined); 49 A.store.Ref(ptr + 12 + 4, undefined); 50 } else { 51 A.store.Bool(ptr + 12 + 8, true); 52 A.store.Ref(ptr + 12 + 0, x["iconSet"]["icon16x16Url"]); 53 A.store.Ref(ptr + 12 + 4, x["iconSet"]["icon32x32Url"]); 54 } 55 } 56 }, 57 "load_AndroidApp": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 58 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 59 60 x["name"] = A.load.Ref(ptr + 0, undefined); 61 x["packageName"] = A.load.Ref(ptr + 4, undefined); 62 x["activityName"] = A.load.Ref(ptr + 8, undefined); 63 if (A.load.Bool(ptr + 12 + 8)) { 64 x["iconSet"] = {}; 65 x["iconSet"]["icon16x16Url"] = A.load.Ref(ptr + 12 + 0, undefined); 66 x["iconSet"]["icon32x32Url"] = A.load.Ref(ptr + 12 + 4, undefined); 67 } else { 68 delete x["iconSet"]; 69 } 70 return create === A.H.TRUE ? A.H.push(x) : ref; 71 }, 72 73 "store_AttachedImages": (ptr: Pointer, ref: heap.Ref<any>) => { 74 const x = A.H.get<any>(ref); 75 76 if (typeof x === "undefined") { 77 A.store.Bool(ptr + 8, false); 78 A.store.Ref(ptr + 0, undefined); 79 A.store.Ref(ptr + 4, undefined); 80 } else { 81 A.store.Bool(ptr + 8, true); 82 A.store.Ref(ptr + 0, x["data"]); 83 A.store.Ref(ptr + 4, x["type"]); 84 } 85 }, 86 "load_AttachedImages": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 87 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 88 89 x["data"] = A.load.Ref(ptr + 0, undefined); 90 x["type"] = A.load.Ref(ptr + 4, undefined); 91 return create === A.H.TRUE ? A.H.push(x) : ref; 92 }, 93 "constof_BulkPinStage": (ref: heap.Ref<string>): number => { 94 const idx = [ 95 "stopped", 96 "paused_offline", 97 "paused_battery_saver", 98 "getting_free_space", 99 "listing_files", 100 "syncing", 101 "success", 102 "not_enough_space", 103 "cannot_get_free_space", 104 "cannot_list_files", 105 "cannot_enable_docs_offline", 106 ].indexOf(A.H.get(ref)); 107 return idx < 0 ? 0 : idx + 1; 108 }, 109 110 "store_BulkPinProgress": (ptr: Pointer, ref: heap.Ref<any>) => { 111 const x = A.H.get<any>(ref); 112 113 if (typeof x === "undefined") { 114 A.store.Bool(ptr + 65, false); 115 A.store.Enum(ptr + 0, -1); 116 A.store.Bool(ptr + 57, false); 117 A.store.Float64(ptr + 8, 0); 118 A.store.Bool(ptr + 58, false); 119 A.store.Float64(ptr + 16, 0); 120 A.store.Bool(ptr + 59, false); 121 A.store.Float64(ptr + 24, 0); 122 A.store.Bool(ptr + 60, false); 123 A.store.Float64(ptr + 32, 0); 124 A.store.Bool(ptr + 61, false); 125 A.store.Int32(ptr + 40, 0); 126 A.store.Bool(ptr + 62, false); 127 A.store.Int32(ptr + 44, 0); 128 A.store.Bool(ptr + 63, false); 129 A.store.Float64(ptr + 48, 0); 130 A.store.Bool(ptr + 64, false); 131 A.store.Bool(ptr + 56, false); 132 } else { 133 A.store.Bool(ptr + 65, true); 134 A.store.Enum( 135 ptr + 0, 136 [ 137 "stopped", 138 "paused_offline", 139 "paused_battery_saver", 140 "getting_free_space", 141 "listing_files", 142 "syncing", 143 "success", 144 "not_enough_space", 145 "cannot_get_free_space", 146 "cannot_list_files", 147 "cannot_enable_docs_offline", 148 ].indexOf(x["stage"] as string) 149 ); 150 A.store.Bool(ptr + 57, "freeSpaceBytes" in x ? true : false); 151 A.store.Float64(ptr + 8, x["freeSpaceBytes"] === undefined ? 0 : (x["freeSpaceBytes"] as number)); 152 A.store.Bool(ptr + 58, "requiredSpaceBytes" in x ? true : false); 153 A.store.Float64(ptr + 16, x["requiredSpaceBytes"] === undefined ? 0 : (x["requiredSpaceBytes"] as number)); 154 A.store.Bool(ptr + 59, "bytesToPin" in x ? true : false); 155 A.store.Float64(ptr + 24, x["bytesToPin"] === undefined ? 0 : (x["bytesToPin"] as number)); 156 A.store.Bool(ptr + 60, "pinnedBytes" in x ? true : false); 157 A.store.Float64(ptr + 32, x["pinnedBytes"] === undefined ? 0 : (x["pinnedBytes"] as number)); 158 A.store.Bool(ptr + 61, "filesToPin" in x ? true : false); 159 A.store.Int32(ptr + 40, x["filesToPin"] === undefined ? 0 : (x["filesToPin"] as number)); 160 A.store.Bool(ptr + 62, "listedFiles" in x ? true : false); 161 A.store.Int32(ptr + 44, x["listedFiles"] === undefined ? 0 : (x["listedFiles"] as number)); 162 A.store.Bool(ptr + 63, "remainingSeconds" in x ? true : false); 163 A.store.Float64(ptr + 48, x["remainingSeconds"] === undefined ? 0 : (x["remainingSeconds"] as number)); 164 A.store.Bool(ptr + 64, "emptiedQueue" in x ? true : false); 165 A.store.Bool(ptr + 56, x["emptiedQueue"] ? true : false); 166 } 167 }, 168 "load_BulkPinProgress": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 169 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 170 171 x["stage"] = A.load.Enum(ptr + 0, [ 172 "stopped", 173 "paused_offline", 174 "paused_battery_saver", 175 "getting_free_space", 176 "listing_files", 177 "syncing", 178 "success", 179 "not_enough_space", 180 "cannot_get_free_space", 181 "cannot_list_files", 182 "cannot_enable_docs_offline", 183 ]); 184 if (A.load.Bool(ptr + 57)) { 185 x["freeSpaceBytes"] = A.load.Float64(ptr + 8); 186 } else { 187 delete x["freeSpaceBytes"]; 188 } 189 if (A.load.Bool(ptr + 58)) { 190 x["requiredSpaceBytes"] = A.load.Float64(ptr + 16); 191 } else { 192 delete x["requiredSpaceBytes"]; 193 } 194 if (A.load.Bool(ptr + 59)) { 195 x["bytesToPin"] = A.load.Float64(ptr + 24); 196 } else { 197 delete x["bytesToPin"]; 198 } 199 if (A.load.Bool(ptr + 60)) { 200 x["pinnedBytes"] = A.load.Float64(ptr + 32); 201 } else { 202 delete x["pinnedBytes"]; 203 } 204 if (A.load.Bool(ptr + 61)) { 205 x["filesToPin"] = A.load.Int32(ptr + 40); 206 } else { 207 delete x["filesToPin"]; 208 } 209 if (A.load.Bool(ptr + 62)) { 210 x["listedFiles"] = A.load.Int32(ptr + 44); 211 } else { 212 delete x["listedFiles"]; 213 } 214 if (A.load.Bool(ptr + 63)) { 215 x["remainingSeconds"] = A.load.Float64(ptr + 48); 216 } else { 217 delete x["remainingSeconds"]; 218 } 219 if (A.load.Bool(ptr + 64)) { 220 x["emptiedQueue"] = A.load.Bool(ptr + 56); 221 } else { 222 delete x["emptiedQueue"]; 223 } 224 return create === A.H.TRUE ? A.H.push(x) : ref; 225 }, 226 "constof_ChangeType": (ref: heap.Ref<string>): number => { 227 const idx = ["add_or_update", "delete"].indexOf(A.H.get(ref)); 228 return idx < 0 ? 0 : idx + 1; 229 }, 230 231 "store_ConflictPauseParams": (ptr: Pointer, ref: heap.Ref<any>) => { 232 const x = A.H.get<any>(ref); 233 234 if (typeof x === "undefined") { 235 A.store.Bool(ptr + 14, false); 236 A.store.Ref(ptr + 0, undefined); 237 A.store.Bool(ptr + 12, false); 238 A.store.Bool(ptr + 4, false); 239 A.store.Bool(ptr + 13, false); 240 A.store.Bool(ptr + 5, false); 241 A.store.Ref(ptr + 8, undefined); 242 } else { 243 A.store.Bool(ptr + 14, true); 244 A.store.Ref(ptr + 0, x["conflictName"]); 245 A.store.Bool(ptr + 12, "conflictIsDirectory" in x ? true : false); 246 A.store.Bool(ptr + 4, x["conflictIsDirectory"] ? true : false); 247 A.store.Bool(ptr + 13, "conflictMultiple" in x ? true : false); 248 A.store.Bool(ptr + 5, x["conflictMultiple"] ? true : false); 249 A.store.Ref(ptr + 8, x["conflictTargetUrl"]); 250 } 251 }, 252 "load_ConflictPauseParams": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 253 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 254 255 x["conflictName"] = A.load.Ref(ptr + 0, undefined); 256 if (A.load.Bool(ptr + 12)) { 257 x["conflictIsDirectory"] = A.load.Bool(ptr + 4); 258 } else { 259 delete x["conflictIsDirectory"]; 260 } 261 if (A.load.Bool(ptr + 13)) { 262 x["conflictMultiple"] = A.load.Bool(ptr + 5); 263 } else { 264 delete x["conflictMultiple"]; 265 } 266 x["conflictTargetUrl"] = A.load.Ref(ptr + 8, undefined); 267 return create === A.H.TRUE ? A.H.push(x) : ref; 268 }, 269 270 "store_ConflictResumeParams": (ptr: Pointer, ref: heap.Ref<any>) => { 271 const x = A.H.get<any>(ref); 272 273 if (typeof x === "undefined") { 274 A.store.Bool(ptr + 6, false); 275 A.store.Ref(ptr + 0, undefined); 276 A.store.Bool(ptr + 5, false); 277 A.store.Bool(ptr + 4, false); 278 } else { 279 A.store.Bool(ptr + 6, true); 280 A.store.Ref(ptr + 0, x["conflictResolve"]); 281 A.store.Bool(ptr + 5, "conflictApplyToAll" in x ? true : false); 282 A.store.Bool(ptr + 4, x["conflictApplyToAll"] ? true : false); 283 } 284 }, 285 "load_ConflictResumeParams": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 286 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 287 288 x["conflictResolve"] = A.load.Ref(ptr + 0, undefined); 289 if (A.load.Bool(ptr + 5)) { 290 x["conflictApplyToAll"] = A.load.Bool(ptr + 4); 291 } else { 292 delete x["conflictApplyToAll"]; 293 } 294 return create === A.H.TRUE ? A.H.push(x) : ref; 295 }, 296 "constof_CrostiniEventType": (ref: heap.Ref<string>): number => { 297 const idx = ["enable", "disable", "share", "unshare", "drop_failed_plugin_vm_directory_not_shared"].indexOf( 298 A.H.get(ref) 299 ); 300 return idx < 0 ? 0 : idx + 1; 301 }, 302 303 "store_CrostiniEvent": (ptr: Pointer, ref: heap.Ref<any>) => { 304 const x = A.H.get<any>(ref); 305 306 if (typeof x === "undefined") { 307 A.store.Bool(ptr + 16, false); 308 A.store.Enum(ptr + 0, -1); 309 A.store.Ref(ptr + 4, undefined); 310 A.store.Ref(ptr + 8, undefined); 311 A.store.Ref(ptr + 12, undefined); 312 } else { 313 A.store.Bool(ptr + 16, true); 314 A.store.Enum( 315 ptr + 0, 316 ["enable", "disable", "share", "unshare", "drop_failed_plugin_vm_directory_not_shared"].indexOf( 317 x["eventType"] as string 318 ) 319 ); 320 A.store.Ref(ptr + 4, x["vmName"]); 321 A.store.Ref(ptr + 8, x["containerName"]); 322 A.store.Ref(ptr + 12, x["entries"]); 323 } 324 }, 325 "load_CrostiniEvent": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 326 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 327 328 x["eventType"] = A.load.Enum(ptr + 0, [ 329 "enable", 330 "disable", 331 "share", 332 "unshare", 333 "drop_failed_plugin_vm_directory_not_shared", 334 ]); 335 x["vmName"] = A.load.Ref(ptr + 4, undefined); 336 x["containerName"] = A.load.Ref(ptr + 8, undefined); 337 x["entries"] = A.load.Ref(ptr + 12, undefined); 338 return create === A.H.TRUE ? A.H.push(x) : ref; 339 }, 340 "constof_DeviceConnectionState": (ref: heap.Ref<string>): number => { 341 const idx = ["OFFLINE", "ONLINE"].indexOf(A.H.get(ref)); 342 return idx < 0 ? 0 : idx + 1; 343 }, 344 "constof_DeviceEventType": (ref: heap.Ref<string>): number => { 345 const idx = [ 346 "disabled", 347 "removed", 348 "hard_unplugged", 349 "format_start", 350 "format_success", 351 "format_fail", 352 "rename_start", 353 "rename_success", 354 "rename_fail", 355 "partition_start", 356 "partition_success", 357 "partition_fail", 358 ].indexOf(A.H.get(ref)); 359 return idx < 0 ? 0 : idx + 1; 360 }, 361 362 "store_DeviceEvent": (ptr: Pointer, ref: heap.Ref<any>) => { 363 const x = A.H.get<any>(ref); 364 365 if (typeof x === "undefined") { 366 A.store.Bool(ptr + 12, false); 367 A.store.Enum(ptr + 0, -1); 368 A.store.Ref(ptr + 4, undefined); 369 A.store.Ref(ptr + 8, undefined); 370 } else { 371 A.store.Bool(ptr + 12, true); 372 A.store.Enum( 373 ptr + 0, 374 [ 375 "disabled", 376 "removed", 377 "hard_unplugged", 378 "format_start", 379 "format_success", 380 "format_fail", 381 "rename_start", 382 "rename_success", 383 "rename_fail", 384 "partition_start", 385 "partition_success", 386 "partition_fail", 387 ].indexOf(x["type"] as string) 388 ); 389 A.store.Ref(ptr + 4, x["devicePath"]); 390 A.store.Ref(ptr + 8, x["deviceLabel"]); 391 } 392 }, 393 "load_DeviceEvent": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 394 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 395 396 x["type"] = A.load.Enum(ptr + 0, [ 397 "disabled", 398 "removed", 399 "hard_unplugged", 400 "format_start", 401 "format_success", 402 "format_fail", 403 "rename_start", 404 "rename_success", 405 "rename_fail", 406 "partition_start", 407 "partition_success", 408 "partition_fail", 409 ]); 410 x["devicePath"] = A.load.Ref(ptr + 4, undefined); 411 x["deviceLabel"] = A.load.Ref(ptr + 8, undefined); 412 return create === A.H.TRUE ? A.H.push(x) : ref; 413 }, 414 "constof_DeviceType": (ref: heap.Ref<string>): number => { 415 const idx = ["usb", "sd", "optical", "mobile", "unknown"].indexOf(A.H.get(ref)); 416 return idx < 0 ? 0 : idx + 1; 417 }, 418 "constof_VolumeType": (ref: heap.Ref<string>): number => { 419 const idx = [ 420 "drive", 421 "downloads", 422 "removable", 423 "archive", 424 "provided", 425 "mtp", 426 "media_view", 427 "crostini", 428 "android_files", 429 "documents_provider", 430 "testing", 431 "smb", 432 "system_internal", 433 "guest_os", 434 ].indexOf(A.H.get(ref)); 435 return idx < 0 ? 0 : idx + 1; 436 }, 437 438 "store_DialogCallerInformation": (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.Ref(ptr + 0, undefined); 444 A.store.Enum(ptr + 4, -1); 445 } else { 446 A.store.Bool(ptr + 8, true); 447 A.store.Ref(ptr + 0, x["url"]); 448 A.store.Enum( 449 ptr + 4, 450 [ 451 "drive", 452 "downloads", 453 "removable", 454 "archive", 455 "provided", 456 "mtp", 457 "media_view", 458 "crostini", 459 "android_files", 460 "documents_provider", 461 "testing", 462 "smb", 463 "system_internal", 464 "guest_os", 465 ].indexOf(x["component"] as string) 466 ); 467 } 468 }, 469 "load_DialogCallerInformation": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 470 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 471 472 x["url"] = A.load.Ref(ptr + 0, undefined); 473 x["component"] = A.load.Enum(ptr + 4, [ 474 "drive", 475 "downloads", 476 "removable", 477 "archive", 478 "provided", 479 "mtp", 480 "media_view", 481 "crostini", 482 "android_files", 483 "documents_provider", 484 "testing", 485 "smb", 486 "system_internal", 487 "guest_os", 488 ]); 489 return create === A.H.TRUE ? A.H.push(x) : ref; 490 }, 491 "constof_DlpLevel": (ref: heap.Ref<string>): number => { 492 const idx = ["report", "warn", "block", "allow"].indexOf(A.H.get(ref)); 493 return idx < 0 ? 0 : idx + 1; 494 }, 495 496 "store_DlpMetadata": (ptr: Pointer, ref: heap.Ref<any>) => { 497 const x = A.H.get<any>(ref); 498 499 if (typeof x === "undefined") { 500 A.store.Bool(ptr + 8, false); 501 A.store.Ref(ptr + 0, undefined); 502 A.store.Bool(ptr + 6, false); 503 A.store.Bool(ptr + 4, false); 504 A.store.Bool(ptr + 7, false); 505 A.store.Bool(ptr + 5, false); 506 } else { 507 A.store.Bool(ptr + 8, true); 508 A.store.Ref(ptr + 0, x["sourceUrl"]); 509 A.store.Bool(ptr + 6, "isDlpRestricted" in x ? true : false); 510 A.store.Bool(ptr + 4, x["isDlpRestricted"] ? true : false); 511 A.store.Bool(ptr + 7, "isRestrictedForDestination" in x ? true : false); 512 A.store.Bool(ptr + 5, x["isRestrictedForDestination"] ? true : false); 513 } 514 }, 515 "load_DlpMetadata": (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["sourceUrl"] = A.load.Ref(ptr + 0, undefined); 519 if (A.load.Bool(ptr + 6)) { 520 x["isDlpRestricted"] = A.load.Bool(ptr + 4); 521 } else { 522 delete x["isDlpRestricted"]; 523 } 524 if (A.load.Bool(ptr + 7)) { 525 x["isRestrictedForDestination"] = A.load.Bool(ptr + 5); 526 } else { 527 delete x["isRestrictedForDestination"]; 528 } 529 return create === A.H.TRUE ? A.H.push(x) : ref; 530 }, 531 532 "store_DlpRestrictionDetails": (ptr: Pointer, ref: heap.Ref<any>) => { 533 const x = A.H.get<any>(ref); 534 535 if (typeof x === "undefined") { 536 A.store.Bool(ptr + 12, false); 537 A.store.Enum(ptr + 0, -1); 538 A.store.Ref(ptr + 4, undefined); 539 A.store.Ref(ptr + 8, undefined); 540 } else { 541 A.store.Bool(ptr + 12, true); 542 A.store.Enum(ptr + 0, ["report", "warn", "block", "allow"].indexOf(x["level"] as string)); 543 A.store.Ref(ptr + 4, x["urls"]); 544 A.store.Ref(ptr + 8, x["components"]); 545 } 546 }, 547 "load_DlpRestrictionDetails": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 548 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 549 550 x["level"] = A.load.Enum(ptr + 0, ["report", "warn", "block", "allow"]); 551 x["urls"] = A.load.Ref(ptr + 4, undefined); 552 x["components"] = A.load.Ref(ptr + 8, undefined); 553 return create === A.H.TRUE ? A.H.push(x) : ref; 554 }, 555 "constof_DriveConfirmDialogType": (ref: heap.Ref<string>): number => { 556 const idx = ["enable_docs_offline"].indexOf(A.H.get(ref)); 557 return idx < 0 ? 0 : idx + 1; 558 }, 559 560 "store_DriveConfirmDialogEvent": (ptr: Pointer, ref: heap.Ref<any>) => { 561 const x = A.H.get<any>(ref); 562 563 if (typeof x === "undefined") { 564 A.store.Bool(ptr + 8, false); 565 A.store.Enum(ptr + 0, -1); 566 A.store.Ref(ptr + 4, undefined); 567 } else { 568 A.store.Bool(ptr + 8, true); 569 A.store.Enum(ptr + 0, ["enable_docs_offline"].indexOf(x["type"] as string)); 570 A.store.Ref(ptr + 4, x["fileUrl"]); 571 } 572 }, 573 "load_DriveConfirmDialogEvent": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 574 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 575 576 x["type"] = A.load.Enum(ptr + 0, ["enable_docs_offline"]); 577 x["fileUrl"] = A.load.Ref(ptr + 4, undefined); 578 return create === A.H.TRUE ? A.H.push(x) : ref; 579 }, 580 "constof_DriveConnectionStateType": (ref: heap.Ref<string>): number => { 581 const idx = ["OFFLINE", "METERED", "ONLINE"].indexOf(A.H.get(ref)); 582 return idx < 0 ? 0 : idx + 1; 583 }, 584 "constof_DriveOfflineReason": (ref: heap.Ref<string>): number => { 585 const idx = ["NOT_READY", "NO_NETWORK", "NO_SERVICE"].indexOf(A.H.get(ref)); 586 return idx < 0 ? 0 : idx + 1; 587 }, 588 589 "store_DriveConnectionState": (ptr: Pointer, ref: heap.Ref<any>) => { 590 const x = A.H.get<any>(ref); 591 592 if (typeof x === "undefined") { 593 A.store.Bool(ptr + 8, false); 594 A.store.Enum(ptr + 0, -1); 595 A.store.Enum(ptr + 4, -1); 596 } else { 597 A.store.Bool(ptr + 8, true); 598 A.store.Enum(ptr + 0, ["OFFLINE", "METERED", "ONLINE"].indexOf(x["type"] as string)); 599 A.store.Enum(ptr + 4, ["NOT_READY", "NO_NETWORK", "NO_SERVICE"].indexOf(x["reason"] as string)); 600 } 601 }, 602 "load_DriveConnectionState": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 603 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 604 605 x["type"] = A.load.Enum(ptr + 0, ["OFFLINE", "METERED", "ONLINE"]); 606 x["reason"] = A.load.Enum(ptr + 4, ["NOT_READY", "NO_NETWORK", "NO_SERVICE"]); 607 return create === A.H.TRUE ? A.H.push(x) : ref; 608 }, 609 "constof_DriveDialogResult": (ref: heap.Ref<string>): number => { 610 const idx = ["not_displayed", "accept", "reject", "dismiss"].indexOf(A.H.get(ref)); 611 return idx < 0 ? 0 : idx + 1; 612 }, 613 614 "store_DriveMetadataSearchResult": (ptr: Pointer, ref: heap.Ref<any>) => { 615 const x = A.H.get<any>(ref); 616 617 if (typeof x === "undefined") { 618 A.store.Bool(ptr + 10, false); 619 A.store.Ref(ptr + 0, undefined); 620 A.store.Ref(ptr + 4, undefined); 621 A.store.Bool(ptr + 9, false); 622 A.store.Bool(ptr + 8, false); 623 } else { 624 A.store.Bool(ptr + 10, true); 625 A.store.Ref(ptr + 0, x["entry"]); 626 A.store.Ref(ptr + 4, x["highlightedBaseName"]); 627 A.store.Bool(ptr + 9, "availableOffline" in x ? true : false); 628 A.store.Bool(ptr + 8, x["availableOffline"] ? true : false); 629 } 630 }, 631 "load_DriveMetadataSearchResult": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 632 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 633 634 x["entry"] = A.load.Ref(ptr + 0, undefined); 635 x["highlightedBaseName"] = A.load.Ref(ptr + 4, undefined); 636 if (A.load.Bool(ptr + 9)) { 637 x["availableOffline"] = A.load.Bool(ptr + 8); 638 } else { 639 delete x["availableOffline"]; 640 } 641 return create === A.H.TRUE ? A.H.push(x) : ref; 642 }, 643 "constof_UserType": (ref: heap.Ref<string>): number => { 644 const idx = ["unmanaged", "organization"].indexOf(A.H.get(ref)); 645 return idx < 0 ? 0 : idx + 1; 646 }, 647 648 "store_DriveQuotaMetadata": (ptr: Pointer, ref: heap.Ref<any>) => { 649 const x = A.H.get<any>(ref); 650 651 if (typeof x === "undefined") { 652 A.store.Bool(ptr + 35, false); 653 A.store.Enum(ptr + 0, -1); 654 A.store.Bool(ptr + 32, false); 655 A.store.Float64(ptr + 8, 0); 656 A.store.Bool(ptr + 33, false); 657 A.store.Float64(ptr + 16, 0); 658 A.store.Bool(ptr + 34, false); 659 A.store.Bool(ptr + 24, false); 660 A.store.Ref(ptr + 28, undefined); 661 } else { 662 A.store.Bool(ptr + 35, true); 663 A.store.Enum(ptr + 0, ["unmanaged", "organization"].indexOf(x["userType"] as string)); 664 A.store.Bool(ptr + 32, "usedBytes" in x ? true : false); 665 A.store.Float64(ptr + 8, x["usedBytes"] === undefined ? 0 : (x["usedBytes"] as number)); 666 A.store.Bool(ptr + 33, "totalBytes" in x ? true : false); 667 A.store.Float64(ptr + 16, x["totalBytes"] === undefined ? 0 : (x["totalBytes"] as number)); 668 A.store.Bool(ptr + 34, "organizationLimitExceeded" in x ? true : false); 669 A.store.Bool(ptr + 24, x["organizationLimitExceeded"] ? true : false); 670 A.store.Ref(ptr + 28, x["organizationName"]); 671 } 672 }, 673 "load_DriveQuotaMetadata": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 674 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 675 676 x["userType"] = A.load.Enum(ptr + 0, ["unmanaged", "organization"]); 677 if (A.load.Bool(ptr + 32)) { 678 x["usedBytes"] = A.load.Float64(ptr + 8); 679 } else { 680 delete x["usedBytes"]; 681 } 682 if (A.load.Bool(ptr + 33)) { 683 x["totalBytes"] = A.load.Float64(ptr + 16); 684 } else { 685 delete x["totalBytes"]; 686 } 687 if (A.load.Bool(ptr + 34)) { 688 x["organizationLimitExceeded"] = A.load.Bool(ptr + 24); 689 } else { 690 delete x["organizationLimitExceeded"]; 691 } 692 x["organizationName"] = A.load.Ref(ptr + 28, undefined); 693 return create === A.H.TRUE ? A.H.push(x) : ref; 694 }, 695 "constof_DriveShareType": (ref: heap.Ref<string>): number => { 696 const idx = ["can_edit", "can_comment", "can_view"].indexOf(A.H.get(ref)); 697 return idx < 0 ? 0 : idx + 1; 698 }, 699 "constof_DriveSyncErrorType": (ref: heap.Ref<string>): number => { 700 const idx = [ 701 "delete_without_permission", 702 "service_unavailable", 703 "no_server_space", 704 "no_server_space_organization", 705 "no_local_space", 706 "no_shared_drive_space", 707 "misc", 708 ].indexOf(A.H.get(ref)); 709 return idx < 0 ? 0 : idx + 1; 710 }, 711 712 "store_DriveSyncErrorEvent": (ptr: Pointer, ref: heap.Ref<any>) => { 713 const x = A.H.get<any>(ref); 714 715 if (typeof x === "undefined") { 716 A.store.Bool(ptr + 12, false); 717 A.store.Enum(ptr + 0, -1); 718 A.store.Ref(ptr + 4, undefined); 719 A.store.Ref(ptr + 8, undefined); 720 } else { 721 A.store.Bool(ptr + 12, true); 722 A.store.Enum( 723 ptr + 0, 724 [ 725 "delete_without_permission", 726 "service_unavailable", 727 "no_server_space", 728 "no_server_space_organization", 729 "no_local_space", 730 "no_shared_drive_space", 731 "misc", 732 ].indexOf(x["type"] as string) 733 ); 734 A.store.Ref(ptr + 4, x["fileUrl"]); 735 A.store.Ref(ptr + 8, x["sharedDrive"]); 736 } 737 }, 738 "load_DriveSyncErrorEvent": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 739 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 740 741 x["type"] = A.load.Enum(ptr + 0, [ 742 "delete_without_permission", 743 "service_unavailable", 744 "no_server_space", 745 "no_server_space_organization", 746 "no_local_space", 747 "no_shared_drive_space", 748 "misc", 749 ]); 750 x["fileUrl"] = A.load.Ref(ptr + 4, undefined); 751 x["sharedDrive"] = A.load.Ref(ptr + 8, undefined); 752 return create === A.H.TRUE ? A.H.push(x) : ref; 753 }, 754 "constof_RecentDateBucket": (ref: heap.Ref<string>): number => { 755 const idx = [ 756 "today", 757 "yesterday", 758 "earlier_this_week", 759 "earlier_this_month", 760 "earlier_this_year", 761 "older", 762 ].indexOf(A.H.get(ref)); 763 return idx < 0 ? 0 : idx + 1; 764 }, 765 "constof_SyncStatus": (ref: heap.Ref<string>): number => { 766 const idx = ["not_found", "queued", "in_progress", "completed", "error"].indexOf(A.H.get(ref)); 767 return idx < 0 ? 0 : idx + 1; 768 }, 769 770 "store_EntryProperties": (ptr: Pointer, ref: heap.Ref<any>) => { 771 const x = A.H.get<any>(ref); 772 773 if (typeof x === "undefined") { 774 A.store.Bool(ptr + 140, false); 775 A.store.Bool(ptr + 113, false); 776 A.store.Float64(ptr + 0, 0); 777 A.store.Bool(ptr + 114, false); 778 A.store.Float64(ptr + 8, 0); 779 A.store.Bool(ptr + 115, false); 780 A.store.Float64(ptr + 16, 0); 781 A.store.Enum(ptr + 24, -1); 782 A.store.Ref(ptr + 28, undefined); 783 A.store.Ref(ptr + 32, undefined); 784 A.store.Bool(ptr + 116, false); 785 A.store.Int32(ptr + 36, 0); 786 A.store.Bool(ptr + 117, false); 787 A.store.Int32(ptr + 40, 0); 788 A.store.Bool(ptr + 118, false); 789 A.store.Int32(ptr + 44, 0); 790 A.store.Bool(ptr + 119, false); 791 A.store.Bool(ptr + 48, false); 792 A.store.Bool(ptr + 120, false); 793 A.store.Bool(ptr + 49, false); 794 A.store.Bool(ptr + 121, false); 795 A.store.Bool(ptr + 50, false); 796 A.store.Bool(ptr + 122, false); 797 A.store.Bool(ptr + 51, false); 798 A.store.Bool(ptr + 123, false); 799 A.store.Bool(ptr + 52, false); 800 A.store.Bool(ptr + 124, false); 801 A.store.Bool(ptr + 53, false); 802 A.store.Ref(ptr + 56, undefined); 803 A.store.Ref(ptr + 60, undefined); 804 A.store.Bool(ptr + 125, false); 805 A.store.Bool(ptr + 64, false); 806 A.store.Bool(ptr + 126, false); 807 A.store.Bool(ptr + 65, false); 808 A.store.Bool(ptr + 127, false); 809 A.store.Bool(ptr + 66, false); 810 A.store.Ref(ptr + 68, undefined); 811 A.store.Ref(ptr + 72, undefined); 812 A.store.Ref(ptr + 76, undefined); 813 A.store.Bool(ptr + 128, false); 814 A.store.Bool(ptr + 80, false); 815 A.store.Bool(ptr + 129, false); 816 A.store.Bool(ptr + 81, false); 817 A.store.Bool(ptr + 130, false); 818 A.store.Bool(ptr + 82, false); 819 A.store.Bool(ptr + 131, false); 820 A.store.Bool(ptr + 83, false); 821 A.store.Bool(ptr + 132, false); 822 A.store.Bool(ptr + 84, false); 823 A.store.Bool(ptr + 133, false); 824 A.store.Bool(ptr + 85, false); 825 A.store.Bool(ptr + 134, false); 826 A.store.Bool(ptr + 86, false); 827 A.store.Bool(ptr + 135, false); 828 A.store.Bool(ptr + 87, false); 829 A.store.Bool(ptr + 136, false); 830 A.store.Bool(ptr + 88, false); 831 A.store.Enum(ptr + 92, -1); 832 A.store.Bool(ptr + 137, false); 833 A.store.Float64(ptr + 96, 0); 834 A.store.Bool(ptr + 138, false); 835 A.store.Float64(ptr + 104, 0); 836 A.store.Bool(ptr + 139, false); 837 A.store.Bool(ptr + 112, false); 838 } else { 839 A.store.Bool(ptr + 140, true); 840 A.store.Bool(ptr + 113, "size" in x ? true : false); 841 A.store.Float64(ptr + 0, x["size"] === undefined ? 0 : (x["size"] as number)); 842 A.store.Bool(ptr + 114, "modificationTime" in x ? true : false); 843 A.store.Float64(ptr + 8, x["modificationTime"] === undefined ? 0 : (x["modificationTime"] as number)); 844 A.store.Bool(ptr + 115, "modificationByMeTime" in x ? true : false); 845 A.store.Float64(ptr + 16, x["modificationByMeTime"] === undefined ? 0 : (x["modificationByMeTime"] as number)); 846 A.store.Enum( 847 ptr + 24, 848 ["today", "yesterday", "earlier_this_week", "earlier_this_month", "earlier_this_year", "older"].indexOf( 849 x["recentDateBucket"] as string 850 ) 851 ); 852 A.store.Ref(ptr + 28, x["thumbnailUrl"]); 853 A.store.Ref(ptr + 32, x["croppedThumbnailUrl"]); 854 A.store.Bool(ptr + 116, "imageWidth" in x ? true : false); 855 A.store.Int32(ptr + 36, x["imageWidth"] === undefined ? 0 : (x["imageWidth"] as number)); 856 A.store.Bool(ptr + 117, "imageHeight" in x ? true : false); 857 A.store.Int32(ptr + 40, x["imageHeight"] === undefined ? 0 : (x["imageHeight"] as number)); 858 A.store.Bool(ptr + 118, "imageRotation" in x ? true : false); 859 A.store.Int32(ptr + 44, x["imageRotation"] === undefined ? 0 : (x["imageRotation"] as number)); 860 A.store.Bool(ptr + 119, "pinned" in x ? true : false); 861 A.store.Bool(ptr + 48, x["pinned"] ? true : false); 862 A.store.Bool(ptr + 120, "present" in x ? true : false); 863 A.store.Bool(ptr + 49, x["present"] ? true : false); 864 A.store.Bool(ptr + 121, "hosted" in x ? true : false); 865 A.store.Bool(ptr + 50, x["hosted"] ? true : false); 866 A.store.Bool(ptr + 122, "availableOffline" in x ? true : false); 867 A.store.Bool(ptr + 51, x["availableOffline"] ? true : false); 868 A.store.Bool(ptr + 123, "availableWhenMetered" in x ? true : false); 869 A.store.Bool(ptr + 52, x["availableWhenMetered"] ? true : false); 870 A.store.Bool(ptr + 124, "dirty" in x ? true : false); 871 A.store.Bool(ptr + 53, x["dirty"] ? true : false); 872 A.store.Ref(ptr + 56, x["customIconUrl"]); 873 A.store.Ref(ptr + 60, x["contentMimeType"]); 874 A.store.Bool(ptr + 125, "sharedWithMe" in x ? true : false); 875 A.store.Bool(ptr + 64, x["sharedWithMe"] ? true : false); 876 A.store.Bool(ptr + 126, "shared" in x ? true : false); 877 A.store.Bool(ptr + 65, x["shared"] ? true : false); 878 A.store.Bool(ptr + 127, "starred" in x ? true : false); 879 A.store.Bool(ptr + 66, x["starred"] ? true : false); 880 A.store.Ref(ptr + 68, x["externalFileUrl"]); 881 A.store.Ref(ptr + 72, x["alternateUrl"]); 882 A.store.Ref(ptr + 76, x["shareUrl"]); 883 A.store.Bool(ptr + 128, "canCopy" in x ? true : false); 884 A.store.Bool(ptr + 80, x["canCopy"] ? true : false); 885 A.store.Bool(ptr + 129, "canDelete" in x ? true : false); 886 A.store.Bool(ptr + 81, x["canDelete"] ? true : false); 887 A.store.Bool(ptr + 130, "canRename" in x ? true : false); 888 A.store.Bool(ptr + 82, x["canRename"] ? true : false); 889 A.store.Bool(ptr + 131, "canAddChildren" in x ? true : false); 890 A.store.Bool(ptr + 83, x["canAddChildren"] ? true : false); 891 A.store.Bool(ptr + 132, "canShare" in x ? true : false); 892 A.store.Bool(ptr + 84, x["canShare"] ? true : false); 893 A.store.Bool(ptr + 133, "canPin" in x ? true : false); 894 A.store.Bool(ptr + 85, x["canPin"] ? true : false); 895 A.store.Bool(ptr + 134, "isMachineRoot" in x ? true : false); 896 A.store.Bool(ptr + 86, x["isMachineRoot"] ? true : false); 897 A.store.Bool(ptr + 135, "isExternalMedia" in x ? true : false); 898 A.store.Bool(ptr + 87, x["isExternalMedia"] ? true : false); 899 A.store.Bool(ptr + 136, "isArbitrarySyncFolder" in x ? true : false); 900 A.store.Bool(ptr + 88, x["isArbitrarySyncFolder"] ? true : false); 901 A.store.Enum( 902 ptr + 92, 903 ["not_found", "queued", "in_progress", "completed", "error"].indexOf(x["syncStatus"] as string) 904 ); 905 A.store.Bool(ptr + 137, "progress" in x ? true : false); 906 A.store.Float64(ptr + 96, x["progress"] === undefined ? 0 : (x["progress"] as number)); 907 A.store.Bool(ptr + 138, "syncCompletedTime" in x ? true : false); 908 A.store.Float64(ptr + 104, x["syncCompletedTime"] === undefined ? 0 : (x["syncCompletedTime"] as number)); 909 A.store.Bool(ptr + 139, "shortcut" in x ? true : false); 910 A.store.Bool(ptr + 112, x["shortcut"] ? true : false); 911 } 912 }, 913 "load_EntryProperties": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 914 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 915 916 if (A.load.Bool(ptr + 113)) { 917 x["size"] = A.load.Float64(ptr + 0); 918 } else { 919 delete x["size"]; 920 } 921 if (A.load.Bool(ptr + 114)) { 922 x["modificationTime"] = A.load.Float64(ptr + 8); 923 } else { 924 delete x["modificationTime"]; 925 } 926 if (A.load.Bool(ptr + 115)) { 927 x["modificationByMeTime"] = A.load.Float64(ptr + 16); 928 } else { 929 delete x["modificationByMeTime"]; 930 } 931 x["recentDateBucket"] = A.load.Enum(ptr + 24, [ 932 "today", 933 "yesterday", 934 "earlier_this_week", 935 "earlier_this_month", 936 "earlier_this_year", 937 "older", 938 ]); 939 x["thumbnailUrl"] = A.load.Ref(ptr + 28, undefined); 940 x["croppedThumbnailUrl"] = A.load.Ref(ptr + 32, undefined); 941 if (A.load.Bool(ptr + 116)) { 942 x["imageWidth"] = A.load.Int32(ptr + 36); 943 } else { 944 delete x["imageWidth"]; 945 } 946 if (A.load.Bool(ptr + 117)) { 947 x["imageHeight"] = A.load.Int32(ptr + 40); 948 } else { 949 delete x["imageHeight"]; 950 } 951 if (A.load.Bool(ptr + 118)) { 952 x["imageRotation"] = A.load.Int32(ptr + 44); 953 } else { 954 delete x["imageRotation"]; 955 } 956 if (A.load.Bool(ptr + 119)) { 957 x["pinned"] = A.load.Bool(ptr + 48); 958 } else { 959 delete x["pinned"]; 960 } 961 if (A.load.Bool(ptr + 120)) { 962 x["present"] = A.load.Bool(ptr + 49); 963 } else { 964 delete x["present"]; 965 } 966 if (A.load.Bool(ptr + 121)) { 967 x["hosted"] = A.load.Bool(ptr + 50); 968 } else { 969 delete x["hosted"]; 970 } 971 if (A.load.Bool(ptr + 122)) { 972 x["availableOffline"] = A.load.Bool(ptr + 51); 973 } else { 974 delete x["availableOffline"]; 975 } 976 if (A.load.Bool(ptr + 123)) { 977 x["availableWhenMetered"] = A.load.Bool(ptr + 52); 978 } else { 979 delete x["availableWhenMetered"]; 980 } 981 if (A.load.Bool(ptr + 124)) { 982 x["dirty"] = A.load.Bool(ptr + 53); 983 } else { 984 delete x["dirty"]; 985 } 986 x["customIconUrl"] = A.load.Ref(ptr + 56, undefined); 987 x["contentMimeType"] = A.load.Ref(ptr + 60, undefined); 988 if (A.load.Bool(ptr + 125)) { 989 x["sharedWithMe"] = A.load.Bool(ptr + 64); 990 } else { 991 delete x["sharedWithMe"]; 992 } 993 if (A.load.Bool(ptr + 126)) { 994 x["shared"] = A.load.Bool(ptr + 65); 995 } else { 996 delete x["shared"]; 997 } 998 if (A.load.Bool(ptr + 127)) { 999 x["starred"] = A.load.Bool(ptr + 66); 1000 } else { 1001 delete x["starred"]; 1002 } 1003 x["externalFileUrl"] = A.load.Ref(ptr + 68, undefined); 1004 x["alternateUrl"] = A.load.Ref(ptr + 72, undefined); 1005 x["shareUrl"] = A.load.Ref(ptr + 76, undefined); 1006 if (A.load.Bool(ptr + 128)) { 1007 x["canCopy"] = A.load.Bool(ptr + 80); 1008 } else { 1009 delete x["canCopy"]; 1010 } 1011 if (A.load.Bool(ptr + 129)) { 1012 x["canDelete"] = A.load.Bool(ptr + 81); 1013 } else { 1014 delete x["canDelete"]; 1015 } 1016 if (A.load.Bool(ptr + 130)) { 1017 x["canRename"] = A.load.Bool(ptr + 82); 1018 } else { 1019 delete x["canRename"]; 1020 } 1021 if (A.load.Bool(ptr + 131)) { 1022 x["canAddChildren"] = A.load.Bool(ptr + 83); 1023 } else { 1024 delete x["canAddChildren"]; 1025 } 1026 if (A.load.Bool(ptr + 132)) { 1027 x["canShare"] = A.load.Bool(ptr + 84); 1028 } else { 1029 delete x["canShare"]; 1030 } 1031 if (A.load.Bool(ptr + 133)) { 1032 x["canPin"] = A.load.Bool(ptr + 85); 1033 } else { 1034 delete x["canPin"]; 1035 } 1036 if (A.load.Bool(ptr + 134)) { 1037 x["isMachineRoot"] = A.load.Bool(ptr + 86); 1038 } else { 1039 delete x["isMachineRoot"]; 1040 } 1041 if (A.load.Bool(ptr + 135)) { 1042 x["isExternalMedia"] = A.load.Bool(ptr + 87); 1043 } else { 1044 delete x["isExternalMedia"]; 1045 } 1046 if (A.load.Bool(ptr + 136)) { 1047 x["isArbitrarySyncFolder"] = A.load.Bool(ptr + 88); 1048 } else { 1049 delete x["isArbitrarySyncFolder"]; 1050 } 1051 x["syncStatus"] = A.load.Enum(ptr + 92, ["not_found", "queued", "in_progress", "completed", "error"]); 1052 if (A.load.Bool(ptr + 137)) { 1053 x["progress"] = A.load.Float64(ptr + 96); 1054 } else { 1055 delete x["progress"]; 1056 } 1057 if (A.load.Bool(ptr + 138)) { 1058 x["syncCompletedTime"] = A.load.Float64(ptr + 104); 1059 } else { 1060 delete x["syncCompletedTime"]; 1061 } 1062 if (A.load.Bool(ptr + 139)) { 1063 x["shortcut"] = A.load.Bool(ptr + 112); 1064 } else { 1065 delete x["shortcut"]; 1066 } 1067 return create === A.H.TRUE ? A.H.push(x) : ref; 1068 }, 1069 "constof_EntryPropertyName": (ref: heap.Ref<string>): number => { 1070 const idx = [ 1071 "size", 1072 "modificationTime", 1073 "modificationByMeTime", 1074 "thumbnailUrl", 1075 "croppedThumbnailUrl", 1076 "imageWidth", 1077 "imageHeight", 1078 "imageRotation", 1079 "pinned", 1080 "present", 1081 "hosted", 1082 "availableOffline", 1083 "availableWhenMetered", 1084 "dirty", 1085 "customIconUrl", 1086 "contentMimeType", 1087 "sharedWithMe", 1088 "shared", 1089 "starred", 1090 "externalFileUrl", 1091 "alternateUrl", 1092 "shareUrl", 1093 "canCopy", 1094 "canDelete", 1095 "canRename", 1096 "canAddChildren", 1097 "canShare", 1098 "canPin", 1099 "isMachineRoot", 1100 "isExternalMedia", 1101 "isArbitrarySyncFolder", 1102 "syncStatus", 1103 "progress", 1104 "shortcut", 1105 "syncCompletedTime", 1106 ].indexOf(A.H.get(ref)); 1107 return idx < 0 ? 0 : idx + 1; 1108 }, 1109 "constof_TaskResult": (ref: heap.Ref<string>): number => { 1110 const idx = ["opened", "message_sent", "failed", "empty", "failed_plugin_vm_directory_not_shared"].indexOf( 1111 A.H.get(ref) 1112 ); 1113 return idx < 0 ? 0 : idx + 1; 1114 }, 1115 "constof_FileCategory": (ref: heap.Ref<string>): number => { 1116 const idx = ["all", "audio", "image", "video", "document"].indexOf(A.H.get(ref)); 1117 return idx < 0 ? 0 : idx + 1; 1118 }, 1119 1120 "store_FileChange": (ptr: Pointer, ref: heap.Ref<any>) => { 1121 const x = A.H.get<any>(ref); 1122 1123 if (typeof x === "undefined") { 1124 A.store.Bool(ptr + 8, false); 1125 A.store.Ref(ptr + 0, undefined); 1126 A.store.Ref(ptr + 4, undefined); 1127 } else { 1128 A.store.Bool(ptr + 8, true); 1129 A.store.Ref(ptr + 0, x["url"]); 1130 A.store.Ref(ptr + 4, x["changes"]); 1131 } 1132 }, 1133 "load_FileChange": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 1134 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 1135 1136 x["url"] = A.load.Ref(ptr + 0, undefined); 1137 x["changes"] = A.load.Ref(ptr + 4, undefined); 1138 return create === A.H.TRUE ? A.H.push(x) : ref; 1139 }, 1140 1141 "store_FileSystemProviderAction": (ptr: Pointer, ref: heap.Ref<any>) => { 1142 const x = A.H.get<any>(ref); 1143 1144 if (typeof x === "undefined") { 1145 A.store.Bool(ptr + 8, false); 1146 A.store.Ref(ptr + 0, undefined); 1147 A.store.Ref(ptr + 4, undefined); 1148 } else { 1149 A.store.Bool(ptr + 8, true); 1150 A.store.Ref(ptr + 0, x["id"]); 1151 A.store.Ref(ptr + 4, x["title"]); 1152 } 1153 }, 1154 "load_FileSystemProviderAction": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 1155 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 1156 1157 x["id"] = A.load.Ref(ptr + 0, undefined); 1158 x["title"] = A.load.Ref(ptr + 4, undefined); 1159 return create === A.H.TRUE ? A.H.push(x) : ref; 1160 }, 1161 1162 "store_FileTaskDescriptor": (ptr: Pointer, ref: heap.Ref<any>) => { 1163 const x = A.H.get<any>(ref); 1164 1165 if (typeof x === "undefined") { 1166 A.store.Bool(ptr + 12, false); 1167 A.store.Ref(ptr + 0, undefined); 1168 A.store.Ref(ptr + 4, undefined); 1169 A.store.Ref(ptr + 8, undefined); 1170 } else { 1171 A.store.Bool(ptr + 12, true); 1172 A.store.Ref(ptr + 0, x["appId"]); 1173 A.store.Ref(ptr + 4, x["taskType"]); 1174 A.store.Ref(ptr + 8, x["actionId"]); 1175 } 1176 }, 1177 "load_FileTaskDescriptor": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 1178 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 1179 1180 x["appId"] = A.load.Ref(ptr + 0, undefined); 1181 x["taskType"] = A.load.Ref(ptr + 4, undefined); 1182 x["actionId"] = A.load.Ref(ptr + 8, undefined); 1183 return create === A.H.TRUE ? A.H.push(x) : ref; 1184 }, 1185 1186 "store_FileTask": (ptr: Pointer, ref: heap.Ref<any>) => { 1187 const x = A.H.get<any>(ref); 1188 1189 if (typeof x === "undefined") { 1190 A.store.Bool(ptr + 30, false); 1191 1192 A.store.Bool(ptr + 0 + 12, false); 1193 A.store.Ref(ptr + 0 + 0, undefined); 1194 A.store.Ref(ptr + 0 + 4, undefined); 1195 A.store.Ref(ptr + 0 + 8, undefined); 1196 A.store.Ref(ptr + 16, undefined); 1197 A.store.Ref(ptr + 20, undefined); 1198 A.store.Bool(ptr + 27, false); 1199 A.store.Bool(ptr + 24, false); 1200 A.store.Bool(ptr + 28, false); 1201 A.store.Bool(ptr + 25, false); 1202 A.store.Bool(ptr + 29, false); 1203 A.store.Bool(ptr + 26, false); 1204 } else { 1205 A.store.Bool(ptr + 30, true); 1206 1207 if (typeof x["descriptor"] === "undefined") { 1208 A.store.Bool(ptr + 0 + 12, false); 1209 A.store.Ref(ptr + 0 + 0, undefined); 1210 A.store.Ref(ptr + 0 + 4, undefined); 1211 A.store.Ref(ptr + 0 + 8, undefined); 1212 } else { 1213 A.store.Bool(ptr + 0 + 12, true); 1214 A.store.Ref(ptr + 0 + 0, x["descriptor"]["appId"]); 1215 A.store.Ref(ptr + 0 + 4, x["descriptor"]["taskType"]); 1216 A.store.Ref(ptr + 0 + 8, x["descriptor"]["actionId"]); 1217 } 1218 A.store.Ref(ptr + 16, x["title"]); 1219 A.store.Ref(ptr + 20, x["iconUrl"]); 1220 A.store.Bool(ptr + 27, "isDefault" in x ? true : false); 1221 A.store.Bool(ptr + 24, x["isDefault"] ? true : false); 1222 A.store.Bool(ptr + 28, "isGenericFileHandler" in x ? true : false); 1223 A.store.Bool(ptr + 25, x["isGenericFileHandler"] ? true : false); 1224 A.store.Bool(ptr + 29, "isDlpBlocked" in x ? true : false); 1225 A.store.Bool(ptr + 26, x["isDlpBlocked"] ? true : false); 1226 } 1227 }, 1228 "load_FileTask": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 1229 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 1230 1231 if (A.load.Bool(ptr + 0 + 12)) { 1232 x["descriptor"] = {}; 1233 x["descriptor"]["appId"] = A.load.Ref(ptr + 0 + 0, undefined); 1234 x["descriptor"]["taskType"] = A.load.Ref(ptr + 0 + 4, undefined); 1235 x["descriptor"]["actionId"] = A.load.Ref(ptr + 0 + 8, undefined); 1236 } else { 1237 delete x["descriptor"]; 1238 } 1239 x["title"] = A.load.Ref(ptr + 16, undefined); 1240 x["iconUrl"] = A.load.Ref(ptr + 20, undefined); 1241 if (A.load.Bool(ptr + 27)) { 1242 x["isDefault"] = A.load.Bool(ptr + 24); 1243 } else { 1244 delete x["isDefault"]; 1245 } 1246 if (A.load.Bool(ptr + 28)) { 1247 x["isGenericFileHandler"] = A.load.Bool(ptr + 25); 1248 } else { 1249 delete x["isGenericFileHandler"]; 1250 } 1251 if (A.load.Bool(ptr + 29)) { 1252 x["isDlpBlocked"] = A.load.Bool(ptr + 26); 1253 } else { 1254 delete x["isDlpBlocked"]; 1255 } 1256 return create === A.H.TRUE ? A.H.push(x) : ref; 1257 }, 1258 "constof_TransferState": (ref: heap.Ref<string>): number => { 1259 const idx = ["in_progress", "queued", "completed", "failed"].indexOf(A.H.get(ref)); 1260 return idx < 0 ? 0 : idx + 1; 1261 }, 1262 1263 "store_FileTransferStatus": (ptr: Pointer, ref: heap.Ref<any>) => { 1264 const x = A.H.get<any>(ref); 1265 1266 if (typeof x === "undefined") { 1267 A.store.Bool(ptr + 35, false); 1268 A.store.Ref(ptr + 0, undefined); 1269 A.store.Enum(ptr + 4, -1); 1270 A.store.Bool(ptr + 30, false); 1271 A.store.Float64(ptr + 8, 0); 1272 A.store.Bool(ptr + 31, false); 1273 A.store.Float64(ptr + 16, 0); 1274 A.store.Bool(ptr + 32, false); 1275 A.store.Int32(ptr + 24, 0); 1276 A.store.Bool(ptr + 33, false); 1277 A.store.Bool(ptr + 28, false); 1278 A.store.Bool(ptr + 34, false); 1279 A.store.Bool(ptr + 29, false); 1280 } else { 1281 A.store.Bool(ptr + 35, true); 1282 A.store.Ref(ptr + 0, x["fileUrl"]); 1283 A.store.Enum(ptr + 4, ["in_progress", "queued", "completed", "failed"].indexOf(x["transferState"] as string)); 1284 A.store.Bool(ptr + 30, "processed" in x ? true : false); 1285 A.store.Float64(ptr + 8, x["processed"] === undefined ? 0 : (x["processed"] as number)); 1286 A.store.Bool(ptr + 31, "total" in x ? true : false); 1287 A.store.Float64(ptr + 16, x["total"] === undefined ? 0 : (x["total"] as number)); 1288 A.store.Bool(ptr + 32, "numTotalJobs" in x ? true : false); 1289 A.store.Int32(ptr + 24, x["numTotalJobs"] === undefined ? 0 : (x["numTotalJobs"] as number)); 1290 A.store.Bool(ptr + 33, "showNotification" in x ? true : false); 1291 A.store.Bool(ptr + 28, x["showNotification"] ? true : false); 1292 A.store.Bool(ptr + 34, "hideWhenZeroJobs" in x ? true : false); 1293 A.store.Bool(ptr + 29, x["hideWhenZeroJobs"] ? true : false); 1294 } 1295 }, 1296 "load_FileTransferStatus": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 1297 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 1298 1299 x["fileUrl"] = A.load.Ref(ptr + 0, undefined); 1300 x["transferState"] = A.load.Enum(ptr + 4, ["in_progress", "queued", "completed", "failed"]); 1301 if (A.load.Bool(ptr + 30)) { 1302 x["processed"] = A.load.Float64(ptr + 8); 1303 } else { 1304 delete x["processed"]; 1305 } 1306 if (A.load.Bool(ptr + 31)) { 1307 x["total"] = A.load.Float64(ptr + 16); 1308 } else { 1309 delete x["total"]; 1310 } 1311 if (A.load.Bool(ptr + 32)) { 1312 x["numTotalJobs"] = A.load.Int32(ptr + 24); 1313 } else { 1314 delete x["numTotalJobs"]; 1315 } 1316 if (A.load.Bool(ptr + 33)) { 1317 x["showNotification"] = A.load.Bool(ptr + 28); 1318 } else { 1319 delete x["showNotification"]; 1320 } 1321 if (A.load.Bool(ptr + 34)) { 1322 x["hideWhenZeroJobs"] = A.load.Bool(ptr + 29); 1323 } else { 1324 delete x["hideWhenZeroJobs"]; 1325 } 1326 return create === A.H.TRUE ? A.H.push(x) : ref; 1327 }, 1328 "constof_FileWatchEventType": (ref: heap.Ref<string>): number => { 1329 const idx = ["changed", "error"].indexOf(A.H.get(ref)); 1330 return idx < 0 ? 0 : idx + 1; 1331 }, 1332 1333 "store_FileWatchEvent": (ptr: Pointer, ref: heap.Ref<any>) => { 1334 const x = A.H.get<any>(ref); 1335 1336 if (typeof x === "undefined") { 1337 A.store.Bool(ptr + 12, false); 1338 A.store.Enum(ptr + 0, -1); 1339 A.store.Ref(ptr + 4, undefined); 1340 A.store.Ref(ptr + 8, undefined); 1341 } else { 1342 A.store.Bool(ptr + 12, true); 1343 A.store.Enum(ptr + 0, ["changed", "error"].indexOf(x["eventType"] as string)); 1344 A.store.Ref(ptr + 4, x["entry"]); 1345 A.store.Ref(ptr + 8, x["changedFiles"]); 1346 } 1347 }, 1348 "load_FileWatchEvent": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 1349 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 1350 1351 x["eventType"] = A.load.Enum(ptr + 0, ["changed", "error"]); 1352 x["entry"] = A.load.Ref(ptr + 4, undefined); 1353 x["changedFiles"] = A.load.Ref(ptr + 8, undefined); 1354 return create === A.H.TRUE ? A.H.push(x) : ref; 1355 }, 1356 "constof_FormatFileSystemType": (ref: heap.Ref<string>): number => { 1357 const idx = ["vfat", "exfat", "ntfs"].indexOf(A.H.get(ref)); 1358 return idx < 0 ? 0 : idx + 1; 1359 }, 1360 1361 "store_StreamInfo": (ptr: Pointer, ref: heap.Ref<any>) => { 1362 const x = A.H.get<any>(ref); 1363 1364 if (typeof x === "undefined") { 1365 A.store.Bool(ptr + 8, false); 1366 A.store.Ref(ptr + 0, undefined); 1367 A.store.Ref(ptr + 4, undefined); 1368 } else { 1369 A.store.Bool(ptr + 8, true); 1370 A.store.Ref(ptr + 0, x["type"]); 1371 A.store.Ref(ptr + 4, x["tags"]); 1372 } 1373 }, 1374 "load_StreamInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 1375 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 1376 1377 x["type"] = A.load.Ref(ptr + 0, undefined); 1378 x["tags"] = A.load.Ref(ptr + 4, undefined); 1379 return create === A.H.TRUE ? A.H.push(x) : ref; 1380 }, 1381 1382 "store_MediaMetadata": (ptr: Pointer, ref: heap.Ref<any>) => { 1383 const x = A.H.get<any>(ref); 1384 1385 if (typeof x === "undefined") { 1386 A.store.Bool(ptr + 78, false); 1387 A.store.Ref(ptr + 0, undefined); 1388 A.store.Bool(ptr + 72, false); 1389 A.store.Int32(ptr + 4, 0); 1390 A.store.Bool(ptr + 73, false); 1391 A.store.Int32(ptr + 8, 0); 1392 A.store.Bool(ptr + 74, false); 1393 A.store.Float64(ptr + 16, 0); 1394 A.store.Bool(ptr + 75, false); 1395 A.store.Int32(ptr + 24, 0); 1396 A.store.Ref(ptr + 28, undefined); 1397 A.store.Ref(ptr + 32, undefined); 1398 A.store.Ref(ptr + 36, undefined); 1399 A.store.Ref(ptr + 40, undefined); 1400 A.store.Bool(ptr + 76, false); 1401 A.store.Int32(ptr + 44, 0); 1402 A.store.Ref(ptr + 48, undefined); 1403 A.store.Ref(ptr + 52, undefined); 1404 A.store.Ref(ptr + 56, undefined); 1405 A.store.Bool(ptr + 77, false); 1406 A.store.Int32(ptr + 60, 0); 1407 A.store.Ref(ptr + 64, undefined); 1408 A.store.Ref(ptr + 68, undefined); 1409 } else { 1410 A.store.Bool(ptr + 78, true); 1411 A.store.Ref(ptr + 0, x["mimeType"]); 1412 A.store.Bool(ptr + 72, "height" in x ? true : false); 1413 A.store.Int32(ptr + 4, x["height"] === undefined ? 0 : (x["height"] as number)); 1414 A.store.Bool(ptr + 73, "width" in x ? true : false); 1415 A.store.Int32(ptr + 8, x["width"] === undefined ? 0 : (x["width"] as number)); 1416 A.store.Bool(ptr + 74, "duration" in x ? true : false); 1417 A.store.Float64(ptr + 16, x["duration"] === undefined ? 0 : (x["duration"] as number)); 1418 A.store.Bool(ptr + 75, "rotation" in x ? true : false); 1419 A.store.Int32(ptr + 24, x["rotation"] === undefined ? 0 : (x["rotation"] as number)); 1420 A.store.Ref(ptr + 28, x["album"]); 1421 A.store.Ref(ptr + 32, x["artist"]); 1422 A.store.Ref(ptr + 36, x["comment"]); 1423 A.store.Ref(ptr + 40, x["copyright"]); 1424 A.store.Bool(ptr + 76, "disc" in x ? true : false); 1425 A.store.Int32(ptr + 44, x["disc"] === undefined ? 0 : (x["disc"] as number)); 1426 A.store.Ref(ptr + 48, x["genre"]); 1427 A.store.Ref(ptr + 52, x["language"]); 1428 A.store.Ref(ptr + 56, x["title"]); 1429 A.store.Bool(ptr + 77, "track" in x ? true : false); 1430 A.store.Int32(ptr + 60, x["track"] === undefined ? 0 : (x["track"] as number)); 1431 A.store.Ref(ptr + 64, x["rawTags"]); 1432 A.store.Ref(ptr + 68, x["attachedImages"]); 1433 } 1434 }, 1435 "load_MediaMetadata": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 1436 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 1437 1438 x["mimeType"] = A.load.Ref(ptr + 0, undefined); 1439 if (A.load.Bool(ptr + 72)) { 1440 x["height"] = A.load.Int32(ptr + 4); 1441 } else { 1442 delete x["height"]; 1443 } 1444 if (A.load.Bool(ptr + 73)) { 1445 x["width"] = A.load.Int32(ptr + 8); 1446 } else { 1447 delete x["width"]; 1448 } 1449 if (A.load.Bool(ptr + 74)) { 1450 x["duration"] = A.load.Float64(ptr + 16); 1451 } else { 1452 delete x["duration"]; 1453 } 1454 if (A.load.Bool(ptr + 75)) { 1455 x["rotation"] = A.load.Int32(ptr + 24); 1456 } else { 1457 delete x["rotation"]; 1458 } 1459 x["album"] = A.load.Ref(ptr + 28, undefined); 1460 x["artist"] = A.load.Ref(ptr + 32, undefined); 1461 x["comment"] = A.load.Ref(ptr + 36, undefined); 1462 x["copyright"] = A.load.Ref(ptr + 40, undefined); 1463 if (A.load.Bool(ptr + 76)) { 1464 x["disc"] = A.load.Int32(ptr + 44); 1465 } else { 1466 delete x["disc"]; 1467 } 1468 x["genre"] = A.load.Ref(ptr + 48, undefined); 1469 x["language"] = A.load.Ref(ptr + 52, undefined); 1470 x["title"] = A.load.Ref(ptr + 56, undefined); 1471 if (A.load.Bool(ptr + 77)) { 1472 x["track"] = A.load.Int32(ptr + 60); 1473 } else { 1474 delete x["track"]; 1475 } 1476 x["rawTags"] = A.load.Ref(ptr + 64, undefined); 1477 x["attachedImages"] = A.load.Ref(ptr + 68, undefined); 1478 return create === A.H.TRUE ? A.H.push(x) : ref; 1479 }, 1480 "constof_PolicyDefaultHandlerStatus": (ref: heap.Ref<string>): number => { 1481 const idx = ["default_handler_assigned_by_policy", "incorrect_assignment"].indexOf(A.H.get(ref)); 1482 return idx < 0 ? 0 : idx + 1; 1483 }, 1484 1485 "store_ResultingTasks": (ptr: Pointer, ref: heap.Ref<any>) => { 1486 const x = A.H.get<any>(ref); 1487 1488 if (typeof x === "undefined") { 1489 A.store.Bool(ptr + 8, false); 1490 A.store.Ref(ptr + 0, undefined); 1491 A.store.Enum(ptr + 4, -1); 1492 } else { 1493 A.store.Bool(ptr + 8, true); 1494 A.store.Ref(ptr + 0, x["tasks"]); 1495 A.store.Enum( 1496 ptr + 4, 1497 ["default_handler_assigned_by_policy", "incorrect_assignment"].indexOf( 1498 x["policyDefaultHandlerStatus"] as string 1499 ) 1500 ); 1501 } 1502 }, 1503 "load_ResultingTasks": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 1504 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 1505 1506 x["tasks"] = A.load.Ref(ptr + 0, undefined); 1507 x["policyDefaultHandlerStatus"] = A.load.Enum(ptr + 4, [ 1508 "default_handler_assigned_by_policy", 1509 "incorrect_assignment", 1510 ]); 1511 return create === A.H.TRUE ? A.H.push(x) : ref; 1512 }, 1513 1514 "store_LinuxPackageInfo": (ptr: Pointer, ref: heap.Ref<any>) => { 1515 const x = A.H.get<any>(ref); 1516 1517 if (typeof x === "undefined") { 1518 A.store.Bool(ptr + 16, false); 1519 A.store.Ref(ptr + 0, undefined); 1520 A.store.Ref(ptr + 4, undefined); 1521 A.store.Ref(ptr + 8, undefined); 1522 A.store.Ref(ptr + 12, undefined); 1523 } else { 1524 A.store.Bool(ptr + 16, true); 1525 A.store.Ref(ptr + 0, x["name"]); 1526 A.store.Ref(ptr + 4, x["version"]); 1527 A.store.Ref(ptr + 8, x["summary"]); 1528 A.store.Ref(ptr + 12, x["description"]); 1529 } 1530 }, 1531 "load_LinuxPackageInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 1532 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 1533 1534 x["name"] = A.load.Ref(ptr + 0, undefined); 1535 x["version"] = A.load.Ref(ptr + 4, undefined); 1536 x["summary"] = A.load.Ref(ptr + 8, undefined); 1537 x["description"] = A.load.Ref(ptr + 12, undefined); 1538 return create === A.H.TRUE ? A.H.push(x) : ref; 1539 }, 1540 1541 "store_Preferences": (ptr: Pointer, ref: heap.Ref<any>) => { 1542 const x = A.H.get<any>(ref); 1543 1544 if (typeof x === "undefined") { 1545 A.store.Bool(ptr + 51, false); 1546 A.store.Bool(ptr + 41, false); 1547 A.store.Bool(ptr + 0, false); 1548 A.store.Bool(ptr + 42, false); 1549 A.store.Bool(ptr + 1, false); 1550 A.store.Bool(ptr + 43, false); 1551 A.store.Bool(ptr + 2, false); 1552 A.store.Bool(ptr + 44, false); 1553 A.store.Bool(ptr + 3, false); 1554 A.store.Ref(ptr + 4, undefined); 1555 A.store.Bool(ptr + 45, false); 1556 A.store.Bool(ptr + 8, false); 1557 A.store.Bool(ptr + 46, false); 1558 A.store.Bool(ptr + 9, false); 1559 A.store.Ref(ptr + 12, undefined); 1560 A.store.Bool(ptr + 47, false); 1561 A.store.Bool(ptr + 16, false); 1562 A.store.Bool(ptr + 48, false); 1563 A.store.Float64(ptr + 24, 0); 1564 A.store.Bool(ptr + 49, false); 1565 A.store.Float64(ptr + 32, 0); 1566 A.store.Bool(ptr + 50, false); 1567 A.store.Bool(ptr + 40, false); 1568 } else { 1569 A.store.Bool(ptr + 51, true); 1570 A.store.Bool(ptr + 41, "driveEnabled" in x ? true : false); 1571 A.store.Bool(ptr + 0, x["driveEnabled"] ? true : false); 1572 A.store.Bool(ptr + 42, "driveSyncEnabledOnMeteredNetwork" in x ? true : false); 1573 A.store.Bool(ptr + 1, x["driveSyncEnabledOnMeteredNetwork"] ? true : false); 1574 A.store.Bool(ptr + 43, "searchSuggestEnabled" in x ? true : false); 1575 A.store.Bool(ptr + 2, x["searchSuggestEnabled"] ? true : false); 1576 A.store.Bool(ptr + 44, "use24hourClock" in x ? true : false); 1577 A.store.Bool(ptr + 3, x["use24hourClock"] ? true : false); 1578 A.store.Ref(ptr + 4, x["timezone"]); 1579 A.store.Bool(ptr + 45, "arcEnabled" in x ? true : false); 1580 A.store.Bool(ptr + 8, x["arcEnabled"] ? true : false); 1581 A.store.Bool(ptr + 46, "arcRemovableMediaAccessEnabled" in x ? true : false); 1582 A.store.Bool(ptr + 9, x["arcRemovableMediaAccessEnabled"] ? true : false); 1583 A.store.Ref(ptr + 12, x["folderShortcuts"]); 1584 A.store.Bool(ptr + 47, "trashEnabled" in x ? true : false); 1585 A.store.Bool(ptr + 16, x["trashEnabled"] ? true : false); 1586 A.store.Bool(ptr + 48, "officeFileMovedOneDrive" in x ? true : false); 1587 A.store.Float64( 1588 ptr + 24, 1589 x["officeFileMovedOneDrive"] === undefined ? 0 : (x["officeFileMovedOneDrive"] as number) 1590 ); 1591 A.store.Bool(ptr + 49, "officeFileMovedGoogleDrive" in x ? true : false); 1592 A.store.Float64( 1593 ptr + 32, 1594 x["officeFileMovedGoogleDrive"] === undefined ? 0 : (x["officeFileMovedGoogleDrive"] as number) 1595 ); 1596 A.store.Bool(ptr + 50, "driveFsBulkPinningEnabled" in x ? true : false); 1597 A.store.Bool(ptr + 40, x["driveFsBulkPinningEnabled"] ? true : false); 1598 } 1599 }, 1600 "load_Preferences": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 1601 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 1602 1603 if (A.load.Bool(ptr + 41)) { 1604 x["driveEnabled"] = A.load.Bool(ptr + 0); 1605 } else { 1606 delete x["driveEnabled"]; 1607 } 1608 if (A.load.Bool(ptr + 42)) { 1609 x["driveSyncEnabledOnMeteredNetwork"] = A.load.Bool(ptr + 1); 1610 } else { 1611 delete x["driveSyncEnabledOnMeteredNetwork"]; 1612 } 1613 if (A.load.Bool(ptr + 43)) { 1614 x["searchSuggestEnabled"] = A.load.Bool(ptr + 2); 1615 } else { 1616 delete x["searchSuggestEnabled"]; 1617 } 1618 if (A.load.Bool(ptr + 44)) { 1619 x["use24hourClock"] = A.load.Bool(ptr + 3); 1620 } else { 1621 delete x["use24hourClock"]; 1622 } 1623 x["timezone"] = A.load.Ref(ptr + 4, undefined); 1624 if (A.load.Bool(ptr + 45)) { 1625 x["arcEnabled"] = A.load.Bool(ptr + 8); 1626 } else { 1627 delete x["arcEnabled"]; 1628 } 1629 if (A.load.Bool(ptr + 46)) { 1630 x["arcRemovableMediaAccessEnabled"] = A.load.Bool(ptr + 9); 1631 } else { 1632 delete x["arcRemovableMediaAccessEnabled"]; 1633 } 1634 x["folderShortcuts"] = A.load.Ref(ptr + 12, undefined); 1635 if (A.load.Bool(ptr + 47)) { 1636 x["trashEnabled"] = A.load.Bool(ptr + 16); 1637 } else { 1638 delete x["trashEnabled"]; 1639 } 1640 if (A.load.Bool(ptr + 48)) { 1641 x["officeFileMovedOneDrive"] = A.load.Float64(ptr + 24); 1642 } else { 1643 delete x["officeFileMovedOneDrive"]; 1644 } 1645 if (A.load.Bool(ptr + 49)) { 1646 x["officeFileMovedGoogleDrive"] = A.load.Float64(ptr + 32); 1647 } else { 1648 delete x["officeFileMovedGoogleDrive"]; 1649 } 1650 if (A.load.Bool(ptr + 50)) { 1651 x["driveFsBulkPinningEnabled"] = A.load.Bool(ptr + 40); 1652 } else { 1653 delete x["driveFsBulkPinningEnabled"]; 1654 } 1655 return create === A.H.TRUE ? A.H.push(x) : ref; 1656 }, 1657 1658 "store_ProfileInfo": (ptr: Pointer, ref: heap.Ref<any>) => { 1659 const x = A.H.get<any>(ref); 1660 1661 if (typeof x === "undefined") { 1662 A.store.Bool(ptr + 10, false); 1663 A.store.Ref(ptr + 0, undefined); 1664 A.store.Ref(ptr + 4, undefined); 1665 A.store.Bool(ptr + 9, false); 1666 A.store.Bool(ptr + 8, false); 1667 } else { 1668 A.store.Bool(ptr + 10, true); 1669 A.store.Ref(ptr + 0, x["profileId"]); 1670 A.store.Ref(ptr + 4, x["displayName"]); 1671 A.store.Bool(ptr + 9, "isCurrentProfile" in x ? true : false); 1672 A.store.Bool(ptr + 8, x["isCurrentProfile"] ? true : false); 1673 } 1674 }, 1675 "load_ProfileInfo": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 1676 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 1677 1678 x["profileId"] = A.load.Ref(ptr + 0, undefined); 1679 x["displayName"] = A.load.Ref(ptr + 4, undefined); 1680 if (A.load.Bool(ptr + 9)) { 1681 x["isCurrentProfile"] = A.load.Bool(ptr + 8); 1682 } else { 1683 delete x["isCurrentProfile"]; 1684 } 1685 return create === A.H.TRUE ? A.H.push(x) : ref; 1686 }, 1687 "constof_ProviderSource": (ref: heap.Ref<string>): number => { 1688 const idx = ["file", "device", "network"].indexOf(A.H.get(ref)); 1689 return idx < 0 ? 0 : idx + 1; 1690 }, 1691 1692 "store_Provider": (ptr: Pointer, ref: heap.Ref<any>) => { 1693 const x = A.H.get<any>(ref); 1694 1695 if (typeof x === "undefined") { 1696 A.store.Bool(ptr + 31, false); 1697 A.store.Ref(ptr + 0, undefined); 1698 1699 A.store.Bool(ptr + 4 + 8, false); 1700 A.store.Ref(ptr + 4 + 0, undefined); 1701 A.store.Ref(ptr + 4 + 4, undefined); 1702 A.store.Ref(ptr + 16, undefined); 1703 A.store.Bool(ptr + 28, false); 1704 A.store.Bool(ptr + 20, false); 1705 A.store.Bool(ptr + 29, false); 1706 A.store.Bool(ptr + 21, false); 1707 A.store.Bool(ptr + 30, false); 1708 A.store.Bool(ptr + 22, false); 1709 A.store.Enum(ptr + 24, -1); 1710 } else { 1711 A.store.Bool(ptr + 31, true); 1712 A.store.Ref(ptr + 0, x["providerId"]); 1713 1714 if (typeof x["iconSet"] === "undefined") { 1715 A.store.Bool(ptr + 4 + 8, false); 1716 A.store.Ref(ptr + 4 + 0, undefined); 1717 A.store.Ref(ptr + 4 + 4, undefined); 1718 } else { 1719 A.store.Bool(ptr + 4 + 8, true); 1720 A.store.Ref(ptr + 4 + 0, x["iconSet"]["icon16x16Url"]); 1721 A.store.Ref(ptr + 4 + 4, x["iconSet"]["icon32x32Url"]); 1722 } 1723 A.store.Ref(ptr + 16, x["name"]); 1724 A.store.Bool(ptr + 28, "configurable" in x ? true : false); 1725 A.store.Bool(ptr + 20, x["configurable"] ? true : false); 1726 A.store.Bool(ptr + 29, "watchable" in x ? true : false); 1727 A.store.Bool(ptr + 21, x["watchable"] ? true : false); 1728 A.store.Bool(ptr + 30, "multipleMounts" in x ? true : false); 1729 A.store.Bool(ptr + 22, x["multipleMounts"] ? true : false); 1730 A.store.Enum(ptr + 24, ["file", "device", "network"].indexOf(x["source"] as string)); 1731 } 1732 }, 1733 "load_Provider": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 1734 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 1735 1736 x["providerId"] = A.load.Ref(ptr + 0, undefined); 1737 if (A.load.Bool(ptr + 4 + 8)) { 1738 x["iconSet"] = {}; 1739 x["iconSet"]["icon16x16Url"] = A.load.Ref(ptr + 4 + 0, undefined); 1740 x["iconSet"]["icon32x32Url"] = A.load.Ref(ptr + 4 + 4, undefined); 1741 } else { 1742 delete x["iconSet"]; 1743 } 1744 x["name"] = A.load.Ref(ptr + 16, undefined); 1745 if (A.load.Bool(ptr + 28)) { 1746 x["configurable"] = A.load.Bool(ptr + 20); 1747 } else { 1748 delete x["configurable"]; 1749 } 1750 if (A.load.Bool(ptr + 29)) { 1751 x["watchable"] = A.load.Bool(ptr + 21); 1752 } else { 1753 delete x["watchable"]; 1754 } 1755 if (A.load.Bool(ptr + 30)) { 1756 x["multipleMounts"] = A.load.Bool(ptr + 22); 1757 } else { 1758 delete x["multipleMounts"]; 1759 } 1760 x["source"] = A.load.Enum(ptr + 24, ["file", "device", "network"]); 1761 return create === A.H.TRUE ? A.H.push(x) : ref; 1762 }, 1763 1764 "store_MountPointSizeStats": (ptr: Pointer, ref: heap.Ref<any>) => { 1765 const x = A.H.get<any>(ref); 1766 1767 if (typeof x === "undefined") { 1768 A.store.Bool(ptr + 18, false); 1769 A.store.Bool(ptr + 16, false); 1770 A.store.Float64(ptr + 0, 0); 1771 A.store.Bool(ptr + 17, false); 1772 A.store.Float64(ptr + 8, 0); 1773 } else { 1774 A.store.Bool(ptr + 18, true); 1775 A.store.Bool(ptr + 16, "totalSize" in x ? true : false); 1776 A.store.Float64(ptr + 0, x["totalSize"] === undefined ? 0 : (x["totalSize"] as number)); 1777 A.store.Bool(ptr + 17, "remainingSize" in x ? true : false); 1778 A.store.Float64(ptr + 8, x["remainingSize"] === undefined ? 0 : (x["remainingSize"] as number)); 1779 } 1780 }, 1781 "load_MountPointSizeStats": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 1782 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 1783 1784 if (A.load.Bool(ptr + 16)) { 1785 x["totalSize"] = A.load.Float64(ptr + 0); 1786 } else { 1787 delete x["totalSize"]; 1788 } 1789 if (A.load.Bool(ptr + 17)) { 1790 x["remainingSize"] = A.load.Float64(ptr + 8); 1791 } else { 1792 delete x["remainingSize"]; 1793 } 1794 return create === A.H.TRUE ? A.H.push(x) : ref; 1795 }, 1796 "constof_Source": (ref: heap.Ref<string>): number => { 1797 const idx = ["file", "device", "network", "system"].indexOf(A.H.get(ref)); 1798 return idx < 0 ? 0 : idx + 1; 1799 }, 1800 "constof_MountError": (ref: heap.Ref<string>): number => { 1801 const idx = [ 1802 "success", 1803 "in_progress", 1804 "unknown_error", 1805 "internal_error", 1806 "invalid_argument", 1807 "invalid_path", 1808 "path_already_mounted", 1809 "path_not_mounted", 1810 "directory_creation_failed", 1811 "invalid_mount_options", 1812 "insufficient_permissions", 1813 "mount_program_not_found", 1814 "mount_program_failed", 1815 "invalid_device_path", 1816 "unknown_filesystem", 1817 "unsupported_filesystem", 1818 "need_password", 1819 "cancelled", 1820 "busy", 1821 ].indexOf(A.H.get(ref)); 1822 return idx < 0 ? 0 : idx + 1; 1823 }, 1824 "constof_MountContext": (ref: heap.Ref<string>): number => { 1825 const idx = ["user", "auto"].indexOf(A.H.get(ref)); 1826 return idx < 0 ? 0 : idx + 1; 1827 }, 1828 "constof_VmType": (ref: heap.Ref<string>): number => { 1829 const idx = ["termina", "plugin_vm", "borealis", "bruschetta", "arcvm"].indexOf(A.H.get(ref)); 1830 return idx < 0 ? 0 : idx + 1; 1831 }, 1832 1833 "store_VolumeMetadata": (ptr: Pointer, ref: heap.Ref<any>) => { 1834 const x = A.H.get<any>(ref); 1835 1836 if (typeof x === "undefined") { 1837 A.store.Bool(ptr + 103, false); 1838 A.store.Ref(ptr + 0, undefined); 1839 A.store.Ref(ptr + 4, undefined); 1840 A.store.Ref(ptr + 8, undefined); 1841 A.store.Enum(ptr + 12, -1); 1842 A.store.Ref(ptr + 16, undefined); 1843 1844 A.store.Bool(ptr + 20 + 10, false); 1845 A.store.Ref(ptr + 20 + 0, undefined); 1846 A.store.Ref(ptr + 20 + 4, undefined); 1847 A.store.Bool(ptr + 20 + 9, false); 1848 A.store.Bool(ptr + 20 + 8, false); 1849 A.store.Ref(ptr + 32, undefined); 1850 A.store.Enum(ptr + 36, -1); 1851 A.store.Enum(ptr + 40, -1); 1852 A.store.Ref(ptr + 44, undefined); 1853 A.store.Bool(ptr + 96, false); 1854 A.store.Bool(ptr + 48, false); 1855 A.store.Bool(ptr + 97, false); 1856 A.store.Bool(ptr + 49, false); 1857 A.store.Bool(ptr + 98, false); 1858 A.store.Bool(ptr + 50, false); 1859 A.store.Bool(ptr + 99, false); 1860 A.store.Bool(ptr + 51, false); 1861 A.store.Bool(ptr + 100, false); 1862 A.store.Bool(ptr + 52, false); 1863 A.store.Bool(ptr + 101, false); 1864 A.store.Bool(ptr + 53, false); 1865 A.store.Enum(ptr + 56, -1); 1866 A.store.Enum(ptr + 60, -1); 1867 A.store.Ref(ptr + 64, undefined); 1868 1869 A.store.Bool(ptr + 68 + 8, false); 1870 A.store.Ref(ptr + 68 + 0, undefined); 1871 A.store.Ref(ptr + 68 + 4, undefined); 1872 A.store.Ref(ptr + 80, undefined); 1873 A.store.Ref(ptr + 84, undefined); 1874 A.store.Bool(ptr + 102, false); 1875 A.store.Bool(ptr + 88, false); 1876 A.store.Enum(ptr + 92, -1); 1877 } else { 1878 A.store.Bool(ptr + 103, true); 1879 A.store.Ref(ptr + 0, x["volumeId"]); 1880 A.store.Ref(ptr + 4, x["fileSystemId"]); 1881 A.store.Ref(ptr + 8, x["providerId"]); 1882 A.store.Enum(ptr + 12, ["file", "device", "network", "system"].indexOf(x["source"] as string)); 1883 A.store.Ref(ptr + 16, x["volumeLabel"]); 1884 1885 if (typeof x["profile"] === "undefined") { 1886 A.store.Bool(ptr + 20 + 10, false); 1887 A.store.Ref(ptr + 20 + 0, undefined); 1888 A.store.Ref(ptr + 20 + 4, undefined); 1889 A.store.Bool(ptr + 20 + 9, false); 1890 A.store.Bool(ptr + 20 + 8, false); 1891 } else { 1892 A.store.Bool(ptr + 20 + 10, true); 1893 A.store.Ref(ptr + 20 + 0, x["profile"]["profileId"]); 1894 A.store.Ref(ptr + 20 + 4, x["profile"]["displayName"]); 1895 A.store.Bool(ptr + 20 + 9, "isCurrentProfile" in x["profile"] ? true : false); 1896 A.store.Bool(ptr + 20 + 8, x["profile"]["isCurrentProfile"] ? true : false); 1897 } 1898 A.store.Ref(ptr + 32, x["sourcePath"]); 1899 A.store.Enum( 1900 ptr + 36, 1901 [ 1902 "drive", 1903 "downloads", 1904 "removable", 1905 "archive", 1906 "provided", 1907 "mtp", 1908 "media_view", 1909 "crostini", 1910 "android_files", 1911 "documents_provider", 1912 "testing", 1913 "smb", 1914 "system_internal", 1915 "guest_os", 1916 ].indexOf(x["volumeType"] as string) 1917 ); 1918 A.store.Enum(ptr + 40, ["usb", "sd", "optical", "mobile", "unknown"].indexOf(x["deviceType"] as string)); 1919 A.store.Ref(ptr + 44, x["devicePath"]); 1920 A.store.Bool(ptr + 96, "isParentDevice" in x ? true : false); 1921 A.store.Bool(ptr + 48, x["isParentDevice"] ? true : false); 1922 A.store.Bool(ptr + 97, "isReadOnly" in x ? true : false); 1923 A.store.Bool(ptr + 49, x["isReadOnly"] ? true : false); 1924 A.store.Bool(ptr + 98, "isReadOnlyRemovableDevice" in x ? true : false); 1925 A.store.Bool(ptr + 50, x["isReadOnlyRemovableDevice"] ? true : false); 1926 A.store.Bool(ptr + 99, "hasMedia" in x ? true : false); 1927 A.store.Bool(ptr + 51, x["hasMedia"] ? true : false); 1928 A.store.Bool(ptr + 100, "configurable" in x ? true : false); 1929 A.store.Bool(ptr + 52, x["configurable"] ? true : false); 1930 A.store.Bool(ptr + 101, "watchable" in x ? true : false); 1931 A.store.Bool(ptr + 53, x["watchable"] ? true : false); 1932 A.store.Enum( 1933 ptr + 56, 1934 [ 1935 "success", 1936 "in_progress", 1937 "unknown_error", 1938 "internal_error", 1939 "invalid_argument", 1940 "invalid_path", 1941 "path_already_mounted", 1942 "path_not_mounted", 1943 "directory_creation_failed", 1944 "invalid_mount_options", 1945 "insufficient_permissions", 1946 "mount_program_not_found", 1947 "mount_program_failed", 1948 "invalid_device_path", 1949 "unknown_filesystem", 1950 "unsupported_filesystem", 1951 "need_password", 1952 "cancelled", 1953 "busy", 1954 ].indexOf(x["mountCondition"] as string) 1955 ); 1956 A.store.Enum(ptr + 60, ["user", "auto"].indexOf(x["mountContext"] as string)); 1957 A.store.Ref(ptr + 64, x["diskFileSystemType"]); 1958 1959 if (typeof x["iconSet"] === "undefined") { 1960 A.store.Bool(ptr + 68 + 8, false); 1961 A.store.Ref(ptr + 68 + 0, undefined); 1962 A.store.Ref(ptr + 68 + 4, undefined); 1963 } else { 1964 A.store.Bool(ptr + 68 + 8, true); 1965 A.store.Ref(ptr + 68 + 0, x["iconSet"]["icon16x16Url"]); 1966 A.store.Ref(ptr + 68 + 4, x["iconSet"]["icon32x32Url"]); 1967 } 1968 A.store.Ref(ptr + 80, x["driveLabel"]); 1969 A.store.Ref(ptr + 84, x["remoteMountPath"]); 1970 A.store.Bool(ptr + 102, "hidden" in x ? true : false); 1971 A.store.Bool(ptr + 88, x["hidden"] ? true : false); 1972 A.store.Enum( 1973 ptr + 92, 1974 ["termina", "plugin_vm", "borealis", "bruschetta", "arcvm"].indexOf(x["vmType"] as string) 1975 ); 1976 } 1977 }, 1978 "load_VolumeMetadata": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 1979 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 1980 1981 x["volumeId"] = A.load.Ref(ptr + 0, undefined); 1982 x["fileSystemId"] = A.load.Ref(ptr + 4, undefined); 1983 x["providerId"] = A.load.Ref(ptr + 8, undefined); 1984 x["source"] = A.load.Enum(ptr + 12, ["file", "device", "network", "system"]); 1985 x["volumeLabel"] = A.load.Ref(ptr + 16, undefined); 1986 if (A.load.Bool(ptr + 20 + 10)) { 1987 x["profile"] = {}; 1988 x["profile"]["profileId"] = A.load.Ref(ptr + 20 + 0, undefined); 1989 x["profile"]["displayName"] = A.load.Ref(ptr + 20 + 4, undefined); 1990 if (A.load.Bool(ptr + 20 + 9)) { 1991 x["profile"]["isCurrentProfile"] = A.load.Bool(ptr + 20 + 8); 1992 } else { 1993 delete x["profile"]["isCurrentProfile"]; 1994 } 1995 } else { 1996 delete x["profile"]; 1997 } 1998 x["sourcePath"] = A.load.Ref(ptr + 32, undefined); 1999 x["volumeType"] = A.load.Enum(ptr + 36, [ 2000 "drive", 2001 "downloads", 2002 "removable", 2003 "archive", 2004 "provided", 2005 "mtp", 2006 "media_view", 2007 "crostini", 2008 "android_files", 2009 "documents_provider", 2010 "testing", 2011 "smb", 2012 "system_internal", 2013 "guest_os", 2014 ]); 2015 x["deviceType"] = A.load.Enum(ptr + 40, ["usb", "sd", "optical", "mobile", "unknown"]); 2016 x["devicePath"] = A.load.Ref(ptr + 44, undefined); 2017 if (A.load.Bool(ptr + 96)) { 2018 x["isParentDevice"] = A.load.Bool(ptr + 48); 2019 } else { 2020 delete x["isParentDevice"]; 2021 } 2022 if (A.load.Bool(ptr + 97)) { 2023 x["isReadOnly"] = A.load.Bool(ptr + 49); 2024 } else { 2025 delete x["isReadOnly"]; 2026 } 2027 if (A.load.Bool(ptr + 98)) { 2028 x["isReadOnlyRemovableDevice"] = A.load.Bool(ptr + 50); 2029 } else { 2030 delete x["isReadOnlyRemovableDevice"]; 2031 } 2032 if (A.load.Bool(ptr + 99)) { 2033 x["hasMedia"] = A.load.Bool(ptr + 51); 2034 } else { 2035 delete x["hasMedia"]; 2036 } 2037 if (A.load.Bool(ptr + 100)) { 2038 x["configurable"] = A.load.Bool(ptr + 52); 2039 } else { 2040 delete x["configurable"]; 2041 } 2042 if (A.load.Bool(ptr + 101)) { 2043 x["watchable"] = A.load.Bool(ptr + 53); 2044 } else { 2045 delete x["watchable"]; 2046 } 2047 x["mountCondition"] = A.load.Enum(ptr + 56, [ 2048 "success", 2049 "in_progress", 2050 "unknown_error", 2051 "internal_error", 2052 "invalid_argument", 2053 "invalid_path", 2054 "path_already_mounted", 2055 "path_not_mounted", 2056 "directory_creation_failed", 2057 "invalid_mount_options", 2058 "insufficient_permissions", 2059 "mount_program_not_found", 2060 "mount_program_failed", 2061 "invalid_device_path", 2062 "unknown_filesystem", 2063 "unsupported_filesystem", 2064 "need_password", 2065 "cancelled", 2066 "busy", 2067 ]); 2068 x["mountContext"] = A.load.Enum(ptr + 60, ["user", "auto"]); 2069 x["diskFileSystemType"] = A.load.Ref(ptr + 64, undefined); 2070 if (A.load.Bool(ptr + 68 + 8)) { 2071 x["iconSet"] = {}; 2072 x["iconSet"]["icon16x16Url"] = A.load.Ref(ptr + 68 + 0, undefined); 2073 x["iconSet"]["icon32x32Url"] = A.load.Ref(ptr + 68 + 4, undefined); 2074 } else { 2075 delete x["iconSet"]; 2076 } 2077 x["driveLabel"] = A.load.Ref(ptr + 80, undefined); 2078 x["remoteMountPath"] = A.load.Ref(ptr + 84, undefined); 2079 if (A.load.Bool(ptr + 102)) { 2080 x["hidden"] = A.load.Bool(ptr + 88); 2081 } else { 2082 delete x["hidden"]; 2083 } 2084 x["vmType"] = A.load.Enum(ptr + 92, ["termina", "plugin_vm", "borealis", "bruschetta", "arcvm"]); 2085 return create === A.H.TRUE ? A.H.push(x) : ref; 2086 }, 2087 2088 "store_GetVolumeRootOptions": (ptr: Pointer, ref: heap.Ref<any>) => { 2089 const x = A.H.get<any>(ref); 2090 2091 if (typeof x === "undefined") { 2092 A.store.Bool(ptr + 6, false); 2093 A.store.Ref(ptr + 0, undefined); 2094 A.store.Bool(ptr + 5, false); 2095 A.store.Bool(ptr + 4, false); 2096 } else { 2097 A.store.Bool(ptr + 6, true); 2098 A.store.Ref(ptr + 0, x["volumeId"]); 2099 A.store.Bool(ptr + 5, "writable" in x ? true : false); 2100 A.store.Bool(ptr + 4, x["writable"] ? true : false); 2101 } 2102 }, 2103 "load_GetVolumeRootOptions": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 2104 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 2105 2106 x["volumeId"] = A.load.Ref(ptr + 0, undefined); 2107 if (A.load.Bool(ptr + 5)) { 2108 x["writable"] = A.load.Bool(ptr + 4); 2109 } else { 2110 delete x["writable"]; 2111 } 2112 return create === A.H.TRUE ? A.H.push(x) : ref; 2113 }, 2114 2115 "store_HoldingSpaceState": (ptr: Pointer, ref: heap.Ref<any>) => { 2116 const x = A.H.get<any>(ref); 2117 2118 if (typeof x === "undefined") { 2119 A.store.Bool(ptr + 4, false); 2120 A.store.Ref(ptr + 0, undefined); 2121 } else { 2122 A.store.Bool(ptr + 4, true); 2123 A.store.Ref(ptr + 0, x["itemUrls"]); 2124 } 2125 }, 2126 "load_HoldingSpaceState": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 2127 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 2128 2129 x["itemUrls"] = A.load.Ref(ptr + 0, undefined); 2130 return create === A.H.TRUE ? A.H.push(x) : ref; 2131 }, 2132 2133 "store_IOTaskParams": (ptr: Pointer, ref: heap.Ref<any>) => { 2134 const x = A.H.get<any>(ref); 2135 2136 if (typeof x === "undefined") { 2137 A.store.Bool(ptr + 10, false); 2138 A.store.Ref(ptr + 0, undefined); 2139 A.store.Ref(ptr + 4, undefined); 2140 A.store.Bool(ptr + 9, false); 2141 A.store.Bool(ptr + 8, false); 2142 } else { 2143 A.store.Bool(ptr + 10, true); 2144 A.store.Ref(ptr + 0, x["destinationFolder"]); 2145 A.store.Ref(ptr + 4, x["password"]); 2146 A.store.Bool(ptr + 9, "showNotification" in x ? true : false); 2147 A.store.Bool(ptr + 8, x["showNotification"] ? true : false); 2148 } 2149 }, 2150 "load_IOTaskParams": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 2151 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 2152 2153 x["destinationFolder"] = A.load.Ref(ptr + 0, undefined); 2154 x["password"] = A.load.Ref(ptr + 4, undefined); 2155 if (A.load.Bool(ptr + 9)) { 2156 x["showNotification"] = A.load.Bool(ptr + 8); 2157 } else { 2158 delete x["showNotification"]; 2159 } 2160 return create === A.H.TRUE ? A.H.push(x) : ref; 2161 }, 2162 "constof_IOTaskState": (ref: heap.Ref<string>): number => { 2163 const idx = [ 2164 "queued", 2165 "scanning", 2166 "in_progress", 2167 "paused", 2168 "success", 2169 "error", 2170 "need_password", 2171 "cancelled", 2172 ].indexOf(A.H.get(ref)); 2173 return idx < 0 ? 0 : idx + 1; 2174 }, 2175 "constof_IOTaskType": (ref: heap.Ref<string>): number => { 2176 const idx = [ 2177 "copy", 2178 "delete", 2179 "empty_trash", 2180 "extract", 2181 "move", 2182 "restore", 2183 "restore_to_destination", 2184 "trash", 2185 "zip", 2186 ].indexOf(A.H.get(ref)); 2187 return idx < 0 ? 0 : idx + 1; 2188 }, 2189 "constof_InspectionType": (ref: heap.Ref<string>): number => { 2190 const idx = ["normal", "console", "element", "background"].indexOf(A.H.get(ref)); 2191 return idx < 0 ? 0 : idx + 1; 2192 }, 2193 "constof_InstallLinuxPackageResponse": (ref: heap.Ref<string>): number => { 2194 const idx = ["started", "failed", "install_already_active"].indexOf(A.H.get(ref)); 2195 return idx < 0 ? 0 : idx + 1; 2196 }, 2197 2198 "store_MountableGuest": (ptr: Pointer, ref: heap.Ref<any>) => { 2199 const x = A.H.get<any>(ref); 2200 2201 if (typeof x === "undefined") { 2202 A.store.Bool(ptr + 13, false); 2203 A.store.Bool(ptr + 12, false); 2204 A.store.Int32(ptr + 0, 0); 2205 A.store.Ref(ptr + 4, undefined); 2206 A.store.Enum(ptr + 8, -1); 2207 } else { 2208 A.store.Bool(ptr + 13, true); 2209 A.store.Bool(ptr + 12, "id" in x ? true : false); 2210 A.store.Int32(ptr + 0, x["id"] === undefined ? 0 : (x["id"] as number)); 2211 A.store.Ref(ptr + 4, x["displayName"]); 2212 A.store.Enum( 2213 ptr + 8, 2214 ["termina", "plugin_vm", "borealis", "bruschetta", "arcvm"].indexOf(x["vmType"] as string) 2215 ); 2216 } 2217 }, 2218 "load_MountableGuest": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 2219 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 2220 2221 if (A.load.Bool(ptr + 12)) { 2222 x["id"] = A.load.Int32(ptr + 0); 2223 } else { 2224 delete x["id"]; 2225 } 2226 x["displayName"] = A.load.Ref(ptr + 4, undefined); 2227 x["vmType"] = A.load.Enum(ptr + 8, ["termina", "plugin_vm", "borealis", "bruschetta", "arcvm"]); 2228 return create === A.H.TRUE ? A.H.push(x) : ref; 2229 }, 2230 "constof_MountCompletedEventType": (ref: heap.Ref<string>): number => { 2231 const idx = ["mount", "unmount"].indexOf(A.H.get(ref)); 2232 return idx < 0 ? 0 : idx + 1; 2233 }, 2234 2235 "store_MountCompletedEvent": (ptr: Pointer, ref: heap.Ref<any>) => { 2236 const x = A.H.get<any>(ref); 2237 2238 if (typeof x === "undefined") { 2239 A.store.Bool(ptr + 114, false); 2240 A.store.Enum(ptr + 0, -1); 2241 A.store.Enum(ptr + 4, -1); 2242 2243 A.store.Bool(ptr + 8 + 103, false); 2244 A.store.Ref(ptr + 8 + 0, undefined); 2245 A.store.Ref(ptr + 8 + 4, undefined); 2246 A.store.Ref(ptr + 8 + 8, undefined); 2247 A.store.Enum(ptr + 8 + 12, -1); 2248 A.store.Ref(ptr + 8 + 16, undefined); 2249 2250 A.store.Bool(ptr + 8 + 20 + 10, false); 2251 A.store.Ref(ptr + 8 + 20 + 0, undefined); 2252 A.store.Ref(ptr + 8 + 20 + 4, undefined); 2253 A.store.Bool(ptr + 8 + 20 + 9, false); 2254 A.store.Bool(ptr + 8 + 20 + 8, false); 2255 A.store.Ref(ptr + 8 + 32, undefined); 2256 A.store.Enum(ptr + 8 + 36, -1); 2257 A.store.Enum(ptr + 8 + 40, -1); 2258 A.store.Ref(ptr + 8 + 44, undefined); 2259 A.store.Bool(ptr + 8 + 96, false); 2260 A.store.Bool(ptr + 8 + 48, false); 2261 A.store.Bool(ptr + 8 + 97, false); 2262 A.store.Bool(ptr + 8 + 49, false); 2263 A.store.Bool(ptr + 8 + 98, false); 2264 A.store.Bool(ptr + 8 + 50, false); 2265 A.store.Bool(ptr + 8 + 99, false); 2266 A.store.Bool(ptr + 8 + 51, false); 2267 A.store.Bool(ptr + 8 + 100, false); 2268 A.store.Bool(ptr + 8 + 52, false); 2269 A.store.Bool(ptr + 8 + 101, false); 2270 A.store.Bool(ptr + 8 + 53, false); 2271 A.store.Enum(ptr + 8 + 56, -1); 2272 A.store.Enum(ptr + 8 + 60, -1); 2273 A.store.Ref(ptr + 8 + 64, undefined); 2274 2275 A.store.Bool(ptr + 8 + 68 + 8, false); 2276 A.store.Ref(ptr + 8 + 68 + 0, undefined); 2277 A.store.Ref(ptr + 8 + 68 + 4, undefined); 2278 A.store.Ref(ptr + 8 + 80, undefined); 2279 A.store.Ref(ptr + 8 + 84, undefined); 2280 A.store.Bool(ptr + 8 + 102, false); 2281 A.store.Bool(ptr + 8 + 88, false); 2282 A.store.Enum(ptr + 8 + 92, -1); 2283 A.store.Bool(ptr + 113, false); 2284 A.store.Bool(ptr + 112, false); 2285 } else { 2286 A.store.Bool(ptr + 114, true); 2287 A.store.Enum(ptr + 0, ["mount", "unmount"].indexOf(x["eventType"] as string)); 2288 A.store.Enum( 2289 ptr + 4, 2290 [ 2291 "success", 2292 "in_progress", 2293 "unknown_error", 2294 "internal_error", 2295 "invalid_argument", 2296 "invalid_path", 2297 "path_already_mounted", 2298 "path_not_mounted", 2299 "directory_creation_failed", 2300 "invalid_mount_options", 2301 "insufficient_permissions", 2302 "mount_program_not_found", 2303 "mount_program_failed", 2304 "invalid_device_path", 2305 "unknown_filesystem", 2306 "unsupported_filesystem", 2307 "need_password", 2308 "cancelled", 2309 "busy", 2310 ].indexOf(x["status"] as string) 2311 ); 2312 2313 if (typeof x["volumeMetadata"] === "undefined") { 2314 A.store.Bool(ptr + 8 + 103, false); 2315 A.store.Ref(ptr + 8 + 0, undefined); 2316 A.store.Ref(ptr + 8 + 4, undefined); 2317 A.store.Ref(ptr + 8 + 8, undefined); 2318 A.store.Enum(ptr + 8 + 12, -1); 2319 A.store.Ref(ptr + 8 + 16, undefined); 2320 2321 A.store.Bool(ptr + 8 + 20 + 10, false); 2322 A.store.Ref(ptr + 8 + 20 + 0, undefined); 2323 A.store.Ref(ptr + 8 + 20 + 4, undefined); 2324 A.store.Bool(ptr + 8 + 20 + 9, false); 2325 A.store.Bool(ptr + 8 + 20 + 8, false); 2326 A.store.Ref(ptr + 8 + 32, undefined); 2327 A.store.Enum(ptr + 8 + 36, -1); 2328 A.store.Enum(ptr + 8 + 40, -1); 2329 A.store.Ref(ptr + 8 + 44, undefined); 2330 A.store.Bool(ptr + 8 + 96, false); 2331 A.store.Bool(ptr + 8 + 48, false); 2332 A.store.Bool(ptr + 8 + 97, false); 2333 A.store.Bool(ptr + 8 + 49, false); 2334 A.store.Bool(ptr + 8 + 98, false); 2335 A.store.Bool(ptr + 8 + 50, false); 2336 A.store.Bool(ptr + 8 + 99, false); 2337 A.store.Bool(ptr + 8 + 51, false); 2338 A.store.Bool(ptr + 8 + 100, false); 2339 A.store.Bool(ptr + 8 + 52, false); 2340 A.store.Bool(ptr + 8 + 101, false); 2341 A.store.Bool(ptr + 8 + 53, false); 2342 A.store.Enum(ptr + 8 + 56, -1); 2343 A.store.Enum(ptr + 8 + 60, -1); 2344 A.store.Ref(ptr + 8 + 64, undefined); 2345 2346 A.store.Bool(ptr + 8 + 68 + 8, false); 2347 A.store.Ref(ptr + 8 + 68 + 0, undefined); 2348 A.store.Ref(ptr + 8 + 68 + 4, undefined); 2349 A.store.Ref(ptr + 8 + 80, undefined); 2350 A.store.Ref(ptr + 8 + 84, undefined); 2351 A.store.Bool(ptr + 8 + 102, false); 2352 A.store.Bool(ptr + 8 + 88, false); 2353 A.store.Enum(ptr + 8 + 92, -1); 2354 } else { 2355 A.store.Bool(ptr + 8 + 103, true); 2356 A.store.Ref(ptr + 8 + 0, x["volumeMetadata"]["volumeId"]); 2357 A.store.Ref(ptr + 8 + 4, x["volumeMetadata"]["fileSystemId"]); 2358 A.store.Ref(ptr + 8 + 8, x["volumeMetadata"]["providerId"]); 2359 A.store.Enum( 2360 ptr + 8 + 12, 2361 ["file", "device", "network", "system"].indexOf(x["volumeMetadata"]["source"] as string) 2362 ); 2363 A.store.Ref(ptr + 8 + 16, x["volumeMetadata"]["volumeLabel"]); 2364 2365 if (typeof x["volumeMetadata"]["profile"] === "undefined") { 2366 A.store.Bool(ptr + 8 + 20 + 10, false); 2367 A.store.Ref(ptr + 8 + 20 + 0, undefined); 2368 A.store.Ref(ptr + 8 + 20 + 4, undefined); 2369 A.store.Bool(ptr + 8 + 20 + 9, false); 2370 A.store.Bool(ptr + 8 + 20 + 8, false); 2371 } else { 2372 A.store.Bool(ptr + 8 + 20 + 10, true); 2373 A.store.Ref(ptr + 8 + 20 + 0, x["volumeMetadata"]["profile"]["profileId"]); 2374 A.store.Ref(ptr + 8 + 20 + 4, x["volumeMetadata"]["profile"]["displayName"]); 2375 A.store.Bool(ptr + 8 + 20 + 9, "isCurrentProfile" in x["volumeMetadata"]["profile"] ? true : false); 2376 A.store.Bool(ptr + 8 + 20 + 8, x["volumeMetadata"]["profile"]["isCurrentProfile"] ? true : false); 2377 } 2378 A.store.Ref(ptr + 8 + 32, x["volumeMetadata"]["sourcePath"]); 2379 A.store.Enum( 2380 ptr + 8 + 36, 2381 [ 2382 "drive", 2383 "downloads", 2384 "removable", 2385 "archive", 2386 "provided", 2387 "mtp", 2388 "media_view", 2389 "crostini", 2390 "android_files", 2391 "documents_provider", 2392 "testing", 2393 "smb", 2394 "system_internal", 2395 "guest_os", 2396 ].indexOf(x["volumeMetadata"]["volumeType"] as string) 2397 ); 2398 A.store.Enum( 2399 ptr + 8 + 40, 2400 ["usb", "sd", "optical", "mobile", "unknown"].indexOf(x["volumeMetadata"]["deviceType"] as string) 2401 ); 2402 A.store.Ref(ptr + 8 + 44, x["volumeMetadata"]["devicePath"]); 2403 A.store.Bool(ptr + 8 + 96, "isParentDevice" in x["volumeMetadata"] ? true : false); 2404 A.store.Bool(ptr + 8 + 48, x["volumeMetadata"]["isParentDevice"] ? true : false); 2405 A.store.Bool(ptr + 8 + 97, "isReadOnly" in x["volumeMetadata"] ? true : false); 2406 A.store.Bool(ptr + 8 + 49, x["volumeMetadata"]["isReadOnly"] ? true : false); 2407 A.store.Bool(ptr + 8 + 98, "isReadOnlyRemovableDevice" in x["volumeMetadata"] ? true : false); 2408 A.store.Bool(ptr + 8 + 50, x["volumeMetadata"]["isReadOnlyRemovableDevice"] ? true : false); 2409 A.store.Bool(ptr + 8 + 99, "hasMedia" in x["volumeMetadata"] ? true : false); 2410 A.store.Bool(ptr + 8 + 51, x["volumeMetadata"]["hasMedia"] ? true : false); 2411 A.store.Bool(ptr + 8 + 100, "configurable" in x["volumeMetadata"] ? true : false); 2412 A.store.Bool(ptr + 8 + 52, x["volumeMetadata"]["configurable"] ? true : false); 2413 A.store.Bool(ptr + 8 + 101, "watchable" in x["volumeMetadata"] ? true : false); 2414 A.store.Bool(ptr + 8 + 53, x["volumeMetadata"]["watchable"] ? true : false); 2415 A.store.Enum( 2416 ptr + 8 + 56, 2417 [ 2418 "success", 2419 "in_progress", 2420 "unknown_error", 2421 "internal_error", 2422 "invalid_argument", 2423 "invalid_path", 2424 "path_already_mounted", 2425 "path_not_mounted", 2426 "directory_creation_failed", 2427 "invalid_mount_options", 2428 "insufficient_permissions", 2429 "mount_program_not_found", 2430 "mount_program_failed", 2431 "invalid_device_path", 2432 "unknown_filesystem", 2433 "unsupported_filesystem", 2434 "need_password", 2435 "cancelled", 2436 "busy", 2437 ].indexOf(x["volumeMetadata"]["mountCondition"] as string) 2438 ); 2439 A.store.Enum(ptr + 8 + 60, ["user", "auto"].indexOf(x["volumeMetadata"]["mountContext"] as string)); 2440 A.store.Ref(ptr + 8 + 64, x["volumeMetadata"]["diskFileSystemType"]); 2441 2442 if (typeof x["volumeMetadata"]["iconSet"] === "undefined") { 2443 A.store.Bool(ptr + 8 + 68 + 8, false); 2444 A.store.Ref(ptr + 8 + 68 + 0, undefined); 2445 A.store.Ref(ptr + 8 + 68 + 4, undefined); 2446 } else { 2447 A.store.Bool(ptr + 8 + 68 + 8, true); 2448 A.store.Ref(ptr + 8 + 68 + 0, x["volumeMetadata"]["iconSet"]["icon16x16Url"]); 2449 A.store.Ref(ptr + 8 + 68 + 4, x["volumeMetadata"]["iconSet"]["icon32x32Url"]); 2450 } 2451 A.store.Ref(ptr + 8 + 80, x["volumeMetadata"]["driveLabel"]); 2452 A.store.Ref(ptr + 8 + 84, x["volumeMetadata"]["remoteMountPath"]); 2453 A.store.Bool(ptr + 8 + 102, "hidden" in x["volumeMetadata"] ? true : false); 2454 A.store.Bool(ptr + 8 + 88, x["volumeMetadata"]["hidden"] ? true : false); 2455 A.store.Enum( 2456 ptr + 8 + 92, 2457 ["termina", "plugin_vm", "borealis", "bruschetta", "arcvm"].indexOf(x["volumeMetadata"]["vmType"] as string) 2458 ); 2459 } 2460 A.store.Bool(ptr + 113, "shouldNotify" in x ? true : false); 2461 A.store.Bool(ptr + 112, x["shouldNotify"] ? true : false); 2462 } 2463 }, 2464 "load_MountCompletedEvent": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 2465 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 2466 2467 x["eventType"] = A.load.Enum(ptr + 0, ["mount", "unmount"]); 2468 x["status"] = A.load.Enum(ptr + 4, [ 2469 "success", 2470 "in_progress", 2471 "unknown_error", 2472 "internal_error", 2473 "invalid_argument", 2474 "invalid_path", 2475 "path_already_mounted", 2476 "path_not_mounted", 2477 "directory_creation_failed", 2478 "invalid_mount_options", 2479 "insufficient_permissions", 2480 "mount_program_not_found", 2481 "mount_program_failed", 2482 "invalid_device_path", 2483 "unknown_filesystem", 2484 "unsupported_filesystem", 2485 "need_password", 2486 "cancelled", 2487 "busy", 2488 ]); 2489 if (A.load.Bool(ptr + 8 + 103)) { 2490 x["volumeMetadata"] = {}; 2491 x["volumeMetadata"]["volumeId"] = A.load.Ref(ptr + 8 + 0, undefined); 2492 x["volumeMetadata"]["fileSystemId"] = A.load.Ref(ptr + 8 + 4, undefined); 2493 x["volumeMetadata"]["providerId"] = A.load.Ref(ptr + 8 + 8, undefined); 2494 x["volumeMetadata"]["source"] = A.load.Enum(ptr + 8 + 12, ["file", "device", "network", "system"]); 2495 x["volumeMetadata"]["volumeLabel"] = A.load.Ref(ptr + 8 + 16, undefined); 2496 if (A.load.Bool(ptr + 8 + 20 + 10)) { 2497 x["volumeMetadata"]["profile"] = {}; 2498 x["volumeMetadata"]["profile"]["profileId"] = A.load.Ref(ptr + 8 + 20 + 0, undefined); 2499 x["volumeMetadata"]["profile"]["displayName"] = A.load.Ref(ptr + 8 + 20 + 4, undefined); 2500 if (A.load.Bool(ptr + 8 + 20 + 9)) { 2501 x["volumeMetadata"]["profile"]["isCurrentProfile"] = A.load.Bool(ptr + 8 + 20 + 8); 2502 } else { 2503 delete x["volumeMetadata"]["profile"]["isCurrentProfile"]; 2504 } 2505 } else { 2506 delete x["volumeMetadata"]["profile"]; 2507 } 2508 x["volumeMetadata"]["sourcePath"] = A.load.Ref(ptr + 8 + 32, undefined); 2509 x["volumeMetadata"]["volumeType"] = A.load.Enum(ptr + 8 + 36, [ 2510 "drive", 2511 "downloads", 2512 "removable", 2513 "archive", 2514 "provided", 2515 "mtp", 2516 "media_view", 2517 "crostini", 2518 "android_files", 2519 "documents_provider", 2520 "testing", 2521 "smb", 2522 "system_internal", 2523 "guest_os", 2524 ]); 2525 x["volumeMetadata"]["deviceType"] = A.load.Enum(ptr + 8 + 40, ["usb", "sd", "optical", "mobile", "unknown"]); 2526 x["volumeMetadata"]["devicePath"] = A.load.Ref(ptr + 8 + 44, undefined); 2527 if (A.load.Bool(ptr + 8 + 96)) { 2528 x["volumeMetadata"]["isParentDevice"] = A.load.Bool(ptr + 8 + 48); 2529 } else { 2530 delete x["volumeMetadata"]["isParentDevice"]; 2531 } 2532 if (A.load.Bool(ptr + 8 + 97)) { 2533 x["volumeMetadata"]["isReadOnly"] = A.load.Bool(ptr + 8 + 49); 2534 } else { 2535 delete x["volumeMetadata"]["isReadOnly"]; 2536 } 2537 if (A.load.Bool(ptr + 8 + 98)) { 2538 x["volumeMetadata"]["isReadOnlyRemovableDevice"] = A.load.Bool(ptr + 8 + 50); 2539 } else { 2540 delete x["volumeMetadata"]["isReadOnlyRemovableDevice"]; 2541 } 2542 if (A.load.Bool(ptr + 8 + 99)) { 2543 x["volumeMetadata"]["hasMedia"] = A.load.Bool(ptr + 8 + 51); 2544 } else { 2545 delete x["volumeMetadata"]["hasMedia"]; 2546 } 2547 if (A.load.Bool(ptr + 8 + 100)) { 2548 x["volumeMetadata"]["configurable"] = A.load.Bool(ptr + 8 + 52); 2549 } else { 2550 delete x["volumeMetadata"]["configurable"]; 2551 } 2552 if (A.load.Bool(ptr + 8 + 101)) { 2553 x["volumeMetadata"]["watchable"] = A.load.Bool(ptr + 8 + 53); 2554 } else { 2555 delete x["volumeMetadata"]["watchable"]; 2556 } 2557 x["volumeMetadata"]["mountCondition"] = A.load.Enum(ptr + 8 + 56, [ 2558 "success", 2559 "in_progress", 2560 "unknown_error", 2561 "internal_error", 2562 "invalid_argument", 2563 "invalid_path", 2564 "path_already_mounted", 2565 "path_not_mounted", 2566 "directory_creation_failed", 2567 "invalid_mount_options", 2568 "insufficient_permissions", 2569 "mount_program_not_found", 2570 "mount_program_failed", 2571 "invalid_device_path", 2572 "unknown_filesystem", 2573 "unsupported_filesystem", 2574 "need_password", 2575 "cancelled", 2576 "busy", 2577 ]); 2578 x["volumeMetadata"]["mountContext"] = A.load.Enum(ptr + 8 + 60, ["user", "auto"]); 2579 x["volumeMetadata"]["diskFileSystemType"] = A.load.Ref(ptr + 8 + 64, undefined); 2580 if (A.load.Bool(ptr + 8 + 68 + 8)) { 2581 x["volumeMetadata"]["iconSet"] = {}; 2582 x["volumeMetadata"]["iconSet"]["icon16x16Url"] = A.load.Ref(ptr + 8 + 68 + 0, undefined); 2583 x["volumeMetadata"]["iconSet"]["icon32x32Url"] = A.load.Ref(ptr + 8 + 68 + 4, undefined); 2584 } else { 2585 delete x["volumeMetadata"]["iconSet"]; 2586 } 2587 x["volumeMetadata"]["driveLabel"] = A.load.Ref(ptr + 8 + 80, undefined); 2588 x["volumeMetadata"]["remoteMountPath"] = A.load.Ref(ptr + 8 + 84, undefined); 2589 if (A.load.Bool(ptr + 8 + 102)) { 2590 x["volumeMetadata"]["hidden"] = A.load.Bool(ptr + 8 + 88); 2591 } else { 2592 delete x["volumeMetadata"]["hidden"]; 2593 } 2594 x["volumeMetadata"]["vmType"] = A.load.Enum(ptr + 8 + 92, [ 2595 "termina", 2596 "plugin_vm", 2597 "borealis", 2598 "bruschetta", 2599 "arcvm", 2600 ]); 2601 } else { 2602 delete x["volumeMetadata"]; 2603 } 2604 if (A.load.Bool(ptr + 113)) { 2605 x["shouldNotify"] = A.load.Bool(ptr + 112); 2606 } else { 2607 delete x["shouldNotify"]; 2608 } 2609 return create === A.H.TRUE ? A.H.push(x) : ref; 2610 }, 2611 2612 "store_OpenWindowParams": (ptr: Pointer, ref: heap.Ref<any>) => { 2613 const x = A.H.get<any>(ref); 2614 2615 if (typeof x === "undefined") { 2616 A.store.Bool(ptr + 8, false); 2617 A.store.Ref(ptr + 0, undefined); 2618 A.store.Ref(ptr + 4, undefined); 2619 } else { 2620 A.store.Bool(ptr + 8, true); 2621 A.store.Ref(ptr + 0, x["currentDirectoryURL"]); 2622 A.store.Ref(ptr + 4, x["selectionURL"]); 2623 } 2624 }, 2625 "load_OpenWindowParams": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 2626 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 2627 2628 x["currentDirectoryURL"] = A.load.Ref(ptr + 0, undefined); 2629 x["selectionURL"] = A.load.Ref(ptr + 4, undefined); 2630 return create === A.H.TRUE ? A.H.push(x) : ref; 2631 }, 2632 2633 "store_ParsedTrashInfoFile": (ptr: Pointer, ref: heap.Ref<any>) => { 2634 const x = A.H.get<any>(ref); 2635 2636 if (typeof x === "undefined") { 2637 A.store.Bool(ptr + 17, false); 2638 A.store.Ref(ptr + 0, undefined); 2639 A.store.Ref(ptr + 4, undefined); 2640 A.store.Bool(ptr + 16, false); 2641 A.store.Float64(ptr + 8, 0); 2642 } else { 2643 A.store.Bool(ptr + 17, true); 2644 A.store.Ref(ptr + 0, x["restoreEntry"]); 2645 A.store.Ref(ptr + 4, x["trashInfoFileName"]); 2646 A.store.Bool(ptr + 16, "deletionDate" in x ? true : false); 2647 A.store.Float64(ptr + 8, x["deletionDate"] === undefined ? 0 : (x["deletionDate"] as number)); 2648 } 2649 }, 2650 "load_ParsedTrashInfoFile": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 2651 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 2652 2653 x["restoreEntry"] = A.load.Ref(ptr + 0, undefined); 2654 x["trashInfoFileName"] = A.load.Ref(ptr + 4, undefined); 2655 if (A.load.Bool(ptr + 16)) { 2656 x["deletionDate"] = A.load.Float64(ptr + 8); 2657 } else { 2658 delete x["deletionDate"]; 2659 } 2660 return create === A.H.TRUE ? A.H.push(x) : ref; 2661 }, 2662 "constof_PolicyErrorType": (ref: heap.Ref<string>): number => { 2663 const idx = ["dlp", "enterprise_connectors", "dlp_warning_timeout"].indexOf(A.H.get(ref)); 2664 return idx < 0 ? 0 : idx + 1; 2665 }, 2666 2667 "store_PolicyPauseParams": (ptr: Pointer, ref: heap.Ref<any>) => { 2668 const x = A.H.get<any>(ref); 2669 2670 if (typeof x === "undefined") { 2671 A.store.Bool(ptr + 13, false); 2672 A.store.Enum(ptr + 0, -1); 2673 A.store.Bool(ptr + 12, false); 2674 A.store.Int32(ptr + 4, 0); 2675 A.store.Ref(ptr + 8, undefined); 2676 } else { 2677 A.store.Bool(ptr + 13, true); 2678 A.store.Enum(ptr + 0, ["dlp", "enterprise_connectors", "dlp_warning_timeout"].indexOf(x["type"] as string)); 2679 A.store.Bool(ptr + 12, "policyFileCount" in x ? true : false); 2680 A.store.Int32(ptr + 4, x["policyFileCount"] === undefined ? 0 : (x["policyFileCount"] as number)); 2681 A.store.Ref(ptr + 8, x["fileName"]); 2682 } 2683 }, 2684 "load_PolicyPauseParams": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 2685 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 2686 2687 x["type"] = A.load.Enum(ptr + 0, ["dlp", "enterprise_connectors", "dlp_warning_timeout"]); 2688 if (A.load.Bool(ptr + 12)) { 2689 x["policyFileCount"] = A.load.Int32(ptr + 4); 2690 } else { 2691 delete x["policyFileCount"]; 2692 } 2693 x["fileName"] = A.load.Ref(ptr + 8, undefined); 2694 return create === A.H.TRUE ? A.H.push(x) : ref; 2695 }, 2696 2697 "store_PauseParams": (ptr: Pointer, ref: heap.Ref<any>) => { 2698 const x = A.H.get<any>(ref); 2699 2700 if (typeof x === "undefined") { 2701 A.store.Bool(ptr + 30, false); 2702 2703 A.store.Bool(ptr + 0 + 14, false); 2704 A.store.Ref(ptr + 0 + 0, undefined); 2705 A.store.Bool(ptr + 0 + 12, false); 2706 A.store.Bool(ptr + 0 + 4, false); 2707 A.store.Bool(ptr + 0 + 13, false); 2708 A.store.Bool(ptr + 0 + 5, false); 2709 A.store.Ref(ptr + 0 + 8, undefined); 2710 2711 A.store.Bool(ptr + 16 + 13, false); 2712 A.store.Enum(ptr + 16 + 0, -1); 2713 A.store.Bool(ptr + 16 + 12, false); 2714 A.store.Int32(ptr + 16 + 4, 0); 2715 A.store.Ref(ptr + 16 + 8, undefined); 2716 } else { 2717 A.store.Bool(ptr + 30, true); 2718 2719 if (typeof x["conflictParams"] === "undefined") { 2720 A.store.Bool(ptr + 0 + 14, false); 2721 A.store.Ref(ptr + 0 + 0, undefined); 2722 A.store.Bool(ptr + 0 + 12, false); 2723 A.store.Bool(ptr + 0 + 4, false); 2724 A.store.Bool(ptr + 0 + 13, false); 2725 A.store.Bool(ptr + 0 + 5, false); 2726 A.store.Ref(ptr + 0 + 8, undefined); 2727 } else { 2728 A.store.Bool(ptr + 0 + 14, true); 2729 A.store.Ref(ptr + 0 + 0, x["conflictParams"]["conflictName"]); 2730 A.store.Bool(ptr + 0 + 12, "conflictIsDirectory" in x["conflictParams"] ? true : false); 2731 A.store.Bool(ptr + 0 + 4, x["conflictParams"]["conflictIsDirectory"] ? true : false); 2732 A.store.Bool(ptr + 0 + 13, "conflictMultiple" in x["conflictParams"] ? true : false); 2733 A.store.Bool(ptr + 0 + 5, x["conflictParams"]["conflictMultiple"] ? true : false); 2734 A.store.Ref(ptr + 0 + 8, x["conflictParams"]["conflictTargetUrl"]); 2735 } 2736 2737 if (typeof x["policyParams"] === "undefined") { 2738 A.store.Bool(ptr + 16 + 13, false); 2739 A.store.Enum(ptr + 16 + 0, -1); 2740 A.store.Bool(ptr + 16 + 12, false); 2741 A.store.Int32(ptr + 16 + 4, 0); 2742 A.store.Ref(ptr + 16 + 8, undefined); 2743 } else { 2744 A.store.Bool(ptr + 16 + 13, true); 2745 A.store.Enum( 2746 ptr + 16 + 0, 2747 ["dlp", "enterprise_connectors", "dlp_warning_timeout"].indexOf(x["policyParams"]["type"] as string) 2748 ); 2749 A.store.Bool(ptr + 16 + 12, "policyFileCount" in x["policyParams"] ? true : false); 2750 A.store.Int32( 2751 ptr + 16 + 4, 2752 x["policyParams"]["policyFileCount"] === undefined ? 0 : (x["policyParams"]["policyFileCount"] as number) 2753 ); 2754 A.store.Ref(ptr + 16 + 8, x["policyParams"]["fileName"]); 2755 } 2756 } 2757 }, 2758 "load_PauseParams": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 2759 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 2760 2761 if (A.load.Bool(ptr + 0 + 14)) { 2762 x["conflictParams"] = {}; 2763 x["conflictParams"]["conflictName"] = A.load.Ref(ptr + 0 + 0, undefined); 2764 if (A.load.Bool(ptr + 0 + 12)) { 2765 x["conflictParams"]["conflictIsDirectory"] = A.load.Bool(ptr + 0 + 4); 2766 } else { 2767 delete x["conflictParams"]["conflictIsDirectory"]; 2768 } 2769 if (A.load.Bool(ptr + 0 + 13)) { 2770 x["conflictParams"]["conflictMultiple"] = A.load.Bool(ptr + 0 + 5); 2771 } else { 2772 delete x["conflictParams"]["conflictMultiple"]; 2773 } 2774 x["conflictParams"]["conflictTargetUrl"] = A.load.Ref(ptr + 0 + 8, undefined); 2775 } else { 2776 delete x["conflictParams"]; 2777 } 2778 if (A.load.Bool(ptr + 16 + 13)) { 2779 x["policyParams"] = {}; 2780 x["policyParams"]["type"] = A.load.Enum(ptr + 16 + 0, ["dlp", "enterprise_connectors", "dlp_warning_timeout"]); 2781 if (A.load.Bool(ptr + 16 + 12)) { 2782 x["policyParams"]["policyFileCount"] = A.load.Int32(ptr + 16 + 4); 2783 } else { 2784 delete x["policyParams"]["policyFileCount"]; 2785 } 2786 x["policyParams"]["fileName"] = A.load.Ref(ptr + 16 + 8, undefined); 2787 } else { 2788 delete x["policyParams"]; 2789 } 2790 return create === A.H.TRUE ? A.H.push(x) : ref; 2791 }, 2792 "constof_PolicyDialogType": (ref: heap.Ref<string>): number => { 2793 const idx = ["warning", "error"].indexOf(A.H.get(ref)); 2794 return idx < 0 ? 0 : idx + 1; 2795 }, 2796 2797 "store_PolicyError": (ptr: Pointer, ref: heap.Ref<any>) => { 2798 const x = A.H.get<any>(ref); 2799 2800 if (typeof x === "undefined") { 2801 A.store.Bool(ptr + 13, false); 2802 A.store.Enum(ptr + 0, -1); 2803 A.store.Bool(ptr + 12, false); 2804 A.store.Int32(ptr + 4, 0); 2805 A.store.Ref(ptr + 8, undefined); 2806 } else { 2807 A.store.Bool(ptr + 13, true); 2808 A.store.Enum(ptr + 0, ["dlp", "enterprise_connectors", "dlp_warning_timeout"].indexOf(x["type"] as string)); 2809 A.store.Bool(ptr + 12, "policyFileCount" in x ? true : false); 2810 A.store.Int32(ptr + 4, x["policyFileCount"] === undefined ? 0 : (x["policyFileCount"] as number)); 2811 A.store.Ref(ptr + 8, x["fileName"]); 2812 } 2813 }, 2814 "load_PolicyError": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 2815 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 2816 2817 x["type"] = A.load.Enum(ptr + 0, ["dlp", "enterprise_connectors", "dlp_warning_timeout"]); 2818 if (A.load.Bool(ptr + 12)) { 2819 x["policyFileCount"] = A.load.Int32(ptr + 4); 2820 } else { 2821 delete x["policyFileCount"]; 2822 } 2823 x["fileName"] = A.load.Ref(ptr + 8, undefined); 2824 return create === A.H.TRUE ? A.H.push(x) : ref; 2825 }, 2826 2827 "store_PolicyResumeParams": (ptr: Pointer, ref: heap.Ref<any>) => { 2828 const x = A.H.get<any>(ref); 2829 2830 if (typeof x === "undefined") { 2831 A.store.Bool(ptr + 4, false); 2832 A.store.Enum(ptr + 0, -1); 2833 } else { 2834 A.store.Bool(ptr + 4, true); 2835 A.store.Enum(ptr + 0, ["dlp", "enterprise_connectors", "dlp_warning_timeout"].indexOf(x["type"] as string)); 2836 } 2837 }, 2838 "load_PolicyResumeParams": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 2839 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 2840 2841 x["type"] = A.load.Enum(ptr + 0, ["dlp", "enterprise_connectors", "dlp_warning_timeout"]); 2842 return create === A.H.TRUE ? A.H.push(x) : ref; 2843 }, 2844 2845 "store_PreferencesChange": (ptr: Pointer, ref: heap.Ref<any>) => { 2846 const x = A.H.get<any>(ref); 2847 2848 if (typeof x === "undefined") { 2849 A.store.Bool(ptr + 13, false); 2850 A.store.Bool(ptr + 9, false); 2851 A.store.Bool(ptr + 0, false); 2852 A.store.Bool(ptr + 10, false); 2853 A.store.Bool(ptr + 1, false); 2854 A.store.Bool(ptr + 11, false); 2855 A.store.Bool(ptr + 2, false); 2856 A.store.Ref(ptr + 4, undefined); 2857 A.store.Bool(ptr + 12, false); 2858 A.store.Bool(ptr + 8, false); 2859 } else { 2860 A.store.Bool(ptr + 13, true); 2861 A.store.Bool(ptr + 9, "driveSyncEnabledOnMeteredNetwork" in x ? true : false); 2862 A.store.Bool(ptr + 0, x["driveSyncEnabledOnMeteredNetwork"] ? true : false); 2863 A.store.Bool(ptr + 10, "arcEnabled" in x ? true : false); 2864 A.store.Bool(ptr + 1, x["arcEnabled"] ? true : false); 2865 A.store.Bool(ptr + 11, "arcRemovableMediaAccessEnabled" in x ? true : false); 2866 A.store.Bool(ptr + 2, x["arcRemovableMediaAccessEnabled"] ? true : false); 2867 A.store.Ref(ptr + 4, x["folderShortcuts"]); 2868 A.store.Bool(ptr + 12, "driveFsBulkPinningEnabled" in x ? true : false); 2869 A.store.Bool(ptr + 8, x["driveFsBulkPinningEnabled"] ? true : false); 2870 } 2871 }, 2872 "load_PreferencesChange": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 2873 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 2874 2875 if (A.load.Bool(ptr + 9)) { 2876 x["driveSyncEnabledOnMeteredNetwork"] = A.load.Bool(ptr + 0); 2877 } else { 2878 delete x["driveSyncEnabledOnMeteredNetwork"]; 2879 } 2880 if (A.load.Bool(ptr + 10)) { 2881 x["arcEnabled"] = A.load.Bool(ptr + 1); 2882 } else { 2883 delete x["arcEnabled"]; 2884 } 2885 if (A.load.Bool(ptr + 11)) { 2886 x["arcRemovableMediaAccessEnabled"] = A.load.Bool(ptr + 2); 2887 } else { 2888 delete x["arcRemovableMediaAccessEnabled"]; 2889 } 2890 x["folderShortcuts"] = A.load.Ref(ptr + 4, undefined); 2891 if (A.load.Bool(ptr + 12)) { 2892 x["driveFsBulkPinningEnabled"] = A.load.Bool(ptr + 8); 2893 } else { 2894 delete x["driveFsBulkPinningEnabled"]; 2895 } 2896 return create === A.H.TRUE ? A.H.push(x) : ref; 2897 }, 2898 2899 "store_ProgressStatus": (ptr: Pointer, ref: heap.Ref<any>) => { 2900 const x = A.H.get<any>(ref); 2901 2902 if (typeof x === "undefined") { 2903 A.store.Bool(ptr + 124, false); 2904 A.store.Enum(ptr + 0, -1); 2905 A.store.Enum(ptr + 4, -1); 2906 2907 A.store.Bool(ptr + 8 + 13, false); 2908 A.store.Enum(ptr + 8 + 0, -1); 2909 A.store.Bool(ptr + 8 + 12, false); 2910 A.store.Int32(ptr + 8 + 4, 0); 2911 A.store.Ref(ptr + 8 + 8, undefined); 2912 A.store.Ref(ptr + 24, undefined); 2913 A.store.Bool(ptr + 116, false); 2914 A.store.Int32(ptr + 28, 0); 2915 A.store.Bool(ptr + 117, false); 2916 A.store.Int32(ptr + 32, 0); 2917 A.store.Ref(ptr + 36, undefined); 2918 A.store.Bool(ptr + 118, false); 2919 A.store.Int32(ptr + 40, 0); 2920 A.store.Bool(ptr + 119, false); 2921 A.store.Int32(ptr + 44, 0); 2922 A.store.Bool(ptr + 120, false); 2923 A.store.Int32(ptr + 48, 0); 2924 A.store.Bool(ptr + 121, false); 2925 A.store.Float64(ptr + 56, 0); 2926 A.store.Bool(ptr + 122, false); 2927 A.store.Int32(ptr + 64, 0); 2928 A.store.Bool(ptr + 123, false); 2929 A.store.Bool(ptr + 68, false); 2930 A.store.Ref(ptr + 72, undefined); 2931 2932 A.store.Bool(ptr + 76 + 30, false); 2933 2934 A.store.Bool(ptr + 76 + 0 + 14, false); 2935 A.store.Ref(ptr + 76 + 0 + 0, undefined); 2936 A.store.Bool(ptr + 76 + 0 + 12, false); 2937 A.store.Bool(ptr + 76 + 0 + 4, false); 2938 A.store.Bool(ptr + 76 + 0 + 13, false); 2939 A.store.Bool(ptr + 76 + 0 + 5, false); 2940 A.store.Ref(ptr + 76 + 0 + 8, undefined); 2941 2942 A.store.Bool(ptr + 76 + 16 + 13, false); 2943 A.store.Enum(ptr + 76 + 16 + 0, -1); 2944 A.store.Bool(ptr + 76 + 16 + 12, false); 2945 A.store.Int32(ptr + 76 + 16 + 4, 0); 2946 A.store.Ref(ptr + 76 + 16 + 8, undefined); 2947 A.store.Ref(ptr + 108, undefined); 2948 A.store.Ref(ptr + 112, undefined); 2949 } else { 2950 A.store.Bool(ptr + 124, true); 2951 A.store.Enum( 2952 ptr + 0, 2953 [ 2954 "copy", 2955 "delete", 2956 "empty_trash", 2957 "extract", 2958 "move", 2959 "restore", 2960 "restore_to_destination", 2961 "trash", 2962 "zip", 2963 ].indexOf(x["type"] as string) 2964 ); 2965 A.store.Enum( 2966 ptr + 4, 2967 ["queued", "scanning", "in_progress", "paused", "success", "error", "need_password", "cancelled"].indexOf( 2968 x["state"] as string 2969 ) 2970 ); 2971 2972 if (typeof x["policyError"] === "undefined") { 2973 A.store.Bool(ptr + 8 + 13, false); 2974 A.store.Enum(ptr + 8 + 0, -1); 2975 A.store.Bool(ptr + 8 + 12, false); 2976 A.store.Int32(ptr + 8 + 4, 0); 2977 A.store.Ref(ptr + 8 + 8, undefined); 2978 } else { 2979 A.store.Bool(ptr + 8 + 13, true); 2980 A.store.Enum( 2981 ptr + 8 + 0, 2982 ["dlp", "enterprise_connectors", "dlp_warning_timeout"].indexOf(x["policyError"]["type"] as string) 2983 ); 2984 A.store.Bool(ptr + 8 + 12, "policyFileCount" in x["policyError"] ? true : false); 2985 A.store.Int32( 2986 ptr + 8 + 4, 2987 x["policyError"]["policyFileCount"] === undefined ? 0 : (x["policyError"]["policyFileCount"] as number) 2988 ); 2989 A.store.Ref(ptr + 8 + 8, x["policyError"]["fileName"]); 2990 } 2991 A.store.Ref(ptr + 24, x["sourceName"]); 2992 A.store.Bool(ptr + 116, "numRemainingItems" in x ? true : false); 2993 A.store.Int32(ptr + 28, x["numRemainingItems"] === undefined ? 0 : (x["numRemainingItems"] as number)); 2994 A.store.Bool(ptr + 117, "itemCount" in x ? true : false); 2995 A.store.Int32(ptr + 32, x["itemCount"] === undefined ? 0 : (x["itemCount"] as number)); 2996 A.store.Ref(ptr + 36, x["destinationName"]); 2997 A.store.Bool(ptr + 118, "bytesTransferred" in x ? true : false); 2998 A.store.Int32(ptr + 40, x["bytesTransferred"] === undefined ? 0 : (x["bytesTransferred"] as number)); 2999 A.store.Bool(ptr + 119, "totalBytes" in x ? true : false); 3000 A.store.Int32(ptr + 44, x["totalBytes"] === undefined ? 0 : (x["totalBytes"] as number)); 3001 A.store.Bool(ptr + 120, "taskId" in x ? true : false); 3002 A.store.Int32(ptr + 48, x["taskId"] === undefined ? 0 : (x["taskId"] as number)); 3003 A.store.Bool(ptr + 121, "remainingSeconds" in x ? true : false); 3004 A.store.Float64(ptr + 56, x["remainingSeconds"] === undefined ? 0 : (x["remainingSeconds"] as number)); 3005 A.store.Bool(ptr + 122, "sourcesScanned" in x ? true : false); 3006 A.store.Int32(ptr + 64, x["sourcesScanned"] === undefined ? 0 : (x["sourcesScanned"] as number)); 3007 A.store.Bool(ptr + 123, "showNotification" in x ? true : false); 3008 A.store.Bool(ptr + 68, x["showNotification"] ? true : false); 3009 A.store.Ref(ptr + 72, x["errorName"]); 3010 3011 if (typeof x["pauseParams"] === "undefined") { 3012 A.store.Bool(ptr + 76 + 30, false); 3013 3014 A.store.Bool(ptr + 76 + 0 + 14, false); 3015 A.store.Ref(ptr + 76 + 0 + 0, undefined); 3016 A.store.Bool(ptr + 76 + 0 + 12, false); 3017 A.store.Bool(ptr + 76 + 0 + 4, false); 3018 A.store.Bool(ptr + 76 + 0 + 13, false); 3019 A.store.Bool(ptr + 76 + 0 + 5, false); 3020 A.store.Ref(ptr + 76 + 0 + 8, undefined); 3021 3022 A.store.Bool(ptr + 76 + 16 + 13, false); 3023 A.store.Enum(ptr + 76 + 16 + 0, -1); 3024 A.store.Bool(ptr + 76 + 16 + 12, false); 3025 A.store.Int32(ptr + 76 + 16 + 4, 0); 3026 A.store.Ref(ptr + 76 + 16 + 8, undefined); 3027 } else { 3028 A.store.Bool(ptr + 76 + 30, true); 3029 3030 if (typeof x["pauseParams"]["conflictParams"] === "undefined") { 3031 A.store.Bool(ptr + 76 + 0 + 14, false); 3032 A.store.Ref(ptr + 76 + 0 + 0, undefined); 3033 A.store.Bool(ptr + 76 + 0 + 12, false); 3034 A.store.Bool(ptr + 76 + 0 + 4, false); 3035 A.store.Bool(ptr + 76 + 0 + 13, false); 3036 A.store.Bool(ptr + 76 + 0 + 5, false); 3037 A.store.Ref(ptr + 76 + 0 + 8, undefined); 3038 } else { 3039 A.store.Bool(ptr + 76 + 0 + 14, true); 3040 A.store.Ref(ptr + 76 + 0 + 0, x["pauseParams"]["conflictParams"]["conflictName"]); 3041 A.store.Bool(ptr + 76 + 0 + 12, "conflictIsDirectory" in x["pauseParams"]["conflictParams"] ? true : false); 3042 A.store.Bool(ptr + 76 + 0 + 4, x["pauseParams"]["conflictParams"]["conflictIsDirectory"] ? true : false); 3043 A.store.Bool(ptr + 76 + 0 + 13, "conflictMultiple" in x["pauseParams"]["conflictParams"] ? true : false); 3044 A.store.Bool(ptr + 76 + 0 + 5, x["pauseParams"]["conflictParams"]["conflictMultiple"] ? true : false); 3045 A.store.Ref(ptr + 76 + 0 + 8, x["pauseParams"]["conflictParams"]["conflictTargetUrl"]); 3046 } 3047 3048 if (typeof x["pauseParams"]["policyParams"] === "undefined") { 3049 A.store.Bool(ptr + 76 + 16 + 13, false); 3050 A.store.Enum(ptr + 76 + 16 + 0, -1); 3051 A.store.Bool(ptr + 76 + 16 + 12, false); 3052 A.store.Int32(ptr + 76 + 16 + 4, 0); 3053 A.store.Ref(ptr + 76 + 16 + 8, undefined); 3054 } else { 3055 A.store.Bool(ptr + 76 + 16 + 13, true); 3056 A.store.Enum( 3057 ptr + 76 + 16 + 0, 3058 ["dlp", "enterprise_connectors", "dlp_warning_timeout"].indexOf( 3059 x["pauseParams"]["policyParams"]["type"] as string 3060 ) 3061 ); 3062 A.store.Bool(ptr + 76 + 16 + 12, "policyFileCount" in x["pauseParams"]["policyParams"] ? true : false); 3063 A.store.Int32( 3064 ptr + 76 + 16 + 4, 3065 x["pauseParams"]["policyParams"]["policyFileCount"] === undefined 3066 ? 0 3067 : (x["pauseParams"]["policyParams"]["policyFileCount"] as number) 3068 ); 3069 A.store.Ref(ptr + 76 + 16 + 8, x["pauseParams"]["policyParams"]["fileName"]); 3070 } 3071 } 3072 A.store.Ref(ptr + 108, x["outputs"]); 3073 A.store.Ref(ptr + 112, x["destinationVolumeId"]); 3074 } 3075 }, 3076 "load_ProgressStatus": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 3077 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 3078 3079 x["type"] = A.load.Enum(ptr + 0, [ 3080 "copy", 3081 "delete", 3082 "empty_trash", 3083 "extract", 3084 "move", 3085 "restore", 3086 "restore_to_destination", 3087 "trash", 3088 "zip", 3089 ]); 3090 x["state"] = A.load.Enum(ptr + 4, [ 3091 "queued", 3092 "scanning", 3093 "in_progress", 3094 "paused", 3095 "success", 3096 "error", 3097 "need_password", 3098 "cancelled", 3099 ]); 3100 if (A.load.Bool(ptr + 8 + 13)) { 3101 x["policyError"] = {}; 3102 x["policyError"]["type"] = A.load.Enum(ptr + 8 + 0, ["dlp", "enterprise_connectors", "dlp_warning_timeout"]); 3103 if (A.load.Bool(ptr + 8 + 12)) { 3104 x["policyError"]["policyFileCount"] = A.load.Int32(ptr + 8 + 4); 3105 } else { 3106 delete x["policyError"]["policyFileCount"]; 3107 } 3108 x["policyError"]["fileName"] = A.load.Ref(ptr + 8 + 8, undefined); 3109 } else { 3110 delete x["policyError"]; 3111 } 3112 x["sourceName"] = A.load.Ref(ptr + 24, undefined); 3113 if (A.load.Bool(ptr + 116)) { 3114 x["numRemainingItems"] = A.load.Int32(ptr + 28); 3115 } else { 3116 delete x["numRemainingItems"]; 3117 } 3118 if (A.load.Bool(ptr + 117)) { 3119 x["itemCount"] = A.load.Int32(ptr + 32); 3120 } else { 3121 delete x["itemCount"]; 3122 } 3123 x["destinationName"] = A.load.Ref(ptr + 36, undefined); 3124 if (A.load.Bool(ptr + 118)) { 3125 x["bytesTransferred"] = A.load.Int32(ptr + 40); 3126 } else { 3127 delete x["bytesTransferred"]; 3128 } 3129 if (A.load.Bool(ptr + 119)) { 3130 x["totalBytes"] = A.load.Int32(ptr + 44); 3131 } else { 3132 delete x["totalBytes"]; 3133 } 3134 if (A.load.Bool(ptr + 120)) { 3135 x["taskId"] = A.load.Int32(ptr + 48); 3136 } else { 3137 delete x["taskId"]; 3138 } 3139 if (A.load.Bool(ptr + 121)) { 3140 x["remainingSeconds"] = A.load.Float64(ptr + 56); 3141 } else { 3142 delete x["remainingSeconds"]; 3143 } 3144 if (A.load.Bool(ptr + 122)) { 3145 x["sourcesScanned"] = A.load.Int32(ptr + 64); 3146 } else { 3147 delete x["sourcesScanned"]; 3148 } 3149 if (A.load.Bool(ptr + 123)) { 3150 x["showNotification"] = A.load.Bool(ptr + 68); 3151 } else { 3152 delete x["showNotification"]; 3153 } 3154 x["errorName"] = A.load.Ref(ptr + 72, undefined); 3155 if (A.load.Bool(ptr + 76 + 30)) { 3156 x["pauseParams"] = {}; 3157 if (A.load.Bool(ptr + 76 + 0 + 14)) { 3158 x["pauseParams"]["conflictParams"] = {}; 3159 x["pauseParams"]["conflictParams"]["conflictName"] = A.load.Ref(ptr + 76 + 0 + 0, undefined); 3160 if (A.load.Bool(ptr + 76 + 0 + 12)) { 3161 x["pauseParams"]["conflictParams"]["conflictIsDirectory"] = A.load.Bool(ptr + 76 + 0 + 4); 3162 } else { 3163 delete x["pauseParams"]["conflictParams"]["conflictIsDirectory"]; 3164 } 3165 if (A.load.Bool(ptr + 76 + 0 + 13)) { 3166 x["pauseParams"]["conflictParams"]["conflictMultiple"] = A.load.Bool(ptr + 76 + 0 + 5); 3167 } else { 3168 delete x["pauseParams"]["conflictParams"]["conflictMultiple"]; 3169 } 3170 x["pauseParams"]["conflictParams"]["conflictTargetUrl"] = A.load.Ref(ptr + 76 + 0 + 8, undefined); 3171 } else { 3172 delete x["pauseParams"]["conflictParams"]; 3173 } 3174 if (A.load.Bool(ptr + 76 + 16 + 13)) { 3175 x["pauseParams"]["policyParams"] = {}; 3176 x["pauseParams"]["policyParams"]["type"] = A.load.Enum(ptr + 76 + 16 + 0, [ 3177 "dlp", 3178 "enterprise_connectors", 3179 "dlp_warning_timeout", 3180 ]); 3181 if (A.load.Bool(ptr + 76 + 16 + 12)) { 3182 x["pauseParams"]["policyParams"]["policyFileCount"] = A.load.Int32(ptr + 76 + 16 + 4); 3183 } else { 3184 delete x["pauseParams"]["policyParams"]["policyFileCount"]; 3185 } 3186 x["pauseParams"]["policyParams"]["fileName"] = A.load.Ref(ptr + 76 + 16 + 8, undefined); 3187 } else { 3188 delete x["pauseParams"]["policyParams"]; 3189 } 3190 } else { 3191 delete x["pauseParams"]; 3192 } 3193 x["outputs"] = A.load.Ref(ptr + 108, undefined); 3194 x["destinationVolumeId"] = A.load.Ref(ptr + 112, undefined); 3195 return create === A.H.TRUE ? A.H.push(x) : ref; 3196 }, 3197 3198 "store_ResumeParams": (ptr: Pointer, ref: heap.Ref<any>) => { 3199 const x = A.H.get<any>(ref); 3200 3201 if (typeof x === "undefined") { 3202 A.store.Bool(ptr + 13, false); 3203 3204 A.store.Bool(ptr + 0 + 6, false); 3205 A.store.Ref(ptr + 0 + 0, undefined); 3206 A.store.Bool(ptr + 0 + 5, false); 3207 A.store.Bool(ptr + 0 + 4, false); 3208 3209 A.store.Bool(ptr + 8 + 4, false); 3210 A.store.Enum(ptr + 8 + 0, -1); 3211 } else { 3212 A.store.Bool(ptr + 13, true); 3213 3214 if (typeof x["conflictParams"] === "undefined") { 3215 A.store.Bool(ptr + 0 + 6, false); 3216 A.store.Ref(ptr + 0 + 0, undefined); 3217 A.store.Bool(ptr + 0 + 5, false); 3218 A.store.Bool(ptr + 0 + 4, false); 3219 } else { 3220 A.store.Bool(ptr + 0 + 6, true); 3221 A.store.Ref(ptr + 0 + 0, x["conflictParams"]["conflictResolve"]); 3222 A.store.Bool(ptr + 0 + 5, "conflictApplyToAll" in x["conflictParams"] ? true : false); 3223 A.store.Bool(ptr + 0 + 4, x["conflictParams"]["conflictApplyToAll"] ? true : false); 3224 } 3225 3226 if (typeof x["policyParams"] === "undefined") { 3227 A.store.Bool(ptr + 8 + 4, false); 3228 A.store.Enum(ptr + 8 + 0, -1); 3229 } else { 3230 A.store.Bool(ptr + 8 + 4, true); 3231 A.store.Enum( 3232 ptr + 8 + 0, 3233 ["dlp", "enterprise_connectors", "dlp_warning_timeout"].indexOf(x["policyParams"]["type"] as string) 3234 ); 3235 } 3236 } 3237 }, 3238 "load_ResumeParams": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 3239 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 3240 3241 if (A.load.Bool(ptr + 0 + 6)) { 3242 x["conflictParams"] = {}; 3243 x["conflictParams"]["conflictResolve"] = A.load.Ref(ptr + 0 + 0, undefined); 3244 if (A.load.Bool(ptr + 0 + 5)) { 3245 x["conflictParams"]["conflictApplyToAll"] = A.load.Bool(ptr + 0 + 4); 3246 } else { 3247 delete x["conflictParams"]["conflictApplyToAll"]; 3248 } 3249 } else { 3250 delete x["conflictParams"]; 3251 } 3252 if (A.load.Bool(ptr + 8 + 4)) { 3253 x["policyParams"] = {}; 3254 x["policyParams"]["type"] = A.load.Enum(ptr + 8 + 0, ["dlp", "enterprise_connectors", "dlp_warning_timeout"]); 3255 } else { 3256 delete x["policyParams"]; 3257 } 3258 return create === A.H.TRUE ? A.H.push(x) : ref; 3259 }, 3260 "constof_SearchType": (ref: heap.Ref<string>): number => { 3261 const idx = ["EXCLUDE_DIRECTORIES", "SHARED_WITH_ME", "OFFLINE", "ALL"].indexOf(A.H.get(ref)); 3262 return idx < 0 ? 0 : idx + 1; 3263 }, 3264 3265 "store_SearchMetadataParams": (ptr: Pointer, ref: heap.Ref<any>) => { 3266 const x = A.H.get<any>(ref); 3267 3268 if (typeof x === "undefined") { 3269 A.store.Bool(ptr + 30, false); 3270 A.store.Ref(ptr + 0, undefined); 3271 A.store.Ref(ptr + 4, undefined); 3272 A.store.Enum(ptr + 8, -1); 3273 A.store.Bool(ptr + 28, false); 3274 A.store.Int32(ptr + 12, 0); 3275 A.store.Bool(ptr + 29, false); 3276 A.store.Float64(ptr + 16, 0); 3277 A.store.Enum(ptr + 24, -1); 3278 } else { 3279 A.store.Bool(ptr + 30, true); 3280 A.store.Ref(ptr + 0, x["rootDir"]); 3281 A.store.Ref(ptr + 4, x["query"]); 3282 A.store.Enum( 3283 ptr + 8, 3284 ["EXCLUDE_DIRECTORIES", "SHARED_WITH_ME", "OFFLINE", "ALL"].indexOf(x["types"] as string) 3285 ); 3286 A.store.Bool(ptr + 28, "maxResults" in x ? true : false); 3287 A.store.Int32(ptr + 12, x["maxResults"] === undefined ? 0 : (x["maxResults"] as number)); 3288 A.store.Bool(ptr + 29, "modifiedTimestamp" in x ? true : false); 3289 A.store.Float64(ptr + 16, x["modifiedTimestamp"] === undefined ? 0 : (x["modifiedTimestamp"] as number)); 3290 A.store.Enum(ptr + 24, ["all", "audio", "image", "video", "document"].indexOf(x["category"] as string)); 3291 } 3292 }, 3293 "load_SearchMetadataParams": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 3294 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 3295 3296 x["rootDir"] = A.load.Ref(ptr + 0, undefined); 3297 x["query"] = A.load.Ref(ptr + 4, undefined); 3298 x["types"] = A.load.Enum(ptr + 8, ["EXCLUDE_DIRECTORIES", "SHARED_WITH_ME", "OFFLINE", "ALL"]); 3299 if (A.load.Bool(ptr + 28)) { 3300 x["maxResults"] = A.load.Int32(ptr + 12); 3301 } else { 3302 delete x["maxResults"]; 3303 } 3304 if (A.load.Bool(ptr + 29)) { 3305 x["modifiedTimestamp"] = A.load.Float64(ptr + 16); 3306 } else { 3307 delete x["modifiedTimestamp"]; 3308 } 3309 x["category"] = A.load.Enum(ptr + 24, ["all", "audio", "image", "video", "document"]); 3310 return create === A.H.TRUE ? A.H.push(x) : ref; 3311 }, 3312 3313 "store_SearchParams": (ptr: Pointer, ref: heap.Ref<any>) => { 3314 const x = A.H.get<any>(ref); 3315 3316 if (typeof x === "undefined") { 3317 A.store.Bool(ptr + 21, false); 3318 A.store.Ref(ptr + 0, undefined); 3319 A.store.Enum(ptr + 4, -1); 3320 A.store.Bool(ptr + 20, false); 3321 A.store.Float64(ptr + 8, 0); 3322 A.store.Ref(ptr + 16, undefined); 3323 } else { 3324 A.store.Bool(ptr + 21, true); 3325 A.store.Ref(ptr + 0, x["query"]); 3326 A.store.Enum(ptr + 4, ["all", "audio", "image", "video", "document"].indexOf(x["category"] as string)); 3327 A.store.Bool(ptr + 20, "modifiedTimestamp" in x ? true : false); 3328 A.store.Float64(ptr + 8, x["modifiedTimestamp"] === undefined ? 0 : (x["modifiedTimestamp"] as number)); 3329 A.store.Ref(ptr + 16, x["nextFeed"]); 3330 } 3331 }, 3332 "load_SearchParams": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 3333 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 3334 3335 x["query"] = A.load.Ref(ptr + 0, undefined); 3336 x["category"] = A.load.Enum(ptr + 4, ["all", "audio", "image", "video", "document"]); 3337 if (A.load.Bool(ptr + 20)) { 3338 x["modifiedTimestamp"] = A.load.Float64(ptr + 8); 3339 } else { 3340 delete x["modifiedTimestamp"]; 3341 } 3342 x["nextFeed"] = A.load.Ref(ptr + 16, undefined); 3343 return create === A.H.TRUE ? A.H.push(x) : ref; 3344 }, 3345 "constof_SharesheetLaunchSource": (ref: heap.Ref<string>): number => { 3346 const idx = ["context_menu", "sharesheet_button", "unknown"].indexOf(A.H.get(ref)); 3347 return idx < 0 ? 0 : idx + 1; 3348 }, 3349 "constof_SourceRestriction": (ref: heap.Ref<string>): number => { 3350 const idx = ["any_source", "native_source"].indexOf(A.H.get(ref)); 3351 return idx < 0 ? 0 : idx + 1; 3352 }, 3353 3354 "store_SyncState": (ptr: Pointer, ref: heap.Ref<any>) => { 3355 const x = A.H.get<any>(ref); 3356 3357 if (typeof x === "undefined") { 3358 A.store.Bool(ptr + 17, false); 3359 A.store.Ref(ptr + 0, undefined); 3360 A.store.Enum(ptr + 4, -1); 3361 A.store.Bool(ptr + 16, false); 3362 A.store.Float64(ptr + 8, 0); 3363 } else { 3364 A.store.Bool(ptr + 17, true); 3365 A.store.Ref(ptr + 0, x["fileUrl"]); 3366 A.store.Enum( 3367 ptr + 4, 3368 ["not_found", "queued", "in_progress", "completed", "error"].indexOf(x["syncStatus"] as string) 3369 ); 3370 A.store.Bool(ptr + 16, "progress" in x ? true : false); 3371 A.store.Float64(ptr + 8, x["progress"] === undefined ? 0 : (x["progress"] as number)); 3372 } 3373 }, 3374 "load_SyncState": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 3375 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 3376 3377 x["fileUrl"] = A.load.Ref(ptr + 0, undefined); 3378 x["syncStatus"] = A.load.Enum(ptr + 4, ["not_found", "queued", "in_progress", "completed", "error"]); 3379 if (A.load.Bool(ptr + 16)) { 3380 x["progress"] = A.load.Float64(ptr + 8); 3381 } else { 3382 delete x["progress"]; 3383 } 3384 return create === A.H.TRUE ? A.H.push(x) : ref; 3385 }, 3386 "constof_ZoomOperationType": (ref: heap.Ref<string>): number => { 3387 const idx = ["in", "out", "reset"].indexOf(A.H.get(ref)); 3388 return idx < 0 ? 0 : idx + 1; 3389 }, 3390 "has_AddFileWatch": (): heap.Ref<boolean> => { 3391 if (WEBEXT?.fileManagerPrivate && "addFileWatch" in WEBEXT?.fileManagerPrivate) { 3392 return A.H.TRUE; 3393 } 3394 return A.H.FALSE; 3395 }, 3396 "func_AddFileWatch": (fn: Pointer): void => { 3397 A.store.Ref(fn, WEBEXT.fileManagerPrivate.addFileWatch); 3398 }, 3399 "call_AddFileWatch": (retPtr: Pointer, entry: heap.Ref<object>): void => { 3400 const _ret = WEBEXT.fileManagerPrivate.addFileWatch(A.H.get<object>(entry)); 3401 A.store.Ref(retPtr, _ret); 3402 }, 3403 "try_AddFileWatch": (retPtr: Pointer, errPtr: Pointer, entry: heap.Ref<object>): heap.Ref<boolean> => { 3404 try { 3405 const _ret = WEBEXT.fileManagerPrivate.addFileWatch(A.H.get<object>(entry)); 3406 A.store.Ref(retPtr, _ret); 3407 return A.H.TRUE; 3408 } catch (err: any) { 3409 A.store.Ref(errPtr, err); 3410 return A.H.FALSE; 3411 } 3412 }, 3413 "has_AddMount": (): heap.Ref<boolean> => { 3414 if (WEBEXT?.fileManagerPrivate && "addMount" in WEBEXT?.fileManagerPrivate) { 3415 return A.H.TRUE; 3416 } 3417 return A.H.FALSE; 3418 }, 3419 "func_AddMount": (fn: Pointer): void => { 3420 A.store.Ref(fn, WEBEXT.fileManagerPrivate.addMount); 3421 }, 3422 "call_AddMount": (retPtr: Pointer, fileUrl: heap.Ref<object>, password: heap.Ref<object>): void => { 3423 const _ret = WEBEXT.fileManagerPrivate.addMount(A.H.get<object>(fileUrl), A.H.get<object>(password)); 3424 A.store.Ref(retPtr, _ret); 3425 }, 3426 "try_AddMount": ( 3427 retPtr: Pointer, 3428 errPtr: Pointer, 3429 fileUrl: heap.Ref<object>, 3430 password: heap.Ref<object> 3431 ): heap.Ref<boolean> => { 3432 try { 3433 const _ret = WEBEXT.fileManagerPrivate.addMount(A.H.get<object>(fileUrl), A.H.get<object>(password)); 3434 A.store.Ref(retPtr, _ret); 3435 return A.H.TRUE; 3436 } catch (err: any) { 3437 A.store.Ref(errPtr, err); 3438 return A.H.FALSE; 3439 } 3440 }, 3441 "has_AddProvidedFileSystem": (): heap.Ref<boolean> => { 3442 if (WEBEXT?.fileManagerPrivate && "addProvidedFileSystem" in WEBEXT?.fileManagerPrivate) { 3443 return A.H.TRUE; 3444 } 3445 return A.H.FALSE; 3446 }, 3447 "func_AddProvidedFileSystem": (fn: Pointer): void => { 3448 A.store.Ref(fn, WEBEXT.fileManagerPrivate.addProvidedFileSystem); 3449 }, 3450 "call_AddProvidedFileSystem": (retPtr: Pointer, providerId: heap.Ref<object>): void => { 3451 const _ret = WEBEXT.fileManagerPrivate.addProvidedFileSystem(A.H.get<object>(providerId)); 3452 A.store.Ref(retPtr, _ret); 3453 }, 3454 "try_AddProvidedFileSystem": ( 3455 retPtr: Pointer, 3456 errPtr: Pointer, 3457 providerId: heap.Ref<object> 3458 ): heap.Ref<boolean> => { 3459 try { 3460 const _ret = WEBEXT.fileManagerPrivate.addProvidedFileSystem(A.H.get<object>(providerId)); 3461 A.store.Ref(retPtr, _ret); 3462 return A.H.TRUE; 3463 } catch (err: any) { 3464 A.store.Ref(errPtr, err); 3465 return A.H.FALSE; 3466 } 3467 }, 3468 "has_CalculateBulkPinRequiredSpace": (): heap.Ref<boolean> => { 3469 if (WEBEXT?.fileManagerPrivate && "calculateBulkPinRequiredSpace" in WEBEXT?.fileManagerPrivate) { 3470 return A.H.TRUE; 3471 } 3472 return A.H.FALSE; 3473 }, 3474 "func_CalculateBulkPinRequiredSpace": (fn: Pointer): void => { 3475 A.store.Ref(fn, WEBEXT.fileManagerPrivate.calculateBulkPinRequiredSpace); 3476 }, 3477 "call_CalculateBulkPinRequiredSpace": (retPtr: Pointer): void => { 3478 const _ret = WEBEXT.fileManagerPrivate.calculateBulkPinRequiredSpace(); 3479 A.store.Ref(retPtr, _ret); 3480 }, 3481 "try_CalculateBulkPinRequiredSpace": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 3482 try { 3483 const _ret = WEBEXT.fileManagerPrivate.calculateBulkPinRequiredSpace(); 3484 A.store.Ref(retPtr, _ret); 3485 return A.H.TRUE; 3486 } catch (err: any) { 3487 A.store.Ref(errPtr, err); 3488 return A.H.FALSE; 3489 } 3490 }, 3491 "has_CancelDialog": (): heap.Ref<boolean> => { 3492 if (WEBEXT?.fileManagerPrivate && "cancelDialog" in WEBEXT?.fileManagerPrivate) { 3493 return A.H.TRUE; 3494 } 3495 return A.H.FALSE; 3496 }, 3497 "func_CancelDialog": (fn: Pointer): void => { 3498 A.store.Ref(fn, WEBEXT.fileManagerPrivate.cancelDialog); 3499 }, 3500 "call_CancelDialog": (retPtr: Pointer): void => { 3501 const _ret = WEBEXT.fileManagerPrivate.cancelDialog(); 3502 }, 3503 "try_CancelDialog": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 3504 try { 3505 const _ret = WEBEXT.fileManagerPrivate.cancelDialog(); 3506 return A.H.TRUE; 3507 } catch (err: any) { 3508 A.store.Ref(errPtr, err); 3509 return A.H.FALSE; 3510 } 3511 }, 3512 "has_CancelIOTask": (): heap.Ref<boolean> => { 3513 if (WEBEXT?.fileManagerPrivate && "cancelIOTask" in WEBEXT?.fileManagerPrivate) { 3514 return A.H.TRUE; 3515 } 3516 return A.H.FALSE; 3517 }, 3518 "func_CancelIOTask": (fn: Pointer): void => { 3519 A.store.Ref(fn, WEBEXT.fileManagerPrivate.cancelIOTask); 3520 }, 3521 "call_CancelIOTask": (retPtr: Pointer, taskId: number): void => { 3522 const _ret = WEBEXT.fileManagerPrivate.cancelIOTask(taskId); 3523 }, 3524 "try_CancelIOTask": (retPtr: Pointer, errPtr: Pointer, taskId: number): heap.Ref<boolean> => { 3525 try { 3526 const _ret = WEBEXT.fileManagerPrivate.cancelIOTask(taskId); 3527 return A.H.TRUE; 3528 } catch (err: any) { 3529 A.store.Ref(errPtr, err); 3530 return A.H.FALSE; 3531 } 3532 }, 3533 "has_CancelMounting": (): heap.Ref<boolean> => { 3534 if (WEBEXT?.fileManagerPrivate && "cancelMounting" in WEBEXT?.fileManagerPrivate) { 3535 return A.H.TRUE; 3536 } 3537 return A.H.FALSE; 3538 }, 3539 "func_CancelMounting": (fn: Pointer): void => { 3540 A.store.Ref(fn, WEBEXT.fileManagerPrivate.cancelMounting); 3541 }, 3542 "call_CancelMounting": (retPtr: Pointer, fileUrl: heap.Ref<object>): void => { 3543 const _ret = WEBEXT.fileManagerPrivate.cancelMounting(A.H.get<object>(fileUrl)); 3544 A.store.Ref(retPtr, _ret); 3545 }, 3546 "try_CancelMounting": (retPtr: Pointer, errPtr: Pointer, fileUrl: heap.Ref<object>): heap.Ref<boolean> => { 3547 try { 3548 const _ret = WEBEXT.fileManagerPrivate.cancelMounting(A.H.get<object>(fileUrl)); 3549 A.store.Ref(retPtr, _ret); 3550 return A.H.TRUE; 3551 } catch (err: any) { 3552 A.store.Ref(errPtr, err); 3553 return A.H.FALSE; 3554 } 3555 }, 3556 "has_ComputeChecksum": (): heap.Ref<boolean> => { 3557 if (WEBEXT?.fileManagerPrivate && "computeChecksum" in WEBEXT?.fileManagerPrivate) { 3558 return A.H.TRUE; 3559 } 3560 return A.H.FALSE; 3561 }, 3562 "func_ComputeChecksum": (fn: Pointer): void => { 3563 A.store.Ref(fn, WEBEXT.fileManagerPrivate.computeChecksum); 3564 }, 3565 "call_ComputeChecksum": (retPtr: Pointer, entry: heap.Ref<object>): void => { 3566 const _ret = WEBEXT.fileManagerPrivate.computeChecksum(A.H.get<object>(entry)); 3567 A.store.Ref(retPtr, _ret); 3568 }, 3569 "try_ComputeChecksum": (retPtr: Pointer, errPtr: Pointer, entry: heap.Ref<object>): heap.Ref<boolean> => { 3570 try { 3571 const _ret = WEBEXT.fileManagerPrivate.computeChecksum(A.H.get<object>(entry)); 3572 A.store.Ref(retPtr, _ret); 3573 return A.H.TRUE; 3574 } catch (err: any) { 3575 A.store.Ref(errPtr, err); 3576 return A.H.FALSE; 3577 } 3578 }, 3579 "has_ConfigureVolume": (): heap.Ref<boolean> => { 3580 if (WEBEXT?.fileManagerPrivate && "configureVolume" in WEBEXT?.fileManagerPrivate) { 3581 return A.H.TRUE; 3582 } 3583 return A.H.FALSE; 3584 }, 3585 "func_ConfigureVolume": (fn: Pointer): void => { 3586 A.store.Ref(fn, WEBEXT.fileManagerPrivate.configureVolume); 3587 }, 3588 "call_ConfigureVolume": (retPtr: Pointer, volumeId: heap.Ref<object>): void => { 3589 const _ret = WEBEXT.fileManagerPrivate.configureVolume(A.H.get<object>(volumeId)); 3590 A.store.Ref(retPtr, _ret); 3591 }, 3592 "try_ConfigureVolume": (retPtr: Pointer, errPtr: Pointer, volumeId: heap.Ref<object>): heap.Ref<boolean> => { 3593 try { 3594 const _ret = WEBEXT.fileManagerPrivate.configureVolume(A.H.get<object>(volumeId)); 3595 A.store.Ref(retPtr, _ret); 3596 return A.H.TRUE; 3597 } catch (err: any) { 3598 A.store.Ref(errPtr, err); 3599 return A.H.FALSE; 3600 } 3601 }, 3602 "has_DismissIOTask": (): heap.Ref<boolean> => { 3603 if (WEBEXT?.fileManagerPrivate && "dismissIOTask" in WEBEXT?.fileManagerPrivate) { 3604 return A.H.TRUE; 3605 } 3606 return A.H.FALSE; 3607 }, 3608 "func_DismissIOTask": (fn: Pointer): void => { 3609 A.store.Ref(fn, WEBEXT.fileManagerPrivate.dismissIOTask); 3610 }, 3611 "call_DismissIOTask": (retPtr: Pointer, taskId: number): void => { 3612 const _ret = WEBEXT.fileManagerPrivate.dismissIOTask(taskId); 3613 A.store.Ref(retPtr, _ret); 3614 }, 3615 "try_DismissIOTask": (retPtr: Pointer, errPtr: Pointer, taskId: number): heap.Ref<boolean> => { 3616 try { 3617 const _ret = WEBEXT.fileManagerPrivate.dismissIOTask(taskId); 3618 A.store.Ref(retPtr, _ret); 3619 return A.H.TRUE; 3620 } catch (err: any) { 3621 A.store.Ref(errPtr, err); 3622 return A.H.FALSE; 3623 } 3624 }, 3625 "has_EnableExternalFileScheme": (): heap.Ref<boolean> => { 3626 if (WEBEXT?.fileManagerPrivate && "enableExternalFileScheme" in WEBEXT?.fileManagerPrivate) { 3627 return A.H.TRUE; 3628 } 3629 return A.H.FALSE; 3630 }, 3631 "func_EnableExternalFileScheme": (fn: Pointer): void => { 3632 A.store.Ref(fn, WEBEXT.fileManagerPrivate.enableExternalFileScheme); 3633 }, 3634 "call_EnableExternalFileScheme": (retPtr: Pointer): void => { 3635 const _ret = WEBEXT.fileManagerPrivate.enableExternalFileScheme(); 3636 }, 3637 "try_EnableExternalFileScheme": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 3638 try { 3639 const _ret = WEBEXT.fileManagerPrivate.enableExternalFileScheme(); 3640 return A.H.TRUE; 3641 } catch (err: any) { 3642 A.store.Ref(errPtr, err); 3643 return A.H.FALSE; 3644 } 3645 }, 3646 "has_ExecuteCustomAction": (): heap.Ref<boolean> => { 3647 if (WEBEXT?.fileManagerPrivate && "executeCustomAction" in WEBEXT?.fileManagerPrivate) { 3648 return A.H.TRUE; 3649 } 3650 return A.H.FALSE; 3651 }, 3652 "func_ExecuteCustomAction": (fn: Pointer): void => { 3653 A.store.Ref(fn, WEBEXT.fileManagerPrivate.executeCustomAction); 3654 }, 3655 "call_ExecuteCustomAction": (retPtr: Pointer, entries: heap.Ref<object>, actionId: heap.Ref<object>): void => { 3656 const _ret = WEBEXT.fileManagerPrivate.executeCustomAction(A.H.get<object>(entries), A.H.get<object>(actionId)); 3657 A.store.Ref(retPtr, _ret); 3658 }, 3659 "try_ExecuteCustomAction": ( 3660 retPtr: Pointer, 3661 errPtr: Pointer, 3662 entries: heap.Ref<object>, 3663 actionId: heap.Ref<object> 3664 ): heap.Ref<boolean> => { 3665 try { 3666 const _ret = WEBEXT.fileManagerPrivate.executeCustomAction(A.H.get<object>(entries), A.H.get<object>(actionId)); 3667 A.store.Ref(retPtr, _ret); 3668 return A.H.TRUE; 3669 } catch (err: any) { 3670 A.store.Ref(errPtr, err); 3671 return A.H.FALSE; 3672 } 3673 }, 3674 "has_ExecuteTask": (): heap.Ref<boolean> => { 3675 if (WEBEXT?.fileManagerPrivate && "executeTask" in WEBEXT?.fileManagerPrivate) { 3676 return A.H.TRUE; 3677 } 3678 return A.H.FALSE; 3679 }, 3680 "func_ExecuteTask": (fn: Pointer): void => { 3681 A.store.Ref(fn, WEBEXT.fileManagerPrivate.executeTask); 3682 }, 3683 "call_ExecuteTask": (retPtr: Pointer, descriptor: Pointer, entries: heap.Ref<object>): void => { 3684 const descriptor_ffi = {}; 3685 3686 descriptor_ffi["appId"] = A.load.Ref(descriptor + 0, undefined); 3687 descriptor_ffi["taskType"] = A.load.Ref(descriptor + 4, undefined); 3688 descriptor_ffi["actionId"] = A.load.Ref(descriptor + 8, undefined); 3689 3690 const _ret = WEBEXT.fileManagerPrivate.executeTask(descriptor_ffi, A.H.get<object>(entries)); 3691 A.store.Ref(retPtr, _ret); 3692 }, 3693 "try_ExecuteTask": ( 3694 retPtr: Pointer, 3695 errPtr: Pointer, 3696 descriptor: Pointer, 3697 entries: heap.Ref<object> 3698 ): heap.Ref<boolean> => { 3699 try { 3700 const descriptor_ffi = {}; 3701 3702 descriptor_ffi["appId"] = A.load.Ref(descriptor + 0, undefined); 3703 descriptor_ffi["taskType"] = A.load.Ref(descriptor + 4, undefined); 3704 descriptor_ffi["actionId"] = A.load.Ref(descriptor + 8, undefined); 3705 3706 const _ret = WEBEXT.fileManagerPrivate.executeTask(descriptor_ffi, A.H.get<object>(entries)); 3707 A.store.Ref(retPtr, _ret); 3708 return A.H.TRUE; 3709 } catch (err: any) { 3710 A.store.Ref(errPtr, err); 3711 return A.H.FALSE; 3712 } 3713 }, 3714 "has_FormatVolume": (): heap.Ref<boolean> => { 3715 if (WEBEXT?.fileManagerPrivate && "formatVolume" in WEBEXT?.fileManagerPrivate) { 3716 return A.H.TRUE; 3717 } 3718 return A.H.FALSE; 3719 }, 3720 "func_FormatVolume": (fn: Pointer): void => { 3721 A.store.Ref(fn, WEBEXT.fileManagerPrivate.formatVolume); 3722 }, 3723 "call_FormatVolume": ( 3724 retPtr: Pointer, 3725 volumeId: heap.Ref<object>, 3726 filesystem: number, 3727 volumeLabel: heap.Ref<object> 3728 ): void => { 3729 const _ret = WEBEXT.fileManagerPrivate.formatVolume( 3730 A.H.get<object>(volumeId), 3731 filesystem > 0 && filesystem <= 3 ? ["vfat", "exfat", "ntfs"][filesystem - 1] : undefined, 3732 A.H.get<object>(volumeLabel) 3733 ); 3734 }, 3735 "try_FormatVolume": ( 3736 retPtr: Pointer, 3737 errPtr: Pointer, 3738 volumeId: heap.Ref<object>, 3739 filesystem: number, 3740 volumeLabel: heap.Ref<object> 3741 ): heap.Ref<boolean> => { 3742 try { 3743 const _ret = WEBEXT.fileManagerPrivate.formatVolume( 3744 A.H.get<object>(volumeId), 3745 filesystem > 0 && filesystem <= 3 ? ["vfat", "exfat", "ntfs"][filesystem - 1] : undefined, 3746 A.H.get<object>(volumeLabel) 3747 ); 3748 return A.H.TRUE; 3749 } catch (err: any) { 3750 A.store.Ref(errPtr, err); 3751 return A.H.FALSE; 3752 } 3753 }, 3754 "has_GetAndroidPickerApps": (): heap.Ref<boolean> => { 3755 if (WEBEXT?.fileManagerPrivate && "getAndroidPickerApps" in WEBEXT?.fileManagerPrivate) { 3756 return A.H.TRUE; 3757 } 3758 return A.H.FALSE; 3759 }, 3760 "func_GetAndroidPickerApps": (fn: Pointer): void => { 3761 A.store.Ref(fn, WEBEXT.fileManagerPrivate.getAndroidPickerApps); 3762 }, 3763 "call_GetAndroidPickerApps": (retPtr: Pointer, extensions: heap.Ref<object>): void => { 3764 const _ret = WEBEXT.fileManagerPrivate.getAndroidPickerApps(A.H.get<object>(extensions)); 3765 A.store.Ref(retPtr, _ret); 3766 }, 3767 "try_GetAndroidPickerApps": (retPtr: Pointer, errPtr: Pointer, extensions: heap.Ref<object>): heap.Ref<boolean> => { 3768 try { 3769 const _ret = WEBEXT.fileManagerPrivate.getAndroidPickerApps(A.H.get<object>(extensions)); 3770 A.store.Ref(retPtr, _ret); 3771 return A.H.TRUE; 3772 } catch (err: any) { 3773 A.store.Ref(errPtr, err); 3774 return A.H.FALSE; 3775 } 3776 }, 3777 "has_GetBulkPinProgress": (): heap.Ref<boolean> => { 3778 if (WEBEXT?.fileManagerPrivate && "getBulkPinProgress" in WEBEXT?.fileManagerPrivate) { 3779 return A.H.TRUE; 3780 } 3781 return A.H.FALSE; 3782 }, 3783 "func_GetBulkPinProgress": (fn: Pointer): void => { 3784 A.store.Ref(fn, WEBEXT.fileManagerPrivate.getBulkPinProgress); 3785 }, 3786 "call_GetBulkPinProgress": (retPtr: Pointer): void => { 3787 const _ret = WEBEXT.fileManagerPrivate.getBulkPinProgress(); 3788 A.store.Ref(retPtr, _ret); 3789 }, 3790 "try_GetBulkPinProgress": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 3791 try { 3792 const _ret = WEBEXT.fileManagerPrivate.getBulkPinProgress(); 3793 A.store.Ref(retPtr, _ret); 3794 return A.H.TRUE; 3795 } catch (err: any) { 3796 A.store.Ref(errPtr, err); 3797 return A.H.FALSE; 3798 } 3799 }, 3800 "has_GetContentMetadata": (): heap.Ref<boolean> => { 3801 if (WEBEXT?.fileManagerPrivate && "getContentMetadata" in WEBEXT?.fileManagerPrivate) { 3802 return A.H.TRUE; 3803 } 3804 return A.H.FALSE; 3805 }, 3806 "func_GetContentMetadata": (fn: Pointer): void => { 3807 A.store.Ref(fn, WEBEXT.fileManagerPrivate.getContentMetadata); 3808 }, 3809 "call_GetContentMetadata": ( 3810 retPtr: Pointer, 3811 fileEntry: heap.Ref<object>, 3812 mimeType: heap.Ref<object>, 3813 includeImages: heap.Ref<boolean> 3814 ): void => { 3815 const _ret = WEBEXT.fileManagerPrivate.getContentMetadata( 3816 A.H.get<object>(fileEntry), 3817 A.H.get<object>(mimeType), 3818 includeImages === A.H.TRUE 3819 ); 3820 A.store.Ref(retPtr, _ret); 3821 }, 3822 "try_GetContentMetadata": ( 3823 retPtr: Pointer, 3824 errPtr: Pointer, 3825 fileEntry: heap.Ref<object>, 3826 mimeType: heap.Ref<object>, 3827 includeImages: heap.Ref<boolean> 3828 ): heap.Ref<boolean> => { 3829 try { 3830 const _ret = WEBEXT.fileManagerPrivate.getContentMetadata( 3831 A.H.get<object>(fileEntry), 3832 A.H.get<object>(mimeType), 3833 includeImages === A.H.TRUE 3834 ); 3835 A.store.Ref(retPtr, _ret); 3836 return A.H.TRUE; 3837 } catch (err: any) { 3838 A.store.Ref(errPtr, err); 3839 return A.H.FALSE; 3840 } 3841 }, 3842 "has_GetContentMimeType": (): heap.Ref<boolean> => { 3843 if (WEBEXT?.fileManagerPrivate && "getContentMimeType" in WEBEXT?.fileManagerPrivate) { 3844 return A.H.TRUE; 3845 } 3846 return A.H.FALSE; 3847 }, 3848 "func_GetContentMimeType": (fn: Pointer): void => { 3849 A.store.Ref(fn, WEBEXT.fileManagerPrivate.getContentMimeType); 3850 }, 3851 "call_GetContentMimeType": (retPtr: Pointer, fileEntry: heap.Ref<object>): void => { 3852 const _ret = WEBEXT.fileManagerPrivate.getContentMimeType(A.H.get<object>(fileEntry)); 3853 A.store.Ref(retPtr, _ret); 3854 }, 3855 "try_GetContentMimeType": (retPtr: Pointer, errPtr: Pointer, fileEntry: heap.Ref<object>): heap.Ref<boolean> => { 3856 try { 3857 const _ret = WEBEXT.fileManagerPrivate.getContentMimeType(A.H.get<object>(fileEntry)); 3858 A.store.Ref(retPtr, _ret); 3859 return A.H.TRUE; 3860 } catch (err: any) { 3861 A.store.Ref(errPtr, err); 3862 return A.H.FALSE; 3863 } 3864 }, 3865 "has_GetCrostiniSharedPaths": (): heap.Ref<boolean> => { 3866 if (WEBEXT?.fileManagerPrivate && "getCrostiniSharedPaths" in WEBEXT?.fileManagerPrivate) { 3867 return A.H.TRUE; 3868 } 3869 return A.H.FALSE; 3870 }, 3871 "func_GetCrostiniSharedPaths": (fn: Pointer): void => { 3872 A.store.Ref(fn, WEBEXT.fileManagerPrivate.getCrostiniSharedPaths); 3873 }, 3874 "call_GetCrostiniSharedPaths": ( 3875 retPtr: Pointer, 3876 observeFirstForSession: heap.Ref<boolean>, 3877 vmName: heap.Ref<object>, 3878 callback: heap.Ref<object> 3879 ): void => { 3880 const _ret = WEBEXT.fileManagerPrivate.getCrostiniSharedPaths( 3881 observeFirstForSession === A.H.TRUE, 3882 A.H.get<object>(vmName), 3883 A.H.get<object>(callback) 3884 ); 3885 }, 3886 "try_GetCrostiniSharedPaths": ( 3887 retPtr: Pointer, 3888 errPtr: Pointer, 3889 observeFirstForSession: heap.Ref<boolean>, 3890 vmName: heap.Ref<object>, 3891 callback: heap.Ref<object> 3892 ): heap.Ref<boolean> => { 3893 try { 3894 const _ret = WEBEXT.fileManagerPrivate.getCrostiniSharedPaths( 3895 observeFirstForSession === A.H.TRUE, 3896 A.H.get<object>(vmName), 3897 A.H.get<object>(callback) 3898 ); 3899 return A.H.TRUE; 3900 } catch (err: any) { 3901 A.store.Ref(errPtr, err); 3902 return A.H.FALSE; 3903 } 3904 }, 3905 "has_GetCustomActions": (): heap.Ref<boolean> => { 3906 if (WEBEXT?.fileManagerPrivate && "getCustomActions" in WEBEXT?.fileManagerPrivate) { 3907 return A.H.TRUE; 3908 } 3909 return A.H.FALSE; 3910 }, 3911 "func_GetCustomActions": (fn: Pointer): void => { 3912 A.store.Ref(fn, WEBEXT.fileManagerPrivate.getCustomActions); 3913 }, 3914 "call_GetCustomActions": (retPtr: Pointer, entries: heap.Ref<object>): void => { 3915 const _ret = WEBEXT.fileManagerPrivate.getCustomActions(A.H.get<object>(entries)); 3916 A.store.Ref(retPtr, _ret); 3917 }, 3918 "try_GetCustomActions": (retPtr: Pointer, errPtr: Pointer, entries: heap.Ref<object>): heap.Ref<boolean> => { 3919 try { 3920 const _ret = WEBEXT.fileManagerPrivate.getCustomActions(A.H.get<object>(entries)); 3921 A.store.Ref(retPtr, _ret); 3922 return A.H.TRUE; 3923 } catch (err: any) { 3924 A.store.Ref(errPtr, err); 3925 return A.H.FALSE; 3926 } 3927 }, 3928 "has_GetDeviceConnectionState": (): heap.Ref<boolean> => { 3929 if (WEBEXT?.fileManagerPrivate && "getDeviceConnectionState" in WEBEXT?.fileManagerPrivate) { 3930 return A.H.TRUE; 3931 } 3932 return A.H.FALSE; 3933 }, 3934 "func_GetDeviceConnectionState": (fn: Pointer): void => { 3935 A.store.Ref(fn, WEBEXT.fileManagerPrivate.getDeviceConnectionState); 3936 }, 3937 "call_GetDeviceConnectionState": (retPtr: Pointer, callback: heap.Ref<object>): void => { 3938 const _ret = WEBEXT.fileManagerPrivate.getDeviceConnectionState(A.H.get<object>(callback)); 3939 }, 3940 "try_GetDeviceConnectionState": ( 3941 retPtr: Pointer, 3942 errPtr: Pointer, 3943 callback: heap.Ref<object> 3944 ): heap.Ref<boolean> => { 3945 try { 3946 const _ret = WEBEXT.fileManagerPrivate.getDeviceConnectionState(A.H.get<object>(callback)); 3947 return A.H.TRUE; 3948 } catch (err: any) { 3949 A.store.Ref(errPtr, err); 3950 return A.H.FALSE; 3951 } 3952 }, 3953 "has_GetDialogCaller": (): heap.Ref<boolean> => { 3954 if (WEBEXT?.fileManagerPrivate && "getDialogCaller" in WEBEXT?.fileManagerPrivate) { 3955 return A.H.TRUE; 3956 } 3957 return A.H.FALSE; 3958 }, 3959 "func_GetDialogCaller": (fn: Pointer): void => { 3960 A.store.Ref(fn, WEBEXT.fileManagerPrivate.getDialogCaller); 3961 }, 3962 "call_GetDialogCaller": (retPtr: Pointer): void => { 3963 const _ret = WEBEXT.fileManagerPrivate.getDialogCaller(); 3964 A.store.Ref(retPtr, _ret); 3965 }, 3966 "try_GetDialogCaller": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 3967 try { 3968 const _ret = WEBEXT.fileManagerPrivate.getDialogCaller(); 3969 A.store.Ref(retPtr, _ret); 3970 return A.H.TRUE; 3971 } catch (err: any) { 3972 A.store.Ref(errPtr, err); 3973 return A.H.FALSE; 3974 } 3975 }, 3976 "has_GetDirectorySize": (): heap.Ref<boolean> => { 3977 if (WEBEXT?.fileManagerPrivate && "getDirectorySize" in WEBEXT?.fileManagerPrivate) { 3978 return A.H.TRUE; 3979 } 3980 return A.H.FALSE; 3981 }, 3982 "func_GetDirectorySize": (fn: Pointer): void => { 3983 A.store.Ref(fn, WEBEXT.fileManagerPrivate.getDirectorySize); 3984 }, 3985 "call_GetDirectorySize": (retPtr: Pointer, entry: heap.Ref<object>): void => { 3986 const _ret = WEBEXT.fileManagerPrivate.getDirectorySize(A.H.get<object>(entry)); 3987 A.store.Ref(retPtr, _ret); 3988 }, 3989 "try_GetDirectorySize": (retPtr: Pointer, errPtr: Pointer, entry: heap.Ref<object>): heap.Ref<boolean> => { 3990 try { 3991 const _ret = WEBEXT.fileManagerPrivate.getDirectorySize(A.H.get<object>(entry)); 3992 A.store.Ref(retPtr, _ret); 3993 return A.H.TRUE; 3994 } catch (err: any) { 3995 A.store.Ref(errPtr, err); 3996 return A.H.FALSE; 3997 } 3998 }, 3999 "has_GetDisallowedTransfers": (): heap.Ref<boolean> => { 4000 if (WEBEXT?.fileManagerPrivate && "getDisallowedTransfers" in WEBEXT?.fileManagerPrivate) { 4001 return A.H.TRUE; 4002 } 4003 return A.H.FALSE; 4004 }, 4005 "func_GetDisallowedTransfers": (fn: Pointer): void => { 4006 A.store.Ref(fn, WEBEXT.fileManagerPrivate.getDisallowedTransfers); 4007 }, 4008 "call_GetDisallowedTransfers": ( 4009 retPtr: Pointer, 4010 entries: heap.Ref<object>, 4011 destinationEntry: heap.Ref<object>, 4012 isMove: heap.Ref<boolean> 4013 ): void => { 4014 const _ret = WEBEXT.fileManagerPrivate.getDisallowedTransfers( 4015 A.H.get<object>(entries), 4016 A.H.get<object>(destinationEntry), 4017 isMove === A.H.TRUE 4018 ); 4019 A.store.Ref(retPtr, _ret); 4020 }, 4021 "try_GetDisallowedTransfers": ( 4022 retPtr: Pointer, 4023 errPtr: Pointer, 4024 entries: heap.Ref<object>, 4025 destinationEntry: heap.Ref<object>, 4026 isMove: heap.Ref<boolean> 4027 ): heap.Ref<boolean> => { 4028 try { 4029 const _ret = WEBEXT.fileManagerPrivate.getDisallowedTransfers( 4030 A.H.get<object>(entries), 4031 A.H.get<object>(destinationEntry), 4032 isMove === A.H.TRUE 4033 ); 4034 A.store.Ref(retPtr, _ret); 4035 return A.H.TRUE; 4036 } catch (err: any) { 4037 A.store.Ref(errPtr, err); 4038 return A.H.FALSE; 4039 } 4040 }, 4041 "has_GetDlpBlockedComponents": (): heap.Ref<boolean> => { 4042 if (WEBEXT?.fileManagerPrivate && "getDlpBlockedComponents" in WEBEXT?.fileManagerPrivate) { 4043 return A.H.TRUE; 4044 } 4045 return A.H.FALSE; 4046 }, 4047 "func_GetDlpBlockedComponents": (fn: Pointer): void => { 4048 A.store.Ref(fn, WEBEXT.fileManagerPrivate.getDlpBlockedComponents); 4049 }, 4050 "call_GetDlpBlockedComponents": (retPtr: Pointer, sourceUrl: heap.Ref<object>): void => { 4051 const _ret = WEBEXT.fileManagerPrivate.getDlpBlockedComponents(A.H.get<object>(sourceUrl)); 4052 A.store.Ref(retPtr, _ret); 4053 }, 4054 "try_GetDlpBlockedComponents": ( 4055 retPtr: Pointer, 4056 errPtr: Pointer, 4057 sourceUrl: heap.Ref<object> 4058 ): heap.Ref<boolean> => { 4059 try { 4060 const _ret = WEBEXT.fileManagerPrivate.getDlpBlockedComponents(A.H.get<object>(sourceUrl)); 4061 A.store.Ref(retPtr, _ret); 4062 return A.H.TRUE; 4063 } catch (err: any) { 4064 A.store.Ref(errPtr, err); 4065 return A.H.FALSE; 4066 } 4067 }, 4068 "has_GetDlpMetadata": (): heap.Ref<boolean> => { 4069 if (WEBEXT?.fileManagerPrivate && "getDlpMetadata" in WEBEXT?.fileManagerPrivate) { 4070 return A.H.TRUE; 4071 } 4072 return A.H.FALSE; 4073 }, 4074 "func_GetDlpMetadata": (fn: Pointer): void => { 4075 A.store.Ref(fn, WEBEXT.fileManagerPrivate.getDlpMetadata); 4076 }, 4077 "call_GetDlpMetadata": (retPtr: Pointer, entries: heap.Ref<object>): void => { 4078 const _ret = WEBEXT.fileManagerPrivate.getDlpMetadata(A.H.get<object>(entries)); 4079 A.store.Ref(retPtr, _ret); 4080 }, 4081 "try_GetDlpMetadata": (retPtr: Pointer, errPtr: Pointer, entries: heap.Ref<object>): heap.Ref<boolean> => { 4082 try { 4083 const _ret = WEBEXT.fileManagerPrivate.getDlpMetadata(A.H.get<object>(entries)); 4084 A.store.Ref(retPtr, _ret); 4085 return A.H.TRUE; 4086 } catch (err: any) { 4087 A.store.Ref(errPtr, err); 4088 return A.H.FALSE; 4089 } 4090 }, 4091 "has_GetDlpRestrictionDetails": (): heap.Ref<boolean> => { 4092 if (WEBEXT?.fileManagerPrivate && "getDlpRestrictionDetails" in WEBEXT?.fileManagerPrivate) { 4093 return A.H.TRUE; 4094 } 4095 return A.H.FALSE; 4096 }, 4097 "func_GetDlpRestrictionDetails": (fn: Pointer): void => { 4098 A.store.Ref(fn, WEBEXT.fileManagerPrivate.getDlpRestrictionDetails); 4099 }, 4100 "call_GetDlpRestrictionDetails": (retPtr: Pointer, sourceUrl: heap.Ref<object>): void => { 4101 const _ret = WEBEXT.fileManagerPrivate.getDlpRestrictionDetails(A.H.get<object>(sourceUrl)); 4102 A.store.Ref(retPtr, _ret); 4103 }, 4104 "try_GetDlpRestrictionDetails": ( 4105 retPtr: Pointer, 4106 errPtr: Pointer, 4107 sourceUrl: heap.Ref<object> 4108 ): heap.Ref<boolean> => { 4109 try { 4110 const _ret = WEBEXT.fileManagerPrivate.getDlpRestrictionDetails(A.H.get<object>(sourceUrl)); 4111 A.store.Ref(retPtr, _ret); 4112 return A.H.TRUE; 4113 } catch (err: any) { 4114 A.store.Ref(errPtr, err); 4115 return A.H.FALSE; 4116 } 4117 }, 4118 "has_GetDriveConnectionState": (): heap.Ref<boolean> => { 4119 if (WEBEXT?.fileManagerPrivate && "getDriveConnectionState" in WEBEXT?.fileManagerPrivate) { 4120 return A.H.TRUE; 4121 } 4122 return A.H.FALSE; 4123 }, 4124 "func_GetDriveConnectionState": (fn: Pointer): void => { 4125 A.store.Ref(fn, WEBEXT.fileManagerPrivate.getDriveConnectionState); 4126 }, 4127 "call_GetDriveConnectionState": (retPtr: Pointer): void => { 4128 const _ret = WEBEXT.fileManagerPrivate.getDriveConnectionState(); 4129 A.store.Ref(retPtr, _ret); 4130 }, 4131 "try_GetDriveConnectionState": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 4132 try { 4133 const _ret = WEBEXT.fileManagerPrivate.getDriveConnectionState(); 4134 A.store.Ref(retPtr, _ret); 4135 return A.H.TRUE; 4136 } catch (err: any) { 4137 A.store.Ref(errPtr, err); 4138 return A.H.FALSE; 4139 } 4140 }, 4141 "has_GetDriveQuotaMetadata": (): heap.Ref<boolean> => { 4142 if (WEBEXT?.fileManagerPrivate && "getDriveQuotaMetadata" in WEBEXT?.fileManagerPrivate) { 4143 return A.H.TRUE; 4144 } 4145 return A.H.FALSE; 4146 }, 4147 "func_GetDriveQuotaMetadata": (fn: Pointer): void => { 4148 A.store.Ref(fn, WEBEXT.fileManagerPrivate.getDriveQuotaMetadata); 4149 }, 4150 "call_GetDriveQuotaMetadata": (retPtr: Pointer, entry: heap.Ref<object>): void => { 4151 const _ret = WEBEXT.fileManagerPrivate.getDriveQuotaMetadata(A.H.get<object>(entry)); 4152 A.store.Ref(retPtr, _ret); 4153 }, 4154 "try_GetDriveQuotaMetadata": (retPtr: Pointer, errPtr: Pointer, entry: heap.Ref<object>): heap.Ref<boolean> => { 4155 try { 4156 const _ret = WEBEXT.fileManagerPrivate.getDriveQuotaMetadata(A.H.get<object>(entry)); 4157 A.store.Ref(retPtr, _ret); 4158 return A.H.TRUE; 4159 } catch (err: any) { 4160 A.store.Ref(errPtr, err); 4161 return A.H.FALSE; 4162 } 4163 }, 4164 "has_GetEntryProperties": (): heap.Ref<boolean> => { 4165 if (WEBEXT?.fileManagerPrivate && "getEntryProperties" in WEBEXT?.fileManagerPrivate) { 4166 return A.H.TRUE; 4167 } 4168 return A.H.FALSE; 4169 }, 4170 "func_GetEntryProperties": (fn: Pointer): void => { 4171 A.store.Ref(fn, WEBEXT.fileManagerPrivate.getEntryProperties); 4172 }, 4173 "call_GetEntryProperties": (retPtr: Pointer, entries: heap.Ref<object>, names: heap.Ref<object>): void => { 4174 const _ret = WEBEXT.fileManagerPrivate.getEntryProperties(A.H.get<object>(entries), A.H.get<object>(names)); 4175 A.store.Ref(retPtr, _ret); 4176 }, 4177 "try_GetEntryProperties": ( 4178 retPtr: Pointer, 4179 errPtr: Pointer, 4180 entries: heap.Ref<object>, 4181 names: heap.Ref<object> 4182 ): heap.Ref<boolean> => { 4183 try { 4184 const _ret = WEBEXT.fileManagerPrivate.getEntryProperties(A.H.get<object>(entries), A.H.get<object>(names)); 4185 A.store.Ref(retPtr, _ret); 4186 return A.H.TRUE; 4187 } catch (err: any) { 4188 A.store.Ref(errPtr, err); 4189 return A.H.FALSE; 4190 } 4191 }, 4192 "has_GetFileTasks": (): heap.Ref<boolean> => { 4193 if (WEBEXT?.fileManagerPrivate && "getFileTasks" in WEBEXT?.fileManagerPrivate) { 4194 return A.H.TRUE; 4195 } 4196 return A.H.FALSE; 4197 }, 4198 "func_GetFileTasks": (fn: Pointer): void => { 4199 A.store.Ref(fn, WEBEXT.fileManagerPrivate.getFileTasks); 4200 }, 4201 "call_GetFileTasks": (retPtr: Pointer, entries: heap.Ref<object>, dlpSourceUrls: heap.Ref<object>): void => { 4202 const _ret = WEBEXT.fileManagerPrivate.getFileTasks(A.H.get<object>(entries), A.H.get<object>(dlpSourceUrls)); 4203 A.store.Ref(retPtr, _ret); 4204 }, 4205 "try_GetFileTasks": ( 4206 retPtr: Pointer, 4207 errPtr: Pointer, 4208 entries: heap.Ref<object>, 4209 dlpSourceUrls: heap.Ref<object> 4210 ): heap.Ref<boolean> => { 4211 try { 4212 const _ret = WEBEXT.fileManagerPrivate.getFileTasks(A.H.get<object>(entries), A.H.get<object>(dlpSourceUrls)); 4213 A.store.Ref(retPtr, _ret); 4214 return A.H.TRUE; 4215 } catch (err: any) { 4216 A.store.Ref(errPtr, err); 4217 return A.H.FALSE; 4218 } 4219 }, 4220 "has_GetHoldingSpaceState": (): heap.Ref<boolean> => { 4221 if (WEBEXT?.fileManagerPrivate && "getHoldingSpaceState" in WEBEXT?.fileManagerPrivate) { 4222 return A.H.TRUE; 4223 } 4224 return A.H.FALSE; 4225 }, 4226 "func_GetHoldingSpaceState": (fn: Pointer): void => { 4227 A.store.Ref(fn, WEBEXT.fileManagerPrivate.getHoldingSpaceState); 4228 }, 4229 "call_GetHoldingSpaceState": (retPtr: Pointer): void => { 4230 const _ret = WEBEXT.fileManagerPrivate.getHoldingSpaceState(); 4231 A.store.Ref(retPtr, _ret); 4232 }, 4233 "try_GetHoldingSpaceState": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 4234 try { 4235 const _ret = WEBEXT.fileManagerPrivate.getHoldingSpaceState(); 4236 A.store.Ref(retPtr, _ret); 4237 return A.H.TRUE; 4238 } catch (err: any) { 4239 A.store.Ref(errPtr, err); 4240 return A.H.FALSE; 4241 } 4242 }, 4243 "has_GetLinuxPackageInfo": (): heap.Ref<boolean> => { 4244 if (WEBEXT?.fileManagerPrivate && "getLinuxPackageInfo" in WEBEXT?.fileManagerPrivate) { 4245 return A.H.TRUE; 4246 } 4247 return A.H.FALSE; 4248 }, 4249 "func_GetLinuxPackageInfo": (fn: Pointer): void => { 4250 A.store.Ref(fn, WEBEXT.fileManagerPrivate.getLinuxPackageInfo); 4251 }, 4252 "call_GetLinuxPackageInfo": (retPtr: Pointer, entry: heap.Ref<object>): void => { 4253 const _ret = WEBEXT.fileManagerPrivate.getLinuxPackageInfo(A.H.get<object>(entry)); 4254 A.store.Ref(retPtr, _ret); 4255 }, 4256 "try_GetLinuxPackageInfo": (retPtr: Pointer, errPtr: Pointer, entry: heap.Ref<object>): heap.Ref<boolean> => { 4257 try { 4258 const _ret = WEBEXT.fileManagerPrivate.getLinuxPackageInfo(A.H.get<object>(entry)); 4259 A.store.Ref(retPtr, _ret); 4260 return A.H.TRUE; 4261 } catch (err: any) { 4262 A.store.Ref(errPtr, err); 4263 return A.H.FALSE; 4264 } 4265 }, 4266 "has_GetMimeType": (): heap.Ref<boolean> => { 4267 if (WEBEXT?.fileManagerPrivate && "getMimeType" in WEBEXT?.fileManagerPrivate) { 4268 return A.H.TRUE; 4269 } 4270 return A.H.FALSE; 4271 }, 4272 "func_GetMimeType": (fn: Pointer): void => { 4273 A.store.Ref(fn, WEBEXT.fileManagerPrivate.getMimeType); 4274 }, 4275 "call_GetMimeType": (retPtr: Pointer, entry: heap.Ref<object>): void => { 4276 const _ret = WEBEXT.fileManagerPrivate.getMimeType(A.H.get<object>(entry)); 4277 A.store.Ref(retPtr, _ret); 4278 }, 4279 "try_GetMimeType": (retPtr: Pointer, errPtr: Pointer, entry: heap.Ref<object>): heap.Ref<boolean> => { 4280 try { 4281 const _ret = WEBEXT.fileManagerPrivate.getMimeType(A.H.get<object>(entry)); 4282 A.store.Ref(retPtr, _ret); 4283 return A.H.TRUE; 4284 } catch (err: any) { 4285 A.store.Ref(errPtr, err); 4286 return A.H.FALSE; 4287 } 4288 }, 4289 "has_GetPreferences": (): heap.Ref<boolean> => { 4290 if (WEBEXT?.fileManagerPrivate && "getPreferences" in WEBEXT?.fileManagerPrivate) { 4291 return A.H.TRUE; 4292 } 4293 return A.H.FALSE; 4294 }, 4295 "func_GetPreferences": (fn: Pointer): void => { 4296 A.store.Ref(fn, WEBEXT.fileManagerPrivate.getPreferences); 4297 }, 4298 "call_GetPreferences": (retPtr: Pointer): void => { 4299 const _ret = WEBEXT.fileManagerPrivate.getPreferences(); 4300 A.store.Ref(retPtr, _ret); 4301 }, 4302 "try_GetPreferences": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 4303 try { 4304 const _ret = WEBEXT.fileManagerPrivate.getPreferences(); 4305 A.store.Ref(retPtr, _ret); 4306 return A.H.TRUE; 4307 } catch (err: any) { 4308 A.store.Ref(errPtr, err); 4309 return A.H.FALSE; 4310 } 4311 }, 4312 "has_GetProfiles": (): heap.Ref<boolean> => { 4313 if (WEBEXT?.fileManagerPrivate && "getProfiles" in WEBEXT?.fileManagerPrivate) { 4314 return A.H.TRUE; 4315 } 4316 return A.H.FALSE; 4317 }, 4318 "func_GetProfiles": (fn: Pointer): void => { 4319 A.store.Ref(fn, WEBEXT.fileManagerPrivate.getProfiles); 4320 }, 4321 "call_GetProfiles": (retPtr: Pointer, callback: heap.Ref<object>): void => { 4322 const _ret = WEBEXT.fileManagerPrivate.getProfiles(A.H.get<object>(callback)); 4323 }, 4324 "try_GetProfiles": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 4325 try { 4326 const _ret = WEBEXT.fileManagerPrivate.getProfiles(A.H.get<object>(callback)); 4327 return A.H.TRUE; 4328 } catch (err: any) { 4329 A.store.Ref(errPtr, err); 4330 return A.H.FALSE; 4331 } 4332 }, 4333 "has_GetProviders": (): heap.Ref<boolean> => { 4334 if (WEBEXT?.fileManagerPrivate && "getProviders" in WEBEXT?.fileManagerPrivate) { 4335 return A.H.TRUE; 4336 } 4337 return A.H.FALSE; 4338 }, 4339 "func_GetProviders": (fn: Pointer): void => { 4340 A.store.Ref(fn, WEBEXT.fileManagerPrivate.getProviders); 4341 }, 4342 "call_GetProviders": (retPtr: Pointer): void => { 4343 const _ret = WEBEXT.fileManagerPrivate.getProviders(); 4344 A.store.Ref(retPtr, _ret); 4345 }, 4346 "try_GetProviders": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 4347 try { 4348 const _ret = WEBEXT.fileManagerPrivate.getProviders(); 4349 A.store.Ref(retPtr, _ret); 4350 return A.H.TRUE; 4351 } catch (err: any) { 4352 A.store.Ref(errPtr, err); 4353 return A.H.FALSE; 4354 } 4355 }, 4356 "has_GetRecentFiles": (): heap.Ref<boolean> => { 4357 if (WEBEXT?.fileManagerPrivate && "getRecentFiles" in WEBEXT?.fileManagerPrivate) { 4358 return A.H.TRUE; 4359 } 4360 return A.H.FALSE; 4361 }, 4362 "func_GetRecentFiles": (fn: Pointer): void => { 4363 A.store.Ref(fn, WEBEXT.fileManagerPrivate.getRecentFiles); 4364 }, 4365 "call_GetRecentFiles": ( 4366 retPtr: Pointer, 4367 restriction: number, 4368 fileCategory: number, 4369 invalidateCache: heap.Ref<boolean> 4370 ): void => { 4371 const _ret = WEBEXT.fileManagerPrivate.getRecentFiles( 4372 restriction > 0 && restriction <= 2 ? ["any_source", "native_source"][restriction - 1] : undefined, 4373 fileCategory > 0 && fileCategory <= 5 4374 ? ["all", "audio", "image", "video", "document"][fileCategory - 1] 4375 : undefined, 4376 invalidateCache === A.H.TRUE 4377 ); 4378 A.store.Ref(retPtr, _ret); 4379 }, 4380 "try_GetRecentFiles": ( 4381 retPtr: Pointer, 4382 errPtr: Pointer, 4383 restriction: number, 4384 fileCategory: number, 4385 invalidateCache: heap.Ref<boolean> 4386 ): heap.Ref<boolean> => { 4387 try { 4388 const _ret = WEBEXT.fileManagerPrivate.getRecentFiles( 4389 restriction > 0 && restriction <= 2 ? ["any_source", "native_source"][restriction - 1] : undefined, 4390 fileCategory > 0 && fileCategory <= 5 4391 ? ["all", "audio", "image", "video", "document"][fileCategory - 1] 4392 : undefined, 4393 invalidateCache === A.H.TRUE 4394 ); 4395 A.store.Ref(retPtr, _ret); 4396 return A.H.TRUE; 4397 } catch (err: any) { 4398 A.store.Ref(errPtr, err); 4399 return A.H.FALSE; 4400 } 4401 }, 4402 "has_GetSizeStats": (): heap.Ref<boolean> => { 4403 if (WEBEXT?.fileManagerPrivate && "getSizeStats" in WEBEXT?.fileManagerPrivate) { 4404 return A.H.TRUE; 4405 } 4406 return A.H.FALSE; 4407 }, 4408 "func_GetSizeStats": (fn: Pointer): void => { 4409 A.store.Ref(fn, WEBEXT.fileManagerPrivate.getSizeStats); 4410 }, 4411 "call_GetSizeStats": (retPtr: Pointer, volumeId: heap.Ref<object>): void => { 4412 const _ret = WEBEXT.fileManagerPrivate.getSizeStats(A.H.get<object>(volumeId)); 4413 A.store.Ref(retPtr, _ret); 4414 }, 4415 "try_GetSizeStats": (retPtr: Pointer, errPtr: Pointer, volumeId: heap.Ref<object>): heap.Ref<boolean> => { 4416 try { 4417 const _ret = WEBEXT.fileManagerPrivate.getSizeStats(A.H.get<object>(volumeId)); 4418 A.store.Ref(retPtr, _ret); 4419 return A.H.TRUE; 4420 } catch (err: any) { 4421 A.store.Ref(errPtr, err); 4422 return A.H.FALSE; 4423 } 4424 }, 4425 "has_GetStrings": (): heap.Ref<boolean> => { 4426 if (WEBEXT?.fileManagerPrivate && "getStrings" in WEBEXT?.fileManagerPrivate) { 4427 return A.H.TRUE; 4428 } 4429 return A.H.FALSE; 4430 }, 4431 "func_GetStrings": (fn: Pointer): void => { 4432 A.store.Ref(fn, WEBEXT.fileManagerPrivate.getStrings); 4433 }, 4434 "call_GetStrings": (retPtr: Pointer): void => { 4435 const _ret = WEBEXT.fileManagerPrivate.getStrings(); 4436 A.store.Ref(retPtr, _ret); 4437 }, 4438 "try_GetStrings": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 4439 try { 4440 const _ret = WEBEXT.fileManagerPrivate.getStrings(); 4441 A.store.Ref(retPtr, _ret); 4442 return A.H.TRUE; 4443 } catch (err: any) { 4444 A.store.Ref(errPtr, err); 4445 return A.H.FALSE; 4446 } 4447 }, 4448 "has_GetVolumeMetadataList": (): heap.Ref<boolean> => { 4449 if (WEBEXT?.fileManagerPrivate && "getVolumeMetadataList" in WEBEXT?.fileManagerPrivate) { 4450 return A.H.TRUE; 4451 } 4452 return A.H.FALSE; 4453 }, 4454 "func_GetVolumeMetadataList": (fn: Pointer): void => { 4455 A.store.Ref(fn, WEBEXT.fileManagerPrivate.getVolumeMetadataList); 4456 }, 4457 "call_GetVolumeMetadataList": (retPtr: Pointer): void => { 4458 const _ret = WEBEXT.fileManagerPrivate.getVolumeMetadataList(); 4459 A.store.Ref(retPtr, _ret); 4460 }, 4461 "try_GetVolumeMetadataList": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 4462 try { 4463 const _ret = WEBEXT.fileManagerPrivate.getVolumeMetadataList(); 4464 A.store.Ref(retPtr, _ret); 4465 return A.H.TRUE; 4466 } catch (err: any) { 4467 A.store.Ref(errPtr, err); 4468 return A.H.FALSE; 4469 } 4470 }, 4471 "has_GetVolumeRoot": (): heap.Ref<boolean> => { 4472 if (WEBEXT?.fileManagerPrivate && "getVolumeRoot" in WEBEXT?.fileManagerPrivate) { 4473 return A.H.TRUE; 4474 } 4475 return A.H.FALSE; 4476 }, 4477 "func_GetVolumeRoot": (fn: Pointer): void => { 4478 A.store.Ref(fn, WEBEXT.fileManagerPrivate.getVolumeRoot); 4479 }, 4480 "call_GetVolumeRoot": (retPtr: Pointer, options: Pointer): void => { 4481 const options_ffi = {}; 4482 4483 options_ffi["volumeId"] = A.load.Ref(options + 0, undefined); 4484 if (A.load.Bool(options + 5)) { 4485 options_ffi["writable"] = A.load.Bool(options + 4); 4486 } 4487 4488 const _ret = WEBEXT.fileManagerPrivate.getVolumeRoot(options_ffi); 4489 A.store.Ref(retPtr, _ret); 4490 }, 4491 "try_GetVolumeRoot": (retPtr: Pointer, errPtr: Pointer, options: Pointer): heap.Ref<boolean> => { 4492 try { 4493 const options_ffi = {}; 4494 4495 options_ffi["volumeId"] = A.load.Ref(options + 0, undefined); 4496 if (A.load.Bool(options + 5)) { 4497 options_ffi["writable"] = A.load.Bool(options + 4); 4498 } 4499 4500 const _ret = WEBEXT.fileManagerPrivate.getVolumeRoot(options_ffi); 4501 A.store.Ref(retPtr, _ret); 4502 return A.H.TRUE; 4503 } catch (err: any) { 4504 A.store.Ref(errPtr, err); 4505 return A.H.FALSE; 4506 } 4507 }, 4508 "has_GrantAccess": (): heap.Ref<boolean> => { 4509 if (WEBEXT?.fileManagerPrivate && "grantAccess" in WEBEXT?.fileManagerPrivate) { 4510 return A.H.TRUE; 4511 } 4512 return A.H.FALSE; 4513 }, 4514 "func_GrantAccess": (fn: Pointer): void => { 4515 A.store.Ref(fn, WEBEXT.fileManagerPrivate.grantAccess); 4516 }, 4517 "call_GrantAccess": (retPtr: Pointer, entryUrls: heap.Ref<object>): void => { 4518 const _ret = WEBEXT.fileManagerPrivate.grantAccess(A.H.get<object>(entryUrls)); 4519 A.store.Ref(retPtr, _ret); 4520 }, 4521 "try_GrantAccess": (retPtr: Pointer, errPtr: Pointer, entryUrls: heap.Ref<object>): heap.Ref<boolean> => { 4522 try { 4523 const _ret = WEBEXT.fileManagerPrivate.grantAccess(A.H.get<object>(entryUrls)); 4524 A.store.Ref(retPtr, _ret); 4525 return A.H.TRUE; 4526 } catch (err: any) { 4527 A.store.Ref(errPtr, err); 4528 return A.H.FALSE; 4529 } 4530 }, 4531 "has_ImportCrostiniImage": (): heap.Ref<boolean> => { 4532 if (WEBEXT?.fileManagerPrivate && "importCrostiniImage" in WEBEXT?.fileManagerPrivate) { 4533 return A.H.TRUE; 4534 } 4535 return A.H.FALSE; 4536 }, 4537 "func_ImportCrostiniImage": (fn: Pointer): void => { 4538 A.store.Ref(fn, WEBEXT.fileManagerPrivate.importCrostiniImage); 4539 }, 4540 "call_ImportCrostiniImage": (retPtr: Pointer, entry: heap.Ref<object>): void => { 4541 const _ret = WEBEXT.fileManagerPrivate.importCrostiniImage(A.H.get<object>(entry)); 4542 }, 4543 "try_ImportCrostiniImage": (retPtr: Pointer, errPtr: Pointer, entry: heap.Ref<object>): heap.Ref<boolean> => { 4544 try { 4545 const _ret = WEBEXT.fileManagerPrivate.importCrostiniImage(A.H.get<object>(entry)); 4546 return A.H.TRUE; 4547 } catch (err: any) { 4548 A.store.Ref(errPtr, err); 4549 return A.H.FALSE; 4550 } 4551 }, 4552 "has_InstallLinuxPackage": (): heap.Ref<boolean> => { 4553 if (WEBEXT?.fileManagerPrivate && "installLinuxPackage" in WEBEXT?.fileManagerPrivate) { 4554 return A.H.TRUE; 4555 } 4556 return A.H.FALSE; 4557 }, 4558 "func_InstallLinuxPackage": (fn: Pointer): void => { 4559 A.store.Ref(fn, WEBEXT.fileManagerPrivate.installLinuxPackage); 4560 }, 4561 "call_InstallLinuxPackage": (retPtr: Pointer, entry: heap.Ref<object>, callback: heap.Ref<object>): void => { 4562 const _ret = WEBEXT.fileManagerPrivate.installLinuxPackage(A.H.get<object>(entry), A.H.get<object>(callback)); 4563 }, 4564 "try_InstallLinuxPackage": ( 4565 retPtr: Pointer, 4566 errPtr: Pointer, 4567 entry: heap.Ref<object>, 4568 callback: heap.Ref<object> 4569 ): heap.Ref<boolean> => { 4570 try { 4571 const _ret = WEBEXT.fileManagerPrivate.installLinuxPackage(A.H.get<object>(entry), A.H.get<object>(callback)); 4572 return A.H.TRUE; 4573 } catch (err: any) { 4574 A.store.Ref(errPtr, err); 4575 return A.H.FALSE; 4576 } 4577 }, 4578 "has_InvokeSharesheet": (): heap.Ref<boolean> => { 4579 if (WEBEXT?.fileManagerPrivate && "invokeSharesheet" in WEBEXT?.fileManagerPrivate) { 4580 return A.H.TRUE; 4581 } 4582 return A.H.FALSE; 4583 }, 4584 "func_InvokeSharesheet": (fn: Pointer): void => { 4585 A.store.Ref(fn, WEBEXT.fileManagerPrivate.invokeSharesheet); 4586 }, 4587 "call_InvokeSharesheet": ( 4588 retPtr: Pointer, 4589 entries: heap.Ref<object>, 4590 launchSource: number, 4591 dlpSourceUrls: heap.Ref<object> 4592 ): void => { 4593 const _ret = WEBEXT.fileManagerPrivate.invokeSharesheet( 4594 A.H.get<object>(entries), 4595 launchSource > 0 && launchSource <= 3 4596 ? ["context_menu", "sharesheet_button", "unknown"][launchSource - 1] 4597 : undefined, 4598 A.H.get<object>(dlpSourceUrls) 4599 ); 4600 A.store.Ref(retPtr, _ret); 4601 }, 4602 "try_InvokeSharesheet": ( 4603 retPtr: Pointer, 4604 errPtr: Pointer, 4605 entries: heap.Ref<object>, 4606 launchSource: number, 4607 dlpSourceUrls: heap.Ref<object> 4608 ): heap.Ref<boolean> => { 4609 try { 4610 const _ret = WEBEXT.fileManagerPrivate.invokeSharesheet( 4611 A.H.get<object>(entries), 4612 launchSource > 0 && launchSource <= 3 4613 ? ["context_menu", "sharesheet_button", "unknown"][launchSource - 1] 4614 : undefined, 4615 A.H.get<object>(dlpSourceUrls) 4616 ); 4617 A.store.Ref(retPtr, _ret); 4618 return A.H.TRUE; 4619 } catch (err: any) { 4620 A.store.Ref(errPtr, err); 4621 return A.H.FALSE; 4622 } 4623 }, 4624 "has_IsTabletModeEnabled": (): heap.Ref<boolean> => { 4625 if (WEBEXT?.fileManagerPrivate && "isTabletModeEnabled" in WEBEXT?.fileManagerPrivate) { 4626 return A.H.TRUE; 4627 } 4628 return A.H.FALSE; 4629 }, 4630 "func_IsTabletModeEnabled": (fn: Pointer): void => { 4631 A.store.Ref(fn, WEBEXT.fileManagerPrivate.isTabletModeEnabled); 4632 }, 4633 "call_IsTabletModeEnabled": (retPtr: Pointer): void => { 4634 const _ret = WEBEXT.fileManagerPrivate.isTabletModeEnabled(); 4635 A.store.Ref(retPtr, _ret); 4636 }, 4637 "try_IsTabletModeEnabled": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 4638 try { 4639 const _ret = WEBEXT.fileManagerPrivate.isTabletModeEnabled(); 4640 A.store.Ref(retPtr, _ret); 4641 return A.H.TRUE; 4642 } catch (err: any) { 4643 A.store.Ref(errPtr, err); 4644 return A.H.FALSE; 4645 } 4646 }, 4647 "has_ListMountableGuests": (): heap.Ref<boolean> => { 4648 if (WEBEXT?.fileManagerPrivate && "listMountableGuests" in WEBEXT?.fileManagerPrivate) { 4649 return A.H.TRUE; 4650 } 4651 return A.H.FALSE; 4652 }, 4653 "func_ListMountableGuests": (fn: Pointer): void => { 4654 A.store.Ref(fn, WEBEXT.fileManagerPrivate.listMountableGuests); 4655 }, 4656 "call_ListMountableGuests": (retPtr: Pointer): void => { 4657 const _ret = WEBEXT.fileManagerPrivate.listMountableGuests(); 4658 A.store.Ref(retPtr, _ret); 4659 }, 4660 "try_ListMountableGuests": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 4661 try { 4662 const _ret = WEBEXT.fileManagerPrivate.listMountableGuests(); 4663 A.store.Ref(retPtr, _ret); 4664 return A.H.TRUE; 4665 } catch (err: any) { 4666 A.store.Ref(errPtr, err); 4667 return A.H.FALSE; 4668 } 4669 }, 4670 "has_MountCrostini": (): heap.Ref<boolean> => { 4671 if (WEBEXT?.fileManagerPrivate && "mountCrostini" in WEBEXT?.fileManagerPrivate) { 4672 return A.H.TRUE; 4673 } 4674 return A.H.FALSE; 4675 }, 4676 "func_MountCrostini": (fn: Pointer): void => { 4677 A.store.Ref(fn, WEBEXT.fileManagerPrivate.mountCrostini); 4678 }, 4679 "call_MountCrostini": (retPtr: Pointer): void => { 4680 const _ret = WEBEXT.fileManagerPrivate.mountCrostini(); 4681 A.store.Ref(retPtr, _ret); 4682 }, 4683 "try_MountCrostini": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 4684 try { 4685 const _ret = WEBEXT.fileManagerPrivate.mountCrostini(); 4686 A.store.Ref(retPtr, _ret); 4687 return A.H.TRUE; 4688 } catch (err: any) { 4689 A.store.Ref(errPtr, err); 4690 return A.H.FALSE; 4691 } 4692 }, 4693 "has_MountGuest": (): heap.Ref<boolean> => { 4694 if (WEBEXT?.fileManagerPrivate && "mountGuest" in WEBEXT?.fileManagerPrivate) { 4695 return A.H.TRUE; 4696 } 4697 return A.H.FALSE; 4698 }, 4699 "func_MountGuest": (fn: Pointer): void => { 4700 A.store.Ref(fn, WEBEXT.fileManagerPrivate.mountGuest); 4701 }, 4702 "call_MountGuest": (retPtr: Pointer, id: number): void => { 4703 const _ret = WEBEXT.fileManagerPrivate.mountGuest(id); 4704 A.store.Ref(retPtr, _ret); 4705 }, 4706 "try_MountGuest": (retPtr: Pointer, errPtr: Pointer, id: number): heap.Ref<boolean> => { 4707 try { 4708 const _ret = WEBEXT.fileManagerPrivate.mountGuest(id); 4709 A.store.Ref(retPtr, _ret); 4710 return A.H.TRUE; 4711 } catch (err: any) { 4712 A.store.Ref(errPtr, err); 4713 return A.H.FALSE; 4714 } 4715 }, 4716 "has_NotifyDriveDialogResult": (): heap.Ref<boolean> => { 4717 if (WEBEXT?.fileManagerPrivate && "notifyDriveDialogResult" in WEBEXT?.fileManagerPrivate) { 4718 return A.H.TRUE; 4719 } 4720 return A.H.FALSE; 4721 }, 4722 "func_NotifyDriveDialogResult": (fn: Pointer): void => { 4723 A.store.Ref(fn, WEBEXT.fileManagerPrivate.notifyDriveDialogResult); 4724 }, 4725 "call_NotifyDriveDialogResult": (retPtr: Pointer, result: number): void => { 4726 const _ret = WEBEXT.fileManagerPrivate.notifyDriveDialogResult( 4727 result > 0 && result <= 4 ? ["not_displayed", "accept", "reject", "dismiss"][result - 1] : undefined 4728 ); 4729 }, 4730 "try_NotifyDriveDialogResult": (retPtr: Pointer, errPtr: Pointer, result: number): heap.Ref<boolean> => { 4731 try { 4732 const _ret = WEBEXT.fileManagerPrivate.notifyDriveDialogResult( 4733 result > 0 && result <= 4 ? ["not_displayed", "accept", "reject", "dismiss"][result - 1] : undefined 4734 ); 4735 return A.H.TRUE; 4736 } catch (err: any) { 4737 A.store.Ref(errPtr, err); 4738 return A.H.FALSE; 4739 } 4740 }, 4741 "has_OnAppsUpdated": (): heap.Ref<boolean> => { 4742 if (WEBEXT?.fileManagerPrivate?.onAppsUpdated && "addListener" in WEBEXT?.fileManagerPrivate?.onAppsUpdated) { 4743 return A.H.TRUE; 4744 } 4745 return A.H.FALSE; 4746 }, 4747 "func_OnAppsUpdated": (fn: Pointer): void => { 4748 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onAppsUpdated.addListener); 4749 }, 4750 "call_OnAppsUpdated": (retPtr: Pointer, callback: heap.Ref<object>): void => { 4751 const _ret = WEBEXT.fileManagerPrivate.onAppsUpdated.addListener(A.H.get<object>(callback)); 4752 }, 4753 "try_OnAppsUpdated": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 4754 try { 4755 const _ret = WEBEXT.fileManagerPrivate.onAppsUpdated.addListener(A.H.get<object>(callback)); 4756 return A.H.TRUE; 4757 } catch (err: any) { 4758 A.store.Ref(errPtr, err); 4759 return A.H.FALSE; 4760 } 4761 }, 4762 "has_OffAppsUpdated": (): heap.Ref<boolean> => { 4763 if (WEBEXT?.fileManagerPrivate?.onAppsUpdated && "removeListener" in WEBEXT?.fileManagerPrivate?.onAppsUpdated) { 4764 return A.H.TRUE; 4765 } 4766 return A.H.FALSE; 4767 }, 4768 "func_OffAppsUpdated": (fn: Pointer): void => { 4769 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onAppsUpdated.removeListener); 4770 }, 4771 "call_OffAppsUpdated": (retPtr: Pointer, callback: heap.Ref<object>): void => { 4772 const _ret = WEBEXT.fileManagerPrivate.onAppsUpdated.removeListener(A.H.get<object>(callback)); 4773 }, 4774 "try_OffAppsUpdated": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 4775 try { 4776 const _ret = WEBEXT.fileManagerPrivate.onAppsUpdated.removeListener(A.H.get<object>(callback)); 4777 return A.H.TRUE; 4778 } catch (err: any) { 4779 A.store.Ref(errPtr, err); 4780 return A.H.FALSE; 4781 } 4782 }, 4783 "has_HasOnAppsUpdated": (): heap.Ref<boolean> => { 4784 if (WEBEXT?.fileManagerPrivate?.onAppsUpdated && "hasListener" in WEBEXT?.fileManagerPrivate?.onAppsUpdated) { 4785 return A.H.TRUE; 4786 } 4787 return A.H.FALSE; 4788 }, 4789 "func_HasOnAppsUpdated": (fn: Pointer): void => { 4790 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onAppsUpdated.hasListener); 4791 }, 4792 "call_HasOnAppsUpdated": (retPtr: Pointer, callback: heap.Ref<object>): void => { 4793 const _ret = WEBEXT.fileManagerPrivate.onAppsUpdated.hasListener(A.H.get<object>(callback)); 4794 A.store.Bool(retPtr, _ret); 4795 }, 4796 "try_HasOnAppsUpdated": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 4797 try { 4798 const _ret = WEBEXT.fileManagerPrivate.onAppsUpdated.hasListener(A.H.get<object>(callback)); 4799 A.store.Bool(retPtr, _ret); 4800 return A.H.TRUE; 4801 } catch (err: any) { 4802 A.store.Ref(errPtr, err); 4803 return A.H.FALSE; 4804 } 4805 }, 4806 "has_OnBulkPinProgress": (): heap.Ref<boolean> => { 4807 if ( 4808 WEBEXT?.fileManagerPrivate?.onBulkPinProgress && 4809 "addListener" in WEBEXT?.fileManagerPrivate?.onBulkPinProgress 4810 ) { 4811 return A.H.TRUE; 4812 } 4813 return A.H.FALSE; 4814 }, 4815 "func_OnBulkPinProgress": (fn: Pointer): void => { 4816 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onBulkPinProgress.addListener); 4817 }, 4818 "call_OnBulkPinProgress": (retPtr: Pointer, callback: heap.Ref<object>): void => { 4819 const _ret = WEBEXT.fileManagerPrivate.onBulkPinProgress.addListener(A.H.get<object>(callback)); 4820 }, 4821 "try_OnBulkPinProgress": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 4822 try { 4823 const _ret = WEBEXT.fileManagerPrivate.onBulkPinProgress.addListener(A.H.get<object>(callback)); 4824 return A.H.TRUE; 4825 } catch (err: any) { 4826 A.store.Ref(errPtr, err); 4827 return A.H.FALSE; 4828 } 4829 }, 4830 "has_OffBulkPinProgress": (): heap.Ref<boolean> => { 4831 if ( 4832 WEBEXT?.fileManagerPrivate?.onBulkPinProgress && 4833 "removeListener" in WEBEXT?.fileManagerPrivate?.onBulkPinProgress 4834 ) { 4835 return A.H.TRUE; 4836 } 4837 return A.H.FALSE; 4838 }, 4839 "func_OffBulkPinProgress": (fn: Pointer): void => { 4840 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onBulkPinProgress.removeListener); 4841 }, 4842 "call_OffBulkPinProgress": (retPtr: Pointer, callback: heap.Ref<object>): void => { 4843 const _ret = WEBEXT.fileManagerPrivate.onBulkPinProgress.removeListener(A.H.get<object>(callback)); 4844 }, 4845 "try_OffBulkPinProgress": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 4846 try { 4847 const _ret = WEBEXT.fileManagerPrivate.onBulkPinProgress.removeListener(A.H.get<object>(callback)); 4848 return A.H.TRUE; 4849 } catch (err: any) { 4850 A.store.Ref(errPtr, err); 4851 return A.H.FALSE; 4852 } 4853 }, 4854 "has_HasOnBulkPinProgress": (): heap.Ref<boolean> => { 4855 if ( 4856 WEBEXT?.fileManagerPrivate?.onBulkPinProgress && 4857 "hasListener" in WEBEXT?.fileManagerPrivate?.onBulkPinProgress 4858 ) { 4859 return A.H.TRUE; 4860 } 4861 return A.H.FALSE; 4862 }, 4863 "func_HasOnBulkPinProgress": (fn: Pointer): void => { 4864 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onBulkPinProgress.hasListener); 4865 }, 4866 "call_HasOnBulkPinProgress": (retPtr: Pointer, callback: heap.Ref<object>): void => { 4867 const _ret = WEBEXT.fileManagerPrivate.onBulkPinProgress.hasListener(A.H.get<object>(callback)); 4868 A.store.Bool(retPtr, _ret); 4869 }, 4870 "try_HasOnBulkPinProgress": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 4871 try { 4872 const _ret = WEBEXT.fileManagerPrivate.onBulkPinProgress.hasListener(A.H.get<object>(callback)); 4873 A.store.Bool(retPtr, _ret); 4874 return A.H.TRUE; 4875 } catch (err: any) { 4876 A.store.Ref(errPtr, err); 4877 return A.H.FALSE; 4878 } 4879 }, 4880 "has_OnCrostiniChanged": (): heap.Ref<boolean> => { 4881 if ( 4882 WEBEXT?.fileManagerPrivate?.onCrostiniChanged && 4883 "addListener" in WEBEXT?.fileManagerPrivate?.onCrostiniChanged 4884 ) { 4885 return A.H.TRUE; 4886 } 4887 return A.H.FALSE; 4888 }, 4889 "func_OnCrostiniChanged": (fn: Pointer): void => { 4890 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onCrostiniChanged.addListener); 4891 }, 4892 "call_OnCrostiniChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 4893 const _ret = WEBEXT.fileManagerPrivate.onCrostiniChanged.addListener(A.H.get<object>(callback)); 4894 }, 4895 "try_OnCrostiniChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 4896 try { 4897 const _ret = WEBEXT.fileManagerPrivate.onCrostiniChanged.addListener(A.H.get<object>(callback)); 4898 return A.H.TRUE; 4899 } catch (err: any) { 4900 A.store.Ref(errPtr, err); 4901 return A.H.FALSE; 4902 } 4903 }, 4904 "has_OffCrostiniChanged": (): heap.Ref<boolean> => { 4905 if ( 4906 WEBEXT?.fileManagerPrivate?.onCrostiniChanged && 4907 "removeListener" in WEBEXT?.fileManagerPrivate?.onCrostiniChanged 4908 ) { 4909 return A.H.TRUE; 4910 } 4911 return A.H.FALSE; 4912 }, 4913 "func_OffCrostiniChanged": (fn: Pointer): void => { 4914 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onCrostiniChanged.removeListener); 4915 }, 4916 "call_OffCrostiniChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 4917 const _ret = WEBEXT.fileManagerPrivate.onCrostiniChanged.removeListener(A.H.get<object>(callback)); 4918 }, 4919 "try_OffCrostiniChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 4920 try { 4921 const _ret = WEBEXT.fileManagerPrivate.onCrostiniChanged.removeListener(A.H.get<object>(callback)); 4922 return A.H.TRUE; 4923 } catch (err: any) { 4924 A.store.Ref(errPtr, err); 4925 return A.H.FALSE; 4926 } 4927 }, 4928 "has_HasOnCrostiniChanged": (): heap.Ref<boolean> => { 4929 if ( 4930 WEBEXT?.fileManagerPrivate?.onCrostiniChanged && 4931 "hasListener" in WEBEXT?.fileManagerPrivate?.onCrostiniChanged 4932 ) { 4933 return A.H.TRUE; 4934 } 4935 return A.H.FALSE; 4936 }, 4937 "func_HasOnCrostiniChanged": (fn: Pointer): void => { 4938 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onCrostiniChanged.hasListener); 4939 }, 4940 "call_HasOnCrostiniChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 4941 const _ret = WEBEXT.fileManagerPrivate.onCrostiniChanged.hasListener(A.H.get<object>(callback)); 4942 A.store.Bool(retPtr, _ret); 4943 }, 4944 "try_HasOnCrostiniChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 4945 try { 4946 const _ret = WEBEXT.fileManagerPrivate.onCrostiniChanged.hasListener(A.H.get<object>(callback)); 4947 A.store.Bool(retPtr, _ret); 4948 return A.H.TRUE; 4949 } catch (err: any) { 4950 A.store.Ref(errPtr, err); 4951 return A.H.FALSE; 4952 } 4953 }, 4954 "has_OnDeviceChanged": (): heap.Ref<boolean> => { 4955 if (WEBEXT?.fileManagerPrivate?.onDeviceChanged && "addListener" in WEBEXT?.fileManagerPrivate?.onDeviceChanged) { 4956 return A.H.TRUE; 4957 } 4958 return A.H.FALSE; 4959 }, 4960 "func_OnDeviceChanged": (fn: Pointer): void => { 4961 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onDeviceChanged.addListener); 4962 }, 4963 "call_OnDeviceChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 4964 const _ret = WEBEXT.fileManagerPrivate.onDeviceChanged.addListener(A.H.get<object>(callback)); 4965 }, 4966 "try_OnDeviceChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 4967 try { 4968 const _ret = WEBEXT.fileManagerPrivate.onDeviceChanged.addListener(A.H.get<object>(callback)); 4969 return A.H.TRUE; 4970 } catch (err: any) { 4971 A.store.Ref(errPtr, err); 4972 return A.H.FALSE; 4973 } 4974 }, 4975 "has_OffDeviceChanged": (): heap.Ref<boolean> => { 4976 if ( 4977 WEBEXT?.fileManagerPrivate?.onDeviceChanged && 4978 "removeListener" in WEBEXT?.fileManagerPrivate?.onDeviceChanged 4979 ) { 4980 return A.H.TRUE; 4981 } 4982 return A.H.FALSE; 4983 }, 4984 "func_OffDeviceChanged": (fn: Pointer): void => { 4985 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onDeviceChanged.removeListener); 4986 }, 4987 "call_OffDeviceChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 4988 const _ret = WEBEXT.fileManagerPrivate.onDeviceChanged.removeListener(A.H.get<object>(callback)); 4989 }, 4990 "try_OffDeviceChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 4991 try { 4992 const _ret = WEBEXT.fileManagerPrivate.onDeviceChanged.removeListener(A.H.get<object>(callback)); 4993 return A.H.TRUE; 4994 } catch (err: any) { 4995 A.store.Ref(errPtr, err); 4996 return A.H.FALSE; 4997 } 4998 }, 4999 "has_HasOnDeviceChanged": (): heap.Ref<boolean> => { 5000 if (WEBEXT?.fileManagerPrivate?.onDeviceChanged && "hasListener" in WEBEXT?.fileManagerPrivate?.onDeviceChanged) { 5001 return A.H.TRUE; 5002 } 5003 return A.H.FALSE; 5004 }, 5005 "func_HasOnDeviceChanged": (fn: Pointer): void => { 5006 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onDeviceChanged.hasListener); 5007 }, 5008 "call_HasOnDeviceChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 5009 const _ret = WEBEXT.fileManagerPrivate.onDeviceChanged.hasListener(A.H.get<object>(callback)); 5010 A.store.Bool(retPtr, _ret); 5011 }, 5012 "try_HasOnDeviceChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 5013 try { 5014 const _ret = WEBEXT.fileManagerPrivate.onDeviceChanged.hasListener(A.H.get<object>(callback)); 5015 A.store.Bool(retPtr, _ret); 5016 return A.H.TRUE; 5017 } catch (err: any) { 5018 A.store.Ref(errPtr, err); 5019 return A.H.FALSE; 5020 } 5021 }, 5022 "has_OnDeviceConnectionStatusChanged": (): heap.Ref<boolean> => { 5023 if ( 5024 WEBEXT?.fileManagerPrivate?.onDeviceConnectionStatusChanged && 5025 "addListener" in WEBEXT?.fileManagerPrivate?.onDeviceConnectionStatusChanged 5026 ) { 5027 return A.H.TRUE; 5028 } 5029 return A.H.FALSE; 5030 }, 5031 "func_OnDeviceConnectionStatusChanged": (fn: Pointer): void => { 5032 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onDeviceConnectionStatusChanged.addListener); 5033 }, 5034 "call_OnDeviceConnectionStatusChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 5035 const _ret = WEBEXT.fileManagerPrivate.onDeviceConnectionStatusChanged.addListener(A.H.get<object>(callback)); 5036 }, 5037 "try_OnDeviceConnectionStatusChanged": ( 5038 retPtr: Pointer, 5039 errPtr: Pointer, 5040 callback: heap.Ref<object> 5041 ): heap.Ref<boolean> => { 5042 try { 5043 const _ret = WEBEXT.fileManagerPrivate.onDeviceConnectionStatusChanged.addListener(A.H.get<object>(callback)); 5044 return A.H.TRUE; 5045 } catch (err: any) { 5046 A.store.Ref(errPtr, err); 5047 return A.H.FALSE; 5048 } 5049 }, 5050 "has_OffDeviceConnectionStatusChanged": (): heap.Ref<boolean> => { 5051 if ( 5052 WEBEXT?.fileManagerPrivate?.onDeviceConnectionStatusChanged && 5053 "removeListener" in WEBEXT?.fileManagerPrivate?.onDeviceConnectionStatusChanged 5054 ) { 5055 return A.H.TRUE; 5056 } 5057 return A.H.FALSE; 5058 }, 5059 "func_OffDeviceConnectionStatusChanged": (fn: Pointer): void => { 5060 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onDeviceConnectionStatusChanged.removeListener); 5061 }, 5062 "call_OffDeviceConnectionStatusChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 5063 const _ret = WEBEXT.fileManagerPrivate.onDeviceConnectionStatusChanged.removeListener(A.H.get<object>(callback)); 5064 }, 5065 "try_OffDeviceConnectionStatusChanged": ( 5066 retPtr: Pointer, 5067 errPtr: Pointer, 5068 callback: heap.Ref<object> 5069 ): heap.Ref<boolean> => { 5070 try { 5071 const _ret = WEBEXT.fileManagerPrivate.onDeviceConnectionStatusChanged.removeListener( 5072 A.H.get<object>(callback) 5073 ); 5074 return A.H.TRUE; 5075 } catch (err: any) { 5076 A.store.Ref(errPtr, err); 5077 return A.H.FALSE; 5078 } 5079 }, 5080 "has_HasOnDeviceConnectionStatusChanged": (): heap.Ref<boolean> => { 5081 if ( 5082 WEBEXT?.fileManagerPrivate?.onDeviceConnectionStatusChanged && 5083 "hasListener" in WEBEXT?.fileManagerPrivate?.onDeviceConnectionStatusChanged 5084 ) { 5085 return A.H.TRUE; 5086 } 5087 return A.H.FALSE; 5088 }, 5089 "func_HasOnDeviceConnectionStatusChanged": (fn: Pointer): void => { 5090 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onDeviceConnectionStatusChanged.hasListener); 5091 }, 5092 "call_HasOnDeviceConnectionStatusChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 5093 const _ret = WEBEXT.fileManagerPrivate.onDeviceConnectionStatusChanged.hasListener(A.H.get<object>(callback)); 5094 A.store.Bool(retPtr, _ret); 5095 }, 5096 "try_HasOnDeviceConnectionStatusChanged": ( 5097 retPtr: Pointer, 5098 errPtr: Pointer, 5099 callback: heap.Ref<object> 5100 ): heap.Ref<boolean> => { 5101 try { 5102 const _ret = WEBEXT.fileManagerPrivate.onDeviceConnectionStatusChanged.hasListener(A.H.get<object>(callback)); 5103 A.store.Bool(retPtr, _ret); 5104 return A.H.TRUE; 5105 } catch (err: any) { 5106 A.store.Ref(errPtr, err); 5107 return A.H.FALSE; 5108 } 5109 }, 5110 "has_OnDirectoryChanged": (): heap.Ref<boolean> => { 5111 if ( 5112 WEBEXT?.fileManagerPrivate?.onDirectoryChanged && 5113 "addListener" in WEBEXT?.fileManagerPrivate?.onDirectoryChanged 5114 ) { 5115 return A.H.TRUE; 5116 } 5117 return A.H.FALSE; 5118 }, 5119 "func_OnDirectoryChanged": (fn: Pointer): void => { 5120 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onDirectoryChanged.addListener); 5121 }, 5122 "call_OnDirectoryChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 5123 const _ret = WEBEXT.fileManagerPrivate.onDirectoryChanged.addListener(A.H.get<object>(callback)); 5124 }, 5125 "try_OnDirectoryChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 5126 try { 5127 const _ret = WEBEXT.fileManagerPrivate.onDirectoryChanged.addListener(A.H.get<object>(callback)); 5128 return A.H.TRUE; 5129 } catch (err: any) { 5130 A.store.Ref(errPtr, err); 5131 return A.H.FALSE; 5132 } 5133 }, 5134 "has_OffDirectoryChanged": (): heap.Ref<boolean> => { 5135 if ( 5136 WEBEXT?.fileManagerPrivate?.onDirectoryChanged && 5137 "removeListener" in WEBEXT?.fileManagerPrivate?.onDirectoryChanged 5138 ) { 5139 return A.H.TRUE; 5140 } 5141 return A.H.FALSE; 5142 }, 5143 "func_OffDirectoryChanged": (fn: Pointer): void => { 5144 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onDirectoryChanged.removeListener); 5145 }, 5146 "call_OffDirectoryChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 5147 const _ret = WEBEXT.fileManagerPrivate.onDirectoryChanged.removeListener(A.H.get<object>(callback)); 5148 }, 5149 "try_OffDirectoryChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 5150 try { 5151 const _ret = WEBEXT.fileManagerPrivate.onDirectoryChanged.removeListener(A.H.get<object>(callback)); 5152 return A.H.TRUE; 5153 } catch (err: any) { 5154 A.store.Ref(errPtr, err); 5155 return A.H.FALSE; 5156 } 5157 }, 5158 "has_HasOnDirectoryChanged": (): heap.Ref<boolean> => { 5159 if ( 5160 WEBEXT?.fileManagerPrivate?.onDirectoryChanged && 5161 "hasListener" in WEBEXT?.fileManagerPrivate?.onDirectoryChanged 5162 ) { 5163 return A.H.TRUE; 5164 } 5165 return A.H.FALSE; 5166 }, 5167 "func_HasOnDirectoryChanged": (fn: Pointer): void => { 5168 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onDirectoryChanged.hasListener); 5169 }, 5170 "call_HasOnDirectoryChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 5171 const _ret = WEBEXT.fileManagerPrivate.onDirectoryChanged.hasListener(A.H.get<object>(callback)); 5172 A.store.Bool(retPtr, _ret); 5173 }, 5174 "try_HasOnDirectoryChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 5175 try { 5176 const _ret = WEBEXT.fileManagerPrivate.onDirectoryChanged.hasListener(A.H.get<object>(callback)); 5177 A.store.Bool(retPtr, _ret); 5178 return A.H.TRUE; 5179 } catch (err: any) { 5180 A.store.Ref(errPtr, err); 5181 return A.H.FALSE; 5182 } 5183 }, 5184 "has_OnDriveConfirmDialog": (): heap.Ref<boolean> => { 5185 if ( 5186 WEBEXT?.fileManagerPrivate?.onDriveConfirmDialog && 5187 "addListener" in WEBEXT?.fileManagerPrivate?.onDriveConfirmDialog 5188 ) { 5189 return A.H.TRUE; 5190 } 5191 return A.H.FALSE; 5192 }, 5193 "func_OnDriveConfirmDialog": (fn: Pointer): void => { 5194 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onDriveConfirmDialog.addListener); 5195 }, 5196 "call_OnDriveConfirmDialog": (retPtr: Pointer, callback: heap.Ref<object>): void => { 5197 const _ret = WEBEXT.fileManagerPrivate.onDriveConfirmDialog.addListener(A.H.get<object>(callback)); 5198 }, 5199 "try_OnDriveConfirmDialog": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 5200 try { 5201 const _ret = WEBEXT.fileManagerPrivate.onDriveConfirmDialog.addListener(A.H.get<object>(callback)); 5202 return A.H.TRUE; 5203 } catch (err: any) { 5204 A.store.Ref(errPtr, err); 5205 return A.H.FALSE; 5206 } 5207 }, 5208 "has_OffDriveConfirmDialog": (): heap.Ref<boolean> => { 5209 if ( 5210 WEBEXT?.fileManagerPrivate?.onDriveConfirmDialog && 5211 "removeListener" in WEBEXT?.fileManagerPrivate?.onDriveConfirmDialog 5212 ) { 5213 return A.H.TRUE; 5214 } 5215 return A.H.FALSE; 5216 }, 5217 "func_OffDriveConfirmDialog": (fn: Pointer): void => { 5218 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onDriveConfirmDialog.removeListener); 5219 }, 5220 "call_OffDriveConfirmDialog": (retPtr: Pointer, callback: heap.Ref<object>): void => { 5221 const _ret = WEBEXT.fileManagerPrivate.onDriveConfirmDialog.removeListener(A.H.get<object>(callback)); 5222 }, 5223 "try_OffDriveConfirmDialog": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 5224 try { 5225 const _ret = WEBEXT.fileManagerPrivate.onDriveConfirmDialog.removeListener(A.H.get<object>(callback)); 5226 return A.H.TRUE; 5227 } catch (err: any) { 5228 A.store.Ref(errPtr, err); 5229 return A.H.FALSE; 5230 } 5231 }, 5232 "has_HasOnDriveConfirmDialog": (): heap.Ref<boolean> => { 5233 if ( 5234 WEBEXT?.fileManagerPrivate?.onDriveConfirmDialog && 5235 "hasListener" in WEBEXT?.fileManagerPrivate?.onDriveConfirmDialog 5236 ) { 5237 return A.H.TRUE; 5238 } 5239 return A.H.FALSE; 5240 }, 5241 "func_HasOnDriveConfirmDialog": (fn: Pointer): void => { 5242 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onDriveConfirmDialog.hasListener); 5243 }, 5244 "call_HasOnDriveConfirmDialog": (retPtr: Pointer, callback: heap.Ref<object>): void => { 5245 const _ret = WEBEXT.fileManagerPrivate.onDriveConfirmDialog.hasListener(A.H.get<object>(callback)); 5246 A.store.Bool(retPtr, _ret); 5247 }, 5248 "try_HasOnDriveConfirmDialog": ( 5249 retPtr: Pointer, 5250 errPtr: Pointer, 5251 callback: heap.Ref<object> 5252 ): heap.Ref<boolean> => { 5253 try { 5254 const _ret = WEBEXT.fileManagerPrivate.onDriveConfirmDialog.hasListener(A.H.get<object>(callback)); 5255 A.store.Bool(retPtr, _ret); 5256 return A.H.TRUE; 5257 } catch (err: any) { 5258 A.store.Ref(errPtr, err); 5259 return A.H.FALSE; 5260 } 5261 }, 5262 "has_OnDriveConnectionStatusChanged": (): heap.Ref<boolean> => { 5263 if ( 5264 WEBEXT?.fileManagerPrivate?.onDriveConnectionStatusChanged && 5265 "addListener" in WEBEXT?.fileManagerPrivate?.onDriveConnectionStatusChanged 5266 ) { 5267 return A.H.TRUE; 5268 } 5269 return A.H.FALSE; 5270 }, 5271 "func_OnDriveConnectionStatusChanged": (fn: Pointer): void => { 5272 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onDriveConnectionStatusChanged.addListener); 5273 }, 5274 "call_OnDriveConnectionStatusChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 5275 const _ret = WEBEXT.fileManagerPrivate.onDriveConnectionStatusChanged.addListener(A.H.get<object>(callback)); 5276 }, 5277 "try_OnDriveConnectionStatusChanged": ( 5278 retPtr: Pointer, 5279 errPtr: Pointer, 5280 callback: heap.Ref<object> 5281 ): heap.Ref<boolean> => { 5282 try { 5283 const _ret = WEBEXT.fileManagerPrivate.onDriveConnectionStatusChanged.addListener(A.H.get<object>(callback)); 5284 return A.H.TRUE; 5285 } catch (err: any) { 5286 A.store.Ref(errPtr, err); 5287 return A.H.FALSE; 5288 } 5289 }, 5290 "has_OffDriveConnectionStatusChanged": (): heap.Ref<boolean> => { 5291 if ( 5292 WEBEXT?.fileManagerPrivate?.onDriveConnectionStatusChanged && 5293 "removeListener" in WEBEXT?.fileManagerPrivate?.onDriveConnectionStatusChanged 5294 ) { 5295 return A.H.TRUE; 5296 } 5297 return A.H.FALSE; 5298 }, 5299 "func_OffDriveConnectionStatusChanged": (fn: Pointer): void => { 5300 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onDriveConnectionStatusChanged.removeListener); 5301 }, 5302 "call_OffDriveConnectionStatusChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 5303 const _ret = WEBEXT.fileManagerPrivate.onDriveConnectionStatusChanged.removeListener(A.H.get<object>(callback)); 5304 }, 5305 "try_OffDriveConnectionStatusChanged": ( 5306 retPtr: Pointer, 5307 errPtr: Pointer, 5308 callback: heap.Ref<object> 5309 ): heap.Ref<boolean> => { 5310 try { 5311 const _ret = WEBEXT.fileManagerPrivate.onDriveConnectionStatusChanged.removeListener(A.H.get<object>(callback)); 5312 return A.H.TRUE; 5313 } catch (err: any) { 5314 A.store.Ref(errPtr, err); 5315 return A.H.FALSE; 5316 } 5317 }, 5318 "has_HasOnDriveConnectionStatusChanged": (): heap.Ref<boolean> => { 5319 if ( 5320 WEBEXT?.fileManagerPrivate?.onDriveConnectionStatusChanged && 5321 "hasListener" in WEBEXT?.fileManagerPrivate?.onDriveConnectionStatusChanged 5322 ) { 5323 return A.H.TRUE; 5324 } 5325 return A.H.FALSE; 5326 }, 5327 "func_HasOnDriveConnectionStatusChanged": (fn: Pointer): void => { 5328 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onDriveConnectionStatusChanged.hasListener); 5329 }, 5330 "call_HasOnDriveConnectionStatusChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 5331 const _ret = WEBEXT.fileManagerPrivate.onDriveConnectionStatusChanged.hasListener(A.H.get<object>(callback)); 5332 A.store.Bool(retPtr, _ret); 5333 }, 5334 "try_HasOnDriveConnectionStatusChanged": ( 5335 retPtr: Pointer, 5336 errPtr: Pointer, 5337 callback: heap.Ref<object> 5338 ): heap.Ref<boolean> => { 5339 try { 5340 const _ret = WEBEXT.fileManagerPrivate.onDriveConnectionStatusChanged.hasListener(A.H.get<object>(callback)); 5341 A.store.Bool(retPtr, _ret); 5342 return A.H.TRUE; 5343 } catch (err: any) { 5344 A.store.Ref(errPtr, err); 5345 return A.H.FALSE; 5346 } 5347 }, 5348 "has_OnDriveSyncError": (): heap.Ref<boolean> => { 5349 if ( 5350 WEBEXT?.fileManagerPrivate?.onDriveSyncError && 5351 "addListener" in WEBEXT?.fileManagerPrivate?.onDriveSyncError 5352 ) { 5353 return A.H.TRUE; 5354 } 5355 return A.H.FALSE; 5356 }, 5357 "func_OnDriveSyncError": (fn: Pointer): void => { 5358 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onDriveSyncError.addListener); 5359 }, 5360 "call_OnDriveSyncError": (retPtr: Pointer, callback: heap.Ref<object>): void => { 5361 const _ret = WEBEXT.fileManagerPrivate.onDriveSyncError.addListener(A.H.get<object>(callback)); 5362 }, 5363 "try_OnDriveSyncError": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 5364 try { 5365 const _ret = WEBEXT.fileManagerPrivate.onDriveSyncError.addListener(A.H.get<object>(callback)); 5366 return A.H.TRUE; 5367 } catch (err: any) { 5368 A.store.Ref(errPtr, err); 5369 return A.H.FALSE; 5370 } 5371 }, 5372 "has_OffDriveSyncError": (): heap.Ref<boolean> => { 5373 if ( 5374 WEBEXT?.fileManagerPrivate?.onDriveSyncError && 5375 "removeListener" in WEBEXT?.fileManagerPrivate?.onDriveSyncError 5376 ) { 5377 return A.H.TRUE; 5378 } 5379 return A.H.FALSE; 5380 }, 5381 "func_OffDriveSyncError": (fn: Pointer): void => { 5382 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onDriveSyncError.removeListener); 5383 }, 5384 "call_OffDriveSyncError": (retPtr: Pointer, callback: heap.Ref<object>): void => { 5385 const _ret = WEBEXT.fileManagerPrivate.onDriveSyncError.removeListener(A.H.get<object>(callback)); 5386 }, 5387 "try_OffDriveSyncError": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 5388 try { 5389 const _ret = WEBEXT.fileManagerPrivate.onDriveSyncError.removeListener(A.H.get<object>(callback)); 5390 return A.H.TRUE; 5391 } catch (err: any) { 5392 A.store.Ref(errPtr, err); 5393 return A.H.FALSE; 5394 } 5395 }, 5396 "has_HasOnDriveSyncError": (): heap.Ref<boolean> => { 5397 if ( 5398 WEBEXT?.fileManagerPrivate?.onDriveSyncError && 5399 "hasListener" in WEBEXT?.fileManagerPrivate?.onDriveSyncError 5400 ) { 5401 return A.H.TRUE; 5402 } 5403 return A.H.FALSE; 5404 }, 5405 "func_HasOnDriveSyncError": (fn: Pointer): void => { 5406 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onDriveSyncError.hasListener); 5407 }, 5408 "call_HasOnDriveSyncError": (retPtr: Pointer, callback: heap.Ref<object>): void => { 5409 const _ret = WEBEXT.fileManagerPrivate.onDriveSyncError.hasListener(A.H.get<object>(callback)); 5410 A.store.Bool(retPtr, _ret); 5411 }, 5412 "try_HasOnDriveSyncError": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 5413 try { 5414 const _ret = WEBEXT.fileManagerPrivate.onDriveSyncError.hasListener(A.H.get<object>(callback)); 5415 A.store.Bool(retPtr, _ret); 5416 return A.H.TRUE; 5417 } catch (err: any) { 5418 A.store.Ref(errPtr, err); 5419 return A.H.FALSE; 5420 } 5421 }, 5422 "has_OnFileTransfersUpdated": (): heap.Ref<boolean> => { 5423 if ( 5424 WEBEXT?.fileManagerPrivate?.onFileTransfersUpdated && 5425 "addListener" in WEBEXT?.fileManagerPrivate?.onFileTransfersUpdated 5426 ) { 5427 return A.H.TRUE; 5428 } 5429 return A.H.FALSE; 5430 }, 5431 "func_OnFileTransfersUpdated": (fn: Pointer): void => { 5432 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onFileTransfersUpdated.addListener); 5433 }, 5434 "call_OnFileTransfersUpdated": (retPtr: Pointer, callback: heap.Ref<object>): void => { 5435 const _ret = WEBEXT.fileManagerPrivate.onFileTransfersUpdated.addListener(A.H.get<object>(callback)); 5436 }, 5437 "try_OnFileTransfersUpdated": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 5438 try { 5439 const _ret = WEBEXT.fileManagerPrivate.onFileTransfersUpdated.addListener(A.H.get<object>(callback)); 5440 return A.H.TRUE; 5441 } catch (err: any) { 5442 A.store.Ref(errPtr, err); 5443 return A.H.FALSE; 5444 } 5445 }, 5446 "has_OffFileTransfersUpdated": (): heap.Ref<boolean> => { 5447 if ( 5448 WEBEXT?.fileManagerPrivate?.onFileTransfersUpdated && 5449 "removeListener" in WEBEXT?.fileManagerPrivate?.onFileTransfersUpdated 5450 ) { 5451 return A.H.TRUE; 5452 } 5453 return A.H.FALSE; 5454 }, 5455 "func_OffFileTransfersUpdated": (fn: Pointer): void => { 5456 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onFileTransfersUpdated.removeListener); 5457 }, 5458 "call_OffFileTransfersUpdated": (retPtr: Pointer, callback: heap.Ref<object>): void => { 5459 const _ret = WEBEXT.fileManagerPrivate.onFileTransfersUpdated.removeListener(A.H.get<object>(callback)); 5460 }, 5461 "try_OffFileTransfersUpdated": ( 5462 retPtr: Pointer, 5463 errPtr: Pointer, 5464 callback: heap.Ref<object> 5465 ): heap.Ref<boolean> => { 5466 try { 5467 const _ret = WEBEXT.fileManagerPrivate.onFileTransfersUpdated.removeListener(A.H.get<object>(callback)); 5468 return A.H.TRUE; 5469 } catch (err: any) { 5470 A.store.Ref(errPtr, err); 5471 return A.H.FALSE; 5472 } 5473 }, 5474 "has_HasOnFileTransfersUpdated": (): heap.Ref<boolean> => { 5475 if ( 5476 WEBEXT?.fileManagerPrivate?.onFileTransfersUpdated && 5477 "hasListener" in WEBEXT?.fileManagerPrivate?.onFileTransfersUpdated 5478 ) { 5479 return A.H.TRUE; 5480 } 5481 return A.H.FALSE; 5482 }, 5483 "func_HasOnFileTransfersUpdated": (fn: Pointer): void => { 5484 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onFileTransfersUpdated.hasListener); 5485 }, 5486 "call_HasOnFileTransfersUpdated": (retPtr: Pointer, callback: heap.Ref<object>): void => { 5487 const _ret = WEBEXT.fileManagerPrivate.onFileTransfersUpdated.hasListener(A.H.get<object>(callback)); 5488 A.store.Bool(retPtr, _ret); 5489 }, 5490 "try_HasOnFileTransfersUpdated": ( 5491 retPtr: Pointer, 5492 errPtr: Pointer, 5493 callback: heap.Ref<object> 5494 ): heap.Ref<boolean> => { 5495 try { 5496 const _ret = WEBEXT.fileManagerPrivate.onFileTransfersUpdated.hasListener(A.H.get<object>(callback)); 5497 A.store.Bool(retPtr, _ret); 5498 return A.H.TRUE; 5499 } catch (err: any) { 5500 A.store.Ref(errPtr, err); 5501 return A.H.FALSE; 5502 } 5503 }, 5504 "has_OnIOTaskProgressStatus": (): heap.Ref<boolean> => { 5505 if ( 5506 WEBEXT?.fileManagerPrivate?.onIOTaskProgressStatus && 5507 "addListener" in WEBEXT?.fileManagerPrivate?.onIOTaskProgressStatus 5508 ) { 5509 return A.H.TRUE; 5510 } 5511 return A.H.FALSE; 5512 }, 5513 "func_OnIOTaskProgressStatus": (fn: Pointer): void => { 5514 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onIOTaskProgressStatus.addListener); 5515 }, 5516 "call_OnIOTaskProgressStatus": (retPtr: Pointer, callback: heap.Ref<object>): void => { 5517 const _ret = WEBEXT.fileManagerPrivate.onIOTaskProgressStatus.addListener(A.H.get<object>(callback)); 5518 }, 5519 "try_OnIOTaskProgressStatus": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 5520 try { 5521 const _ret = WEBEXT.fileManagerPrivate.onIOTaskProgressStatus.addListener(A.H.get<object>(callback)); 5522 return A.H.TRUE; 5523 } catch (err: any) { 5524 A.store.Ref(errPtr, err); 5525 return A.H.FALSE; 5526 } 5527 }, 5528 "has_OffIOTaskProgressStatus": (): heap.Ref<boolean> => { 5529 if ( 5530 WEBEXT?.fileManagerPrivate?.onIOTaskProgressStatus && 5531 "removeListener" in WEBEXT?.fileManagerPrivate?.onIOTaskProgressStatus 5532 ) { 5533 return A.H.TRUE; 5534 } 5535 return A.H.FALSE; 5536 }, 5537 "func_OffIOTaskProgressStatus": (fn: Pointer): void => { 5538 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onIOTaskProgressStatus.removeListener); 5539 }, 5540 "call_OffIOTaskProgressStatus": (retPtr: Pointer, callback: heap.Ref<object>): void => { 5541 const _ret = WEBEXT.fileManagerPrivate.onIOTaskProgressStatus.removeListener(A.H.get<object>(callback)); 5542 }, 5543 "try_OffIOTaskProgressStatus": ( 5544 retPtr: Pointer, 5545 errPtr: Pointer, 5546 callback: heap.Ref<object> 5547 ): heap.Ref<boolean> => { 5548 try { 5549 const _ret = WEBEXT.fileManagerPrivate.onIOTaskProgressStatus.removeListener(A.H.get<object>(callback)); 5550 return A.H.TRUE; 5551 } catch (err: any) { 5552 A.store.Ref(errPtr, err); 5553 return A.H.FALSE; 5554 } 5555 }, 5556 "has_HasOnIOTaskProgressStatus": (): heap.Ref<boolean> => { 5557 if ( 5558 WEBEXT?.fileManagerPrivate?.onIOTaskProgressStatus && 5559 "hasListener" in WEBEXT?.fileManagerPrivate?.onIOTaskProgressStatus 5560 ) { 5561 return A.H.TRUE; 5562 } 5563 return A.H.FALSE; 5564 }, 5565 "func_HasOnIOTaskProgressStatus": (fn: Pointer): void => { 5566 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onIOTaskProgressStatus.hasListener); 5567 }, 5568 "call_HasOnIOTaskProgressStatus": (retPtr: Pointer, callback: heap.Ref<object>): void => { 5569 const _ret = WEBEXT.fileManagerPrivate.onIOTaskProgressStatus.hasListener(A.H.get<object>(callback)); 5570 A.store.Bool(retPtr, _ret); 5571 }, 5572 "try_HasOnIOTaskProgressStatus": ( 5573 retPtr: Pointer, 5574 errPtr: Pointer, 5575 callback: heap.Ref<object> 5576 ): heap.Ref<boolean> => { 5577 try { 5578 const _ret = WEBEXT.fileManagerPrivate.onIOTaskProgressStatus.hasListener(A.H.get<object>(callback)); 5579 A.store.Bool(retPtr, _ret); 5580 return A.H.TRUE; 5581 } catch (err: any) { 5582 A.store.Ref(errPtr, err); 5583 return A.H.FALSE; 5584 } 5585 }, 5586 "has_OnIndividualFileTransfersUpdated": (): heap.Ref<boolean> => { 5587 if ( 5588 WEBEXT?.fileManagerPrivate?.onIndividualFileTransfersUpdated && 5589 "addListener" in WEBEXT?.fileManagerPrivate?.onIndividualFileTransfersUpdated 5590 ) { 5591 return A.H.TRUE; 5592 } 5593 return A.H.FALSE; 5594 }, 5595 "func_OnIndividualFileTransfersUpdated": (fn: Pointer): void => { 5596 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onIndividualFileTransfersUpdated.addListener); 5597 }, 5598 "call_OnIndividualFileTransfersUpdated": (retPtr: Pointer, callback: heap.Ref<object>): void => { 5599 const _ret = WEBEXT.fileManagerPrivate.onIndividualFileTransfersUpdated.addListener(A.H.get<object>(callback)); 5600 }, 5601 "try_OnIndividualFileTransfersUpdated": ( 5602 retPtr: Pointer, 5603 errPtr: Pointer, 5604 callback: heap.Ref<object> 5605 ): heap.Ref<boolean> => { 5606 try { 5607 const _ret = WEBEXT.fileManagerPrivate.onIndividualFileTransfersUpdated.addListener(A.H.get<object>(callback)); 5608 return A.H.TRUE; 5609 } catch (err: any) { 5610 A.store.Ref(errPtr, err); 5611 return A.H.FALSE; 5612 } 5613 }, 5614 "has_OffIndividualFileTransfersUpdated": (): heap.Ref<boolean> => { 5615 if ( 5616 WEBEXT?.fileManagerPrivate?.onIndividualFileTransfersUpdated && 5617 "removeListener" in WEBEXT?.fileManagerPrivate?.onIndividualFileTransfersUpdated 5618 ) { 5619 return A.H.TRUE; 5620 } 5621 return A.H.FALSE; 5622 }, 5623 "func_OffIndividualFileTransfersUpdated": (fn: Pointer): void => { 5624 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onIndividualFileTransfersUpdated.removeListener); 5625 }, 5626 "call_OffIndividualFileTransfersUpdated": (retPtr: Pointer, callback: heap.Ref<object>): void => { 5627 const _ret = WEBEXT.fileManagerPrivate.onIndividualFileTransfersUpdated.removeListener(A.H.get<object>(callback)); 5628 }, 5629 "try_OffIndividualFileTransfersUpdated": ( 5630 retPtr: Pointer, 5631 errPtr: Pointer, 5632 callback: heap.Ref<object> 5633 ): heap.Ref<boolean> => { 5634 try { 5635 const _ret = WEBEXT.fileManagerPrivate.onIndividualFileTransfersUpdated.removeListener( 5636 A.H.get<object>(callback) 5637 ); 5638 return A.H.TRUE; 5639 } catch (err: any) { 5640 A.store.Ref(errPtr, err); 5641 return A.H.FALSE; 5642 } 5643 }, 5644 "has_HasOnIndividualFileTransfersUpdated": (): heap.Ref<boolean> => { 5645 if ( 5646 WEBEXT?.fileManagerPrivate?.onIndividualFileTransfersUpdated && 5647 "hasListener" in WEBEXT?.fileManagerPrivate?.onIndividualFileTransfersUpdated 5648 ) { 5649 return A.H.TRUE; 5650 } 5651 return A.H.FALSE; 5652 }, 5653 "func_HasOnIndividualFileTransfersUpdated": (fn: Pointer): void => { 5654 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onIndividualFileTransfersUpdated.hasListener); 5655 }, 5656 "call_HasOnIndividualFileTransfersUpdated": (retPtr: Pointer, callback: heap.Ref<object>): void => { 5657 const _ret = WEBEXT.fileManagerPrivate.onIndividualFileTransfersUpdated.hasListener(A.H.get<object>(callback)); 5658 A.store.Bool(retPtr, _ret); 5659 }, 5660 "try_HasOnIndividualFileTransfersUpdated": ( 5661 retPtr: Pointer, 5662 errPtr: Pointer, 5663 callback: heap.Ref<object> 5664 ): heap.Ref<boolean> => { 5665 try { 5666 const _ret = WEBEXT.fileManagerPrivate.onIndividualFileTransfersUpdated.hasListener(A.H.get<object>(callback)); 5667 A.store.Bool(retPtr, _ret); 5668 return A.H.TRUE; 5669 } catch (err: any) { 5670 A.store.Ref(errPtr, err); 5671 return A.H.FALSE; 5672 } 5673 }, 5674 "has_OnMountCompleted": (): heap.Ref<boolean> => { 5675 if ( 5676 WEBEXT?.fileManagerPrivate?.onMountCompleted && 5677 "addListener" in WEBEXT?.fileManagerPrivate?.onMountCompleted 5678 ) { 5679 return A.H.TRUE; 5680 } 5681 return A.H.FALSE; 5682 }, 5683 "func_OnMountCompleted": (fn: Pointer): void => { 5684 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onMountCompleted.addListener); 5685 }, 5686 "call_OnMountCompleted": (retPtr: Pointer, callback: heap.Ref<object>): void => { 5687 const _ret = WEBEXT.fileManagerPrivate.onMountCompleted.addListener(A.H.get<object>(callback)); 5688 }, 5689 "try_OnMountCompleted": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 5690 try { 5691 const _ret = WEBEXT.fileManagerPrivate.onMountCompleted.addListener(A.H.get<object>(callback)); 5692 return A.H.TRUE; 5693 } catch (err: any) { 5694 A.store.Ref(errPtr, err); 5695 return A.H.FALSE; 5696 } 5697 }, 5698 "has_OffMountCompleted": (): heap.Ref<boolean> => { 5699 if ( 5700 WEBEXT?.fileManagerPrivate?.onMountCompleted && 5701 "removeListener" in WEBEXT?.fileManagerPrivate?.onMountCompleted 5702 ) { 5703 return A.H.TRUE; 5704 } 5705 return A.H.FALSE; 5706 }, 5707 "func_OffMountCompleted": (fn: Pointer): void => { 5708 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onMountCompleted.removeListener); 5709 }, 5710 "call_OffMountCompleted": (retPtr: Pointer, callback: heap.Ref<object>): void => { 5711 const _ret = WEBEXT.fileManagerPrivate.onMountCompleted.removeListener(A.H.get<object>(callback)); 5712 }, 5713 "try_OffMountCompleted": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 5714 try { 5715 const _ret = WEBEXT.fileManagerPrivate.onMountCompleted.removeListener(A.H.get<object>(callback)); 5716 return A.H.TRUE; 5717 } catch (err: any) { 5718 A.store.Ref(errPtr, err); 5719 return A.H.FALSE; 5720 } 5721 }, 5722 "has_HasOnMountCompleted": (): heap.Ref<boolean> => { 5723 if ( 5724 WEBEXT?.fileManagerPrivate?.onMountCompleted && 5725 "hasListener" in WEBEXT?.fileManagerPrivate?.onMountCompleted 5726 ) { 5727 return A.H.TRUE; 5728 } 5729 return A.H.FALSE; 5730 }, 5731 "func_HasOnMountCompleted": (fn: Pointer): void => { 5732 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onMountCompleted.hasListener); 5733 }, 5734 "call_HasOnMountCompleted": (retPtr: Pointer, callback: heap.Ref<object>): void => { 5735 const _ret = WEBEXT.fileManagerPrivate.onMountCompleted.hasListener(A.H.get<object>(callback)); 5736 A.store.Bool(retPtr, _ret); 5737 }, 5738 "try_HasOnMountCompleted": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 5739 try { 5740 const _ret = WEBEXT.fileManagerPrivate.onMountCompleted.hasListener(A.H.get<object>(callback)); 5741 A.store.Bool(retPtr, _ret); 5742 return A.H.TRUE; 5743 } catch (err: any) { 5744 A.store.Ref(errPtr, err); 5745 return A.H.FALSE; 5746 } 5747 }, 5748 "has_OnMountableGuestsChanged": (): heap.Ref<boolean> => { 5749 if ( 5750 WEBEXT?.fileManagerPrivate?.onMountableGuestsChanged && 5751 "addListener" in WEBEXT?.fileManagerPrivate?.onMountableGuestsChanged 5752 ) { 5753 return A.H.TRUE; 5754 } 5755 return A.H.FALSE; 5756 }, 5757 "func_OnMountableGuestsChanged": (fn: Pointer): void => { 5758 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onMountableGuestsChanged.addListener); 5759 }, 5760 "call_OnMountableGuestsChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 5761 const _ret = WEBEXT.fileManagerPrivate.onMountableGuestsChanged.addListener(A.H.get<object>(callback)); 5762 }, 5763 "try_OnMountableGuestsChanged": ( 5764 retPtr: Pointer, 5765 errPtr: Pointer, 5766 callback: heap.Ref<object> 5767 ): heap.Ref<boolean> => { 5768 try { 5769 const _ret = WEBEXT.fileManagerPrivate.onMountableGuestsChanged.addListener(A.H.get<object>(callback)); 5770 return A.H.TRUE; 5771 } catch (err: any) { 5772 A.store.Ref(errPtr, err); 5773 return A.H.FALSE; 5774 } 5775 }, 5776 "has_OffMountableGuestsChanged": (): heap.Ref<boolean> => { 5777 if ( 5778 WEBEXT?.fileManagerPrivate?.onMountableGuestsChanged && 5779 "removeListener" in WEBEXT?.fileManagerPrivate?.onMountableGuestsChanged 5780 ) { 5781 return A.H.TRUE; 5782 } 5783 return A.H.FALSE; 5784 }, 5785 "func_OffMountableGuestsChanged": (fn: Pointer): void => { 5786 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onMountableGuestsChanged.removeListener); 5787 }, 5788 "call_OffMountableGuestsChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 5789 const _ret = WEBEXT.fileManagerPrivate.onMountableGuestsChanged.removeListener(A.H.get<object>(callback)); 5790 }, 5791 "try_OffMountableGuestsChanged": ( 5792 retPtr: Pointer, 5793 errPtr: Pointer, 5794 callback: heap.Ref<object> 5795 ): heap.Ref<boolean> => { 5796 try { 5797 const _ret = WEBEXT.fileManagerPrivate.onMountableGuestsChanged.removeListener(A.H.get<object>(callback)); 5798 return A.H.TRUE; 5799 } catch (err: any) { 5800 A.store.Ref(errPtr, err); 5801 return A.H.FALSE; 5802 } 5803 }, 5804 "has_HasOnMountableGuestsChanged": (): heap.Ref<boolean> => { 5805 if ( 5806 WEBEXT?.fileManagerPrivate?.onMountableGuestsChanged && 5807 "hasListener" in WEBEXT?.fileManagerPrivate?.onMountableGuestsChanged 5808 ) { 5809 return A.H.TRUE; 5810 } 5811 return A.H.FALSE; 5812 }, 5813 "func_HasOnMountableGuestsChanged": (fn: Pointer): void => { 5814 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onMountableGuestsChanged.hasListener); 5815 }, 5816 "call_HasOnMountableGuestsChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 5817 const _ret = WEBEXT.fileManagerPrivate.onMountableGuestsChanged.hasListener(A.H.get<object>(callback)); 5818 A.store.Bool(retPtr, _ret); 5819 }, 5820 "try_HasOnMountableGuestsChanged": ( 5821 retPtr: Pointer, 5822 errPtr: Pointer, 5823 callback: heap.Ref<object> 5824 ): heap.Ref<boolean> => { 5825 try { 5826 const _ret = WEBEXT.fileManagerPrivate.onMountableGuestsChanged.hasListener(A.H.get<object>(callback)); 5827 A.store.Bool(retPtr, _ret); 5828 return A.H.TRUE; 5829 } catch (err: any) { 5830 A.store.Ref(errPtr, err); 5831 return A.H.FALSE; 5832 } 5833 }, 5834 "has_OnPinTransfersUpdated": (): heap.Ref<boolean> => { 5835 if ( 5836 WEBEXT?.fileManagerPrivate?.onPinTransfersUpdated && 5837 "addListener" in WEBEXT?.fileManagerPrivate?.onPinTransfersUpdated 5838 ) { 5839 return A.H.TRUE; 5840 } 5841 return A.H.FALSE; 5842 }, 5843 "func_OnPinTransfersUpdated": (fn: Pointer): void => { 5844 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onPinTransfersUpdated.addListener); 5845 }, 5846 "call_OnPinTransfersUpdated": (retPtr: Pointer, callback: heap.Ref<object>): void => { 5847 const _ret = WEBEXT.fileManagerPrivate.onPinTransfersUpdated.addListener(A.H.get<object>(callback)); 5848 }, 5849 "try_OnPinTransfersUpdated": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 5850 try { 5851 const _ret = WEBEXT.fileManagerPrivate.onPinTransfersUpdated.addListener(A.H.get<object>(callback)); 5852 return A.H.TRUE; 5853 } catch (err: any) { 5854 A.store.Ref(errPtr, err); 5855 return A.H.FALSE; 5856 } 5857 }, 5858 "has_OffPinTransfersUpdated": (): heap.Ref<boolean> => { 5859 if ( 5860 WEBEXT?.fileManagerPrivate?.onPinTransfersUpdated && 5861 "removeListener" in WEBEXT?.fileManagerPrivate?.onPinTransfersUpdated 5862 ) { 5863 return A.H.TRUE; 5864 } 5865 return A.H.FALSE; 5866 }, 5867 "func_OffPinTransfersUpdated": (fn: Pointer): void => { 5868 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onPinTransfersUpdated.removeListener); 5869 }, 5870 "call_OffPinTransfersUpdated": (retPtr: Pointer, callback: heap.Ref<object>): void => { 5871 const _ret = WEBEXT.fileManagerPrivate.onPinTransfersUpdated.removeListener(A.H.get<object>(callback)); 5872 }, 5873 "try_OffPinTransfersUpdated": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 5874 try { 5875 const _ret = WEBEXT.fileManagerPrivate.onPinTransfersUpdated.removeListener(A.H.get<object>(callback)); 5876 return A.H.TRUE; 5877 } catch (err: any) { 5878 A.store.Ref(errPtr, err); 5879 return A.H.FALSE; 5880 } 5881 }, 5882 "has_HasOnPinTransfersUpdated": (): heap.Ref<boolean> => { 5883 if ( 5884 WEBEXT?.fileManagerPrivate?.onPinTransfersUpdated && 5885 "hasListener" in WEBEXT?.fileManagerPrivate?.onPinTransfersUpdated 5886 ) { 5887 return A.H.TRUE; 5888 } 5889 return A.H.FALSE; 5890 }, 5891 "func_HasOnPinTransfersUpdated": (fn: Pointer): void => { 5892 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onPinTransfersUpdated.hasListener); 5893 }, 5894 "call_HasOnPinTransfersUpdated": (retPtr: Pointer, callback: heap.Ref<object>): void => { 5895 const _ret = WEBEXT.fileManagerPrivate.onPinTransfersUpdated.hasListener(A.H.get<object>(callback)); 5896 A.store.Bool(retPtr, _ret); 5897 }, 5898 "try_HasOnPinTransfersUpdated": ( 5899 retPtr: Pointer, 5900 errPtr: Pointer, 5901 callback: heap.Ref<object> 5902 ): heap.Ref<boolean> => { 5903 try { 5904 const _ret = WEBEXT.fileManagerPrivate.onPinTransfersUpdated.hasListener(A.H.get<object>(callback)); 5905 A.store.Bool(retPtr, _ret); 5906 return A.H.TRUE; 5907 } catch (err: any) { 5908 A.store.Ref(errPtr, err); 5909 return A.H.FALSE; 5910 } 5911 }, 5912 "has_OnPreferencesChanged": (): heap.Ref<boolean> => { 5913 if ( 5914 WEBEXT?.fileManagerPrivate?.onPreferencesChanged && 5915 "addListener" in WEBEXT?.fileManagerPrivate?.onPreferencesChanged 5916 ) { 5917 return A.H.TRUE; 5918 } 5919 return A.H.FALSE; 5920 }, 5921 "func_OnPreferencesChanged": (fn: Pointer): void => { 5922 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onPreferencesChanged.addListener); 5923 }, 5924 "call_OnPreferencesChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 5925 const _ret = WEBEXT.fileManagerPrivate.onPreferencesChanged.addListener(A.H.get<object>(callback)); 5926 }, 5927 "try_OnPreferencesChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 5928 try { 5929 const _ret = WEBEXT.fileManagerPrivate.onPreferencesChanged.addListener(A.H.get<object>(callback)); 5930 return A.H.TRUE; 5931 } catch (err: any) { 5932 A.store.Ref(errPtr, err); 5933 return A.H.FALSE; 5934 } 5935 }, 5936 "has_OffPreferencesChanged": (): heap.Ref<boolean> => { 5937 if ( 5938 WEBEXT?.fileManagerPrivate?.onPreferencesChanged && 5939 "removeListener" in WEBEXT?.fileManagerPrivate?.onPreferencesChanged 5940 ) { 5941 return A.H.TRUE; 5942 } 5943 return A.H.FALSE; 5944 }, 5945 "func_OffPreferencesChanged": (fn: Pointer): void => { 5946 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onPreferencesChanged.removeListener); 5947 }, 5948 "call_OffPreferencesChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 5949 const _ret = WEBEXT.fileManagerPrivate.onPreferencesChanged.removeListener(A.H.get<object>(callback)); 5950 }, 5951 "try_OffPreferencesChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 5952 try { 5953 const _ret = WEBEXT.fileManagerPrivate.onPreferencesChanged.removeListener(A.H.get<object>(callback)); 5954 return A.H.TRUE; 5955 } catch (err: any) { 5956 A.store.Ref(errPtr, err); 5957 return A.H.FALSE; 5958 } 5959 }, 5960 "has_HasOnPreferencesChanged": (): heap.Ref<boolean> => { 5961 if ( 5962 WEBEXT?.fileManagerPrivate?.onPreferencesChanged && 5963 "hasListener" in WEBEXT?.fileManagerPrivate?.onPreferencesChanged 5964 ) { 5965 return A.H.TRUE; 5966 } 5967 return A.H.FALSE; 5968 }, 5969 "func_HasOnPreferencesChanged": (fn: Pointer): void => { 5970 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onPreferencesChanged.hasListener); 5971 }, 5972 "call_HasOnPreferencesChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 5973 const _ret = WEBEXT.fileManagerPrivate.onPreferencesChanged.hasListener(A.H.get<object>(callback)); 5974 A.store.Bool(retPtr, _ret); 5975 }, 5976 "try_HasOnPreferencesChanged": ( 5977 retPtr: Pointer, 5978 errPtr: Pointer, 5979 callback: heap.Ref<object> 5980 ): heap.Ref<boolean> => { 5981 try { 5982 const _ret = WEBEXT.fileManagerPrivate.onPreferencesChanged.hasListener(A.H.get<object>(callback)); 5983 A.store.Bool(retPtr, _ret); 5984 return A.H.TRUE; 5985 } catch (err: any) { 5986 A.store.Ref(errPtr, err); 5987 return A.H.FALSE; 5988 } 5989 }, 5990 "has_OnTabletModeChanged": (): heap.Ref<boolean> => { 5991 if ( 5992 WEBEXT?.fileManagerPrivate?.onTabletModeChanged && 5993 "addListener" in WEBEXT?.fileManagerPrivate?.onTabletModeChanged 5994 ) { 5995 return A.H.TRUE; 5996 } 5997 return A.H.FALSE; 5998 }, 5999 "func_OnTabletModeChanged": (fn: Pointer): void => { 6000 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onTabletModeChanged.addListener); 6001 }, 6002 "call_OnTabletModeChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 6003 const _ret = WEBEXT.fileManagerPrivate.onTabletModeChanged.addListener(A.H.get<object>(callback)); 6004 }, 6005 "try_OnTabletModeChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 6006 try { 6007 const _ret = WEBEXT.fileManagerPrivate.onTabletModeChanged.addListener(A.H.get<object>(callback)); 6008 return A.H.TRUE; 6009 } catch (err: any) { 6010 A.store.Ref(errPtr, err); 6011 return A.H.FALSE; 6012 } 6013 }, 6014 "has_OffTabletModeChanged": (): heap.Ref<boolean> => { 6015 if ( 6016 WEBEXT?.fileManagerPrivate?.onTabletModeChanged && 6017 "removeListener" in WEBEXT?.fileManagerPrivate?.onTabletModeChanged 6018 ) { 6019 return A.H.TRUE; 6020 } 6021 return A.H.FALSE; 6022 }, 6023 "func_OffTabletModeChanged": (fn: Pointer): void => { 6024 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onTabletModeChanged.removeListener); 6025 }, 6026 "call_OffTabletModeChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 6027 const _ret = WEBEXT.fileManagerPrivate.onTabletModeChanged.removeListener(A.H.get<object>(callback)); 6028 }, 6029 "try_OffTabletModeChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 6030 try { 6031 const _ret = WEBEXT.fileManagerPrivate.onTabletModeChanged.removeListener(A.H.get<object>(callback)); 6032 return A.H.TRUE; 6033 } catch (err: any) { 6034 A.store.Ref(errPtr, err); 6035 return A.H.FALSE; 6036 } 6037 }, 6038 "has_HasOnTabletModeChanged": (): heap.Ref<boolean> => { 6039 if ( 6040 WEBEXT?.fileManagerPrivate?.onTabletModeChanged && 6041 "hasListener" in WEBEXT?.fileManagerPrivate?.onTabletModeChanged 6042 ) { 6043 return A.H.TRUE; 6044 } 6045 return A.H.FALSE; 6046 }, 6047 "func_HasOnTabletModeChanged": (fn: Pointer): void => { 6048 A.store.Ref(fn, WEBEXT.fileManagerPrivate.onTabletModeChanged.hasListener); 6049 }, 6050 "call_HasOnTabletModeChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 6051 const _ret = WEBEXT.fileManagerPrivate.onTabletModeChanged.hasListener(A.H.get<object>(callback)); 6052 A.store.Bool(retPtr, _ret); 6053 }, 6054 "try_HasOnTabletModeChanged": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 6055 try { 6056 const _ret = WEBEXT.fileManagerPrivate.onTabletModeChanged.hasListener(A.H.get<object>(callback)); 6057 A.store.Bool(retPtr, _ret); 6058 return A.H.TRUE; 6059 } catch (err: any) { 6060 A.store.Ref(errPtr, err); 6061 return A.H.FALSE; 6062 } 6063 }, 6064 "has_OpenInspector": (): heap.Ref<boolean> => { 6065 if (WEBEXT?.fileManagerPrivate && "openInspector" in WEBEXT?.fileManagerPrivate) { 6066 return A.H.TRUE; 6067 } 6068 return A.H.FALSE; 6069 }, 6070 "func_OpenInspector": (fn: Pointer): void => { 6071 A.store.Ref(fn, WEBEXT.fileManagerPrivate.openInspector); 6072 }, 6073 "call_OpenInspector": (retPtr: Pointer, type: number): void => { 6074 const _ret = WEBEXT.fileManagerPrivate.openInspector( 6075 type > 0 && type <= 4 ? ["normal", "console", "element", "background"][type - 1] : undefined 6076 ); 6077 }, 6078 "try_OpenInspector": (retPtr: Pointer, errPtr: Pointer, type: number): heap.Ref<boolean> => { 6079 try { 6080 const _ret = WEBEXT.fileManagerPrivate.openInspector( 6081 type > 0 && type <= 4 ? ["normal", "console", "element", "background"][type - 1] : undefined 6082 ); 6083 return A.H.TRUE; 6084 } catch (err: any) { 6085 A.store.Ref(errPtr, err); 6086 return A.H.FALSE; 6087 } 6088 }, 6089 "has_OpenManageSyncSettings": (): heap.Ref<boolean> => { 6090 if (WEBEXT?.fileManagerPrivate && "openManageSyncSettings" in WEBEXT?.fileManagerPrivate) { 6091 return A.H.TRUE; 6092 } 6093 return A.H.FALSE; 6094 }, 6095 "func_OpenManageSyncSettings": (fn: Pointer): void => { 6096 A.store.Ref(fn, WEBEXT.fileManagerPrivate.openManageSyncSettings); 6097 }, 6098 "call_OpenManageSyncSettings": (retPtr: Pointer): void => { 6099 const _ret = WEBEXT.fileManagerPrivate.openManageSyncSettings(); 6100 }, 6101 "try_OpenManageSyncSettings": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 6102 try { 6103 const _ret = WEBEXT.fileManagerPrivate.openManageSyncSettings(); 6104 return A.H.TRUE; 6105 } catch (err: any) { 6106 A.store.Ref(errPtr, err); 6107 return A.H.FALSE; 6108 } 6109 }, 6110 "has_OpenSettingsSubpage": (): heap.Ref<boolean> => { 6111 if (WEBEXT?.fileManagerPrivate && "openSettingsSubpage" in WEBEXT?.fileManagerPrivate) { 6112 return A.H.TRUE; 6113 } 6114 return A.H.FALSE; 6115 }, 6116 "func_OpenSettingsSubpage": (fn: Pointer): void => { 6117 A.store.Ref(fn, WEBEXT.fileManagerPrivate.openSettingsSubpage); 6118 }, 6119 "call_OpenSettingsSubpage": (retPtr: Pointer, sub_page: heap.Ref<object>): void => { 6120 const _ret = WEBEXT.fileManagerPrivate.openSettingsSubpage(A.H.get<object>(sub_page)); 6121 }, 6122 "try_OpenSettingsSubpage": (retPtr: Pointer, errPtr: Pointer, sub_page: heap.Ref<object>): heap.Ref<boolean> => { 6123 try { 6124 const _ret = WEBEXT.fileManagerPrivate.openSettingsSubpage(A.H.get<object>(sub_page)); 6125 return A.H.TRUE; 6126 } catch (err: any) { 6127 A.store.Ref(errPtr, err); 6128 return A.H.FALSE; 6129 } 6130 }, 6131 "has_OpenURL": (): heap.Ref<boolean> => { 6132 if (WEBEXT?.fileManagerPrivate && "openURL" in WEBEXT?.fileManagerPrivate) { 6133 return A.H.TRUE; 6134 } 6135 return A.H.FALSE; 6136 }, 6137 "func_OpenURL": (fn: Pointer): void => { 6138 A.store.Ref(fn, WEBEXT.fileManagerPrivate.openURL); 6139 }, 6140 "call_OpenURL": (retPtr: Pointer, url: heap.Ref<object>): void => { 6141 const _ret = WEBEXT.fileManagerPrivate.openURL(A.H.get<object>(url)); 6142 }, 6143 "try_OpenURL": (retPtr: Pointer, errPtr: Pointer, url: heap.Ref<object>): heap.Ref<boolean> => { 6144 try { 6145 const _ret = WEBEXT.fileManagerPrivate.openURL(A.H.get<object>(url)); 6146 return A.H.TRUE; 6147 } catch (err: any) { 6148 A.store.Ref(errPtr, err); 6149 return A.H.FALSE; 6150 } 6151 }, 6152 "has_OpenWindow": (): heap.Ref<boolean> => { 6153 if (WEBEXT?.fileManagerPrivate && "openWindow" in WEBEXT?.fileManagerPrivate) { 6154 return A.H.TRUE; 6155 } 6156 return A.H.FALSE; 6157 }, 6158 "func_OpenWindow": (fn: Pointer): void => { 6159 A.store.Ref(fn, WEBEXT.fileManagerPrivate.openWindow); 6160 }, 6161 "call_OpenWindow": (retPtr: Pointer, params: Pointer): void => { 6162 const params_ffi = {}; 6163 6164 params_ffi["currentDirectoryURL"] = A.load.Ref(params + 0, undefined); 6165 params_ffi["selectionURL"] = A.load.Ref(params + 4, undefined); 6166 6167 const _ret = WEBEXT.fileManagerPrivate.openWindow(params_ffi); 6168 A.store.Ref(retPtr, _ret); 6169 }, 6170 "try_OpenWindow": (retPtr: Pointer, errPtr: Pointer, params: Pointer): heap.Ref<boolean> => { 6171 try { 6172 const params_ffi = {}; 6173 6174 params_ffi["currentDirectoryURL"] = A.load.Ref(params + 0, undefined); 6175 params_ffi["selectionURL"] = A.load.Ref(params + 4, undefined); 6176 6177 const _ret = WEBEXT.fileManagerPrivate.openWindow(params_ffi); 6178 A.store.Ref(retPtr, _ret); 6179 return A.H.TRUE; 6180 } catch (err: any) { 6181 A.store.Ref(errPtr, err); 6182 return A.H.FALSE; 6183 } 6184 }, 6185 "has_ParseTrashInfoFiles": (): heap.Ref<boolean> => { 6186 if (WEBEXT?.fileManagerPrivate && "parseTrashInfoFiles" in WEBEXT?.fileManagerPrivate) { 6187 return A.H.TRUE; 6188 } 6189 return A.H.FALSE; 6190 }, 6191 "func_ParseTrashInfoFiles": (fn: Pointer): void => { 6192 A.store.Ref(fn, WEBEXT.fileManagerPrivate.parseTrashInfoFiles); 6193 }, 6194 "call_ParseTrashInfoFiles": (retPtr: Pointer, entries: heap.Ref<object>): void => { 6195 const _ret = WEBEXT.fileManagerPrivate.parseTrashInfoFiles(A.H.get<object>(entries)); 6196 A.store.Ref(retPtr, _ret); 6197 }, 6198 "try_ParseTrashInfoFiles": (retPtr: Pointer, errPtr: Pointer, entries: heap.Ref<object>): heap.Ref<boolean> => { 6199 try { 6200 const _ret = WEBEXT.fileManagerPrivate.parseTrashInfoFiles(A.H.get<object>(entries)); 6201 A.store.Ref(retPtr, _ret); 6202 return A.H.TRUE; 6203 } catch (err: any) { 6204 A.store.Ref(errPtr, err); 6205 return A.H.FALSE; 6206 } 6207 }, 6208 "has_PinDriveFile": (): heap.Ref<boolean> => { 6209 if (WEBEXT?.fileManagerPrivate && "pinDriveFile" in WEBEXT?.fileManagerPrivate) { 6210 return A.H.TRUE; 6211 } 6212 return A.H.FALSE; 6213 }, 6214 "func_PinDriveFile": (fn: Pointer): void => { 6215 A.store.Ref(fn, WEBEXT.fileManagerPrivate.pinDriveFile); 6216 }, 6217 "call_PinDriveFile": (retPtr: Pointer, entry: heap.Ref<object>, pin: heap.Ref<boolean>): void => { 6218 const _ret = WEBEXT.fileManagerPrivate.pinDriveFile(A.H.get<object>(entry), pin === A.H.TRUE); 6219 A.store.Ref(retPtr, _ret); 6220 }, 6221 "try_PinDriveFile": ( 6222 retPtr: Pointer, 6223 errPtr: Pointer, 6224 entry: heap.Ref<object>, 6225 pin: heap.Ref<boolean> 6226 ): heap.Ref<boolean> => { 6227 try { 6228 const _ret = WEBEXT.fileManagerPrivate.pinDriveFile(A.H.get<object>(entry), pin === A.H.TRUE); 6229 A.store.Ref(retPtr, _ret); 6230 return A.H.TRUE; 6231 } catch (err: any) { 6232 A.store.Ref(errPtr, err); 6233 return A.H.FALSE; 6234 } 6235 }, 6236 "has_PollDriveHostedFilePinStates": (): heap.Ref<boolean> => { 6237 if (WEBEXT?.fileManagerPrivate && "pollDriveHostedFilePinStates" in WEBEXT?.fileManagerPrivate) { 6238 return A.H.TRUE; 6239 } 6240 return A.H.FALSE; 6241 }, 6242 "func_PollDriveHostedFilePinStates": (fn: Pointer): void => { 6243 A.store.Ref(fn, WEBEXT.fileManagerPrivate.pollDriveHostedFilePinStates); 6244 }, 6245 "call_PollDriveHostedFilePinStates": (retPtr: Pointer): void => { 6246 const _ret = WEBEXT.fileManagerPrivate.pollDriveHostedFilePinStates(); 6247 }, 6248 "try_PollDriveHostedFilePinStates": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 6249 try { 6250 const _ret = WEBEXT.fileManagerPrivate.pollDriveHostedFilePinStates(); 6251 return A.H.TRUE; 6252 } catch (err: any) { 6253 A.store.Ref(errPtr, err); 6254 return A.H.FALSE; 6255 } 6256 }, 6257 "has_ProgressPausedTasks": (): heap.Ref<boolean> => { 6258 if (WEBEXT?.fileManagerPrivate && "progressPausedTasks" in WEBEXT?.fileManagerPrivate) { 6259 return A.H.TRUE; 6260 } 6261 return A.H.FALSE; 6262 }, 6263 "func_ProgressPausedTasks": (fn: Pointer): void => { 6264 A.store.Ref(fn, WEBEXT.fileManagerPrivate.progressPausedTasks); 6265 }, 6266 "call_ProgressPausedTasks": (retPtr: Pointer): void => { 6267 const _ret = WEBEXT.fileManagerPrivate.progressPausedTasks(); 6268 }, 6269 "try_ProgressPausedTasks": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 6270 try { 6271 const _ret = WEBEXT.fileManagerPrivate.progressPausedTasks(); 6272 return A.H.TRUE; 6273 } catch (err: any) { 6274 A.store.Ref(errPtr, err); 6275 return A.H.FALSE; 6276 } 6277 }, 6278 "has_RemoveFileWatch": (): heap.Ref<boolean> => { 6279 if (WEBEXT?.fileManagerPrivate && "removeFileWatch" in WEBEXT?.fileManagerPrivate) { 6280 return A.H.TRUE; 6281 } 6282 return A.H.FALSE; 6283 }, 6284 "func_RemoveFileWatch": (fn: Pointer): void => { 6285 A.store.Ref(fn, WEBEXT.fileManagerPrivate.removeFileWatch); 6286 }, 6287 "call_RemoveFileWatch": (retPtr: Pointer, entry: heap.Ref<object>): void => { 6288 const _ret = WEBEXT.fileManagerPrivate.removeFileWatch(A.H.get<object>(entry)); 6289 A.store.Ref(retPtr, _ret); 6290 }, 6291 "try_RemoveFileWatch": (retPtr: Pointer, errPtr: Pointer, entry: heap.Ref<object>): heap.Ref<boolean> => { 6292 try { 6293 const _ret = WEBEXT.fileManagerPrivate.removeFileWatch(A.H.get<object>(entry)); 6294 A.store.Ref(retPtr, _ret); 6295 return A.H.TRUE; 6296 } catch (err: any) { 6297 A.store.Ref(errPtr, err); 6298 return A.H.FALSE; 6299 } 6300 }, 6301 "has_RemoveMount": (): heap.Ref<boolean> => { 6302 if (WEBEXT?.fileManagerPrivate && "removeMount" in WEBEXT?.fileManagerPrivate) { 6303 return A.H.TRUE; 6304 } 6305 return A.H.FALSE; 6306 }, 6307 "func_RemoveMount": (fn: Pointer): void => { 6308 A.store.Ref(fn, WEBEXT.fileManagerPrivate.removeMount); 6309 }, 6310 "call_RemoveMount": (retPtr: Pointer, volumeId: heap.Ref<object>): void => { 6311 const _ret = WEBEXT.fileManagerPrivate.removeMount(A.H.get<object>(volumeId)); 6312 A.store.Ref(retPtr, _ret); 6313 }, 6314 "try_RemoveMount": (retPtr: Pointer, errPtr: Pointer, volumeId: heap.Ref<object>): heap.Ref<boolean> => { 6315 try { 6316 const _ret = WEBEXT.fileManagerPrivate.removeMount(A.H.get<object>(volumeId)); 6317 A.store.Ref(retPtr, _ret); 6318 return A.H.TRUE; 6319 } catch (err: any) { 6320 A.store.Ref(errPtr, err); 6321 return A.H.FALSE; 6322 } 6323 }, 6324 "has_RenameVolume": (): heap.Ref<boolean> => { 6325 if (WEBEXT?.fileManagerPrivate && "renameVolume" in WEBEXT?.fileManagerPrivate) { 6326 return A.H.TRUE; 6327 } 6328 return A.H.FALSE; 6329 }, 6330 "func_RenameVolume": (fn: Pointer): void => { 6331 A.store.Ref(fn, WEBEXT.fileManagerPrivate.renameVolume); 6332 }, 6333 "call_RenameVolume": (retPtr: Pointer, volumeId: heap.Ref<object>, newName: heap.Ref<object>): void => { 6334 const _ret = WEBEXT.fileManagerPrivate.renameVolume(A.H.get<object>(volumeId), A.H.get<object>(newName)); 6335 }, 6336 "try_RenameVolume": ( 6337 retPtr: Pointer, 6338 errPtr: Pointer, 6339 volumeId: heap.Ref<object>, 6340 newName: heap.Ref<object> 6341 ): heap.Ref<boolean> => { 6342 try { 6343 const _ret = WEBEXT.fileManagerPrivate.renameVolume(A.H.get<object>(volumeId), A.H.get<object>(newName)); 6344 return A.H.TRUE; 6345 } catch (err: any) { 6346 A.store.Ref(errPtr, err); 6347 return A.H.FALSE; 6348 } 6349 }, 6350 "has_ResolveIsolatedEntries": (): heap.Ref<boolean> => { 6351 if (WEBEXT?.fileManagerPrivate && "resolveIsolatedEntries" in WEBEXT?.fileManagerPrivate) { 6352 return A.H.TRUE; 6353 } 6354 return A.H.FALSE; 6355 }, 6356 "func_ResolveIsolatedEntries": (fn: Pointer): void => { 6357 A.store.Ref(fn, WEBEXT.fileManagerPrivate.resolveIsolatedEntries); 6358 }, 6359 "call_ResolveIsolatedEntries": (retPtr: Pointer, entries: heap.Ref<object>): void => { 6360 const _ret = WEBEXT.fileManagerPrivate.resolveIsolatedEntries(A.H.get<object>(entries)); 6361 A.store.Ref(retPtr, _ret); 6362 }, 6363 "try_ResolveIsolatedEntries": (retPtr: Pointer, errPtr: Pointer, entries: heap.Ref<object>): heap.Ref<boolean> => { 6364 try { 6365 const _ret = WEBEXT.fileManagerPrivate.resolveIsolatedEntries(A.H.get<object>(entries)); 6366 A.store.Ref(retPtr, _ret); 6367 return A.H.TRUE; 6368 } catch (err: any) { 6369 A.store.Ref(errPtr, err); 6370 return A.H.FALSE; 6371 } 6372 }, 6373 "has_ResumeIOTask": (): heap.Ref<boolean> => { 6374 if (WEBEXT?.fileManagerPrivate && "resumeIOTask" in WEBEXT?.fileManagerPrivate) { 6375 return A.H.TRUE; 6376 } 6377 return A.H.FALSE; 6378 }, 6379 "func_ResumeIOTask": (fn: Pointer): void => { 6380 A.store.Ref(fn, WEBEXT.fileManagerPrivate.resumeIOTask); 6381 }, 6382 "call_ResumeIOTask": (retPtr: Pointer, taskId: number, params: Pointer): void => { 6383 const params_ffi = {}; 6384 6385 if (A.load.Bool(params + 0 + 6)) { 6386 params_ffi["conflictParams"] = {}; 6387 params_ffi["conflictParams"]["conflictResolve"] = A.load.Ref(params + 0 + 0, undefined); 6388 if (A.load.Bool(params + 0 + 5)) { 6389 params_ffi["conflictParams"]["conflictApplyToAll"] = A.load.Bool(params + 0 + 4); 6390 } 6391 } 6392 if (A.load.Bool(params + 8 + 4)) { 6393 params_ffi["policyParams"] = {}; 6394 params_ffi["policyParams"]["type"] = A.load.Enum(params + 8 + 0, [ 6395 "dlp", 6396 "enterprise_connectors", 6397 "dlp_warning_timeout", 6398 ]); 6399 } 6400 6401 const _ret = WEBEXT.fileManagerPrivate.resumeIOTask(taskId, params_ffi); 6402 }, 6403 "try_ResumeIOTask": (retPtr: Pointer, errPtr: Pointer, taskId: number, params: Pointer): heap.Ref<boolean> => { 6404 try { 6405 const params_ffi = {}; 6406 6407 if (A.load.Bool(params + 0 + 6)) { 6408 params_ffi["conflictParams"] = {}; 6409 params_ffi["conflictParams"]["conflictResolve"] = A.load.Ref(params + 0 + 0, undefined); 6410 if (A.load.Bool(params + 0 + 5)) { 6411 params_ffi["conflictParams"]["conflictApplyToAll"] = A.load.Bool(params + 0 + 4); 6412 } 6413 } 6414 if (A.load.Bool(params + 8 + 4)) { 6415 params_ffi["policyParams"] = {}; 6416 params_ffi["policyParams"]["type"] = A.load.Enum(params + 8 + 0, [ 6417 "dlp", 6418 "enterprise_connectors", 6419 "dlp_warning_timeout", 6420 ]); 6421 } 6422 6423 const _ret = WEBEXT.fileManagerPrivate.resumeIOTask(taskId, params_ffi); 6424 return A.H.TRUE; 6425 } catch (err: any) { 6426 A.store.Ref(errPtr, err); 6427 return A.H.FALSE; 6428 } 6429 }, 6430 "has_SearchDrive": (): heap.Ref<boolean> => { 6431 if (WEBEXT?.fileManagerPrivate && "searchDrive" in WEBEXT?.fileManagerPrivate) { 6432 return A.H.TRUE; 6433 } 6434 return A.H.FALSE; 6435 }, 6436 "func_SearchDrive": (fn: Pointer): void => { 6437 A.store.Ref(fn, WEBEXT.fileManagerPrivate.searchDrive); 6438 }, 6439 "call_SearchDrive": (retPtr: Pointer, searchParams: Pointer, callback: heap.Ref<object>): void => { 6440 const searchParams_ffi = {}; 6441 6442 searchParams_ffi["query"] = A.load.Ref(searchParams + 0, undefined); 6443 searchParams_ffi["category"] = A.load.Enum(searchParams + 4, ["all", "audio", "image", "video", "document"]); 6444 if (A.load.Bool(searchParams + 20)) { 6445 searchParams_ffi["modifiedTimestamp"] = A.load.Float64(searchParams + 8); 6446 } 6447 searchParams_ffi["nextFeed"] = A.load.Ref(searchParams + 16, undefined); 6448 6449 const _ret = WEBEXT.fileManagerPrivate.searchDrive(searchParams_ffi, A.H.get<object>(callback)); 6450 }, 6451 "try_SearchDrive": ( 6452 retPtr: Pointer, 6453 errPtr: Pointer, 6454 searchParams: Pointer, 6455 callback: heap.Ref<object> 6456 ): heap.Ref<boolean> => { 6457 try { 6458 const searchParams_ffi = {}; 6459 6460 searchParams_ffi["query"] = A.load.Ref(searchParams + 0, undefined); 6461 searchParams_ffi["category"] = A.load.Enum(searchParams + 4, ["all", "audio", "image", "video", "document"]); 6462 if (A.load.Bool(searchParams + 20)) { 6463 searchParams_ffi["modifiedTimestamp"] = A.load.Float64(searchParams + 8); 6464 } 6465 searchParams_ffi["nextFeed"] = A.load.Ref(searchParams + 16, undefined); 6466 6467 const _ret = WEBEXT.fileManagerPrivate.searchDrive(searchParams_ffi, A.H.get<object>(callback)); 6468 return A.H.TRUE; 6469 } catch (err: any) { 6470 A.store.Ref(errPtr, err); 6471 return A.H.FALSE; 6472 } 6473 }, 6474 "has_SearchDriveMetadata": (): heap.Ref<boolean> => { 6475 if (WEBEXT?.fileManagerPrivate && "searchDriveMetadata" in WEBEXT?.fileManagerPrivate) { 6476 return A.H.TRUE; 6477 } 6478 return A.H.FALSE; 6479 }, 6480 "func_SearchDriveMetadata": (fn: Pointer): void => { 6481 A.store.Ref(fn, WEBEXT.fileManagerPrivate.searchDriveMetadata); 6482 }, 6483 "call_SearchDriveMetadata": (retPtr: Pointer, searchParams: Pointer): void => { 6484 const searchParams_ffi = {}; 6485 6486 searchParams_ffi["rootDir"] = A.load.Ref(searchParams + 0, undefined); 6487 searchParams_ffi["query"] = A.load.Ref(searchParams + 4, undefined); 6488 searchParams_ffi["types"] = A.load.Enum(searchParams + 8, [ 6489 "EXCLUDE_DIRECTORIES", 6490 "SHARED_WITH_ME", 6491 "OFFLINE", 6492 "ALL", 6493 ]); 6494 if (A.load.Bool(searchParams + 28)) { 6495 searchParams_ffi["maxResults"] = A.load.Int32(searchParams + 12); 6496 } 6497 if (A.load.Bool(searchParams + 29)) { 6498 searchParams_ffi["modifiedTimestamp"] = A.load.Float64(searchParams + 16); 6499 } 6500 searchParams_ffi["category"] = A.load.Enum(searchParams + 24, ["all", "audio", "image", "video", "document"]); 6501 6502 const _ret = WEBEXT.fileManagerPrivate.searchDriveMetadata(searchParams_ffi); 6503 A.store.Ref(retPtr, _ret); 6504 }, 6505 "try_SearchDriveMetadata": (retPtr: Pointer, errPtr: Pointer, searchParams: Pointer): heap.Ref<boolean> => { 6506 try { 6507 const searchParams_ffi = {}; 6508 6509 searchParams_ffi["rootDir"] = A.load.Ref(searchParams + 0, undefined); 6510 searchParams_ffi["query"] = A.load.Ref(searchParams + 4, undefined); 6511 searchParams_ffi["types"] = A.load.Enum(searchParams + 8, [ 6512 "EXCLUDE_DIRECTORIES", 6513 "SHARED_WITH_ME", 6514 "OFFLINE", 6515 "ALL", 6516 ]); 6517 if (A.load.Bool(searchParams + 28)) { 6518 searchParams_ffi["maxResults"] = A.load.Int32(searchParams + 12); 6519 } 6520 if (A.load.Bool(searchParams + 29)) { 6521 searchParams_ffi["modifiedTimestamp"] = A.load.Float64(searchParams + 16); 6522 } 6523 searchParams_ffi["category"] = A.load.Enum(searchParams + 24, ["all", "audio", "image", "video", "document"]); 6524 6525 const _ret = WEBEXT.fileManagerPrivate.searchDriveMetadata(searchParams_ffi); 6526 A.store.Ref(retPtr, _ret); 6527 return A.H.TRUE; 6528 } catch (err: any) { 6529 A.store.Ref(errPtr, err); 6530 return A.H.FALSE; 6531 } 6532 }, 6533 "has_SearchFiles": (): heap.Ref<boolean> => { 6534 if (WEBEXT?.fileManagerPrivate && "searchFiles" in WEBEXT?.fileManagerPrivate) { 6535 return A.H.TRUE; 6536 } 6537 return A.H.FALSE; 6538 }, 6539 "func_SearchFiles": (fn: Pointer): void => { 6540 A.store.Ref(fn, WEBEXT.fileManagerPrivate.searchFiles); 6541 }, 6542 "call_SearchFiles": (retPtr: Pointer, searchParams: Pointer): void => { 6543 const searchParams_ffi = {}; 6544 6545 searchParams_ffi["rootDir"] = A.load.Ref(searchParams + 0, undefined); 6546 searchParams_ffi["query"] = A.load.Ref(searchParams + 4, undefined); 6547 searchParams_ffi["types"] = A.load.Enum(searchParams + 8, [ 6548 "EXCLUDE_DIRECTORIES", 6549 "SHARED_WITH_ME", 6550 "OFFLINE", 6551 "ALL", 6552 ]); 6553 if (A.load.Bool(searchParams + 28)) { 6554 searchParams_ffi["maxResults"] = A.load.Int32(searchParams + 12); 6555 } 6556 if (A.load.Bool(searchParams + 29)) { 6557 searchParams_ffi["modifiedTimestamp"] = A.load.Float64(searchParams + 16); 6558 } 6559 searchParams_ffi["category"] = A.load.Enum(searchParams + 24, ["all", "audio", "image", "video", "document"]); 6560 6561 const _ret = WEBEXT.fileManagerPrivate.searchFiles(searchParams_ffi); 6562 A.store.Ref(retPtr, _ret); 6563 }, 6564 "try_SearchFiles": (retPtr: Pointer, errPtr: Pointer, searchParams: Pointer): heap.Ref<boolean> => { 6565 try { 6566 const searchParams_ffi = {}; 6567 6568 searchParams_ffi["rootDir"] = A.load.Ref(searchParams + 0, undefined); 6569 searchParams_ffi["query"] = A.load.Ref(searchParams + 4, undefined); 6570 searchParams_ffi["types"] = A.load.Enum(searchParams + 8, [ 6571 "EXCLUDE_DIRECTORIES", 6572 "SHARED_WITH_ME", 6573 "OFFLINE", 6574 "ALL", 6575 ]); 6576 if (A.load.Bool(searchParams + 28)) { 6577 searchParams_ffi["maxResults"] = A.load.Int32(searchParams + 12); 6578 } 6579 if (A.load.Bool(searchParams + 29)) { 6580 searchParams_ffi["modifiedTimestamp"] = A.load.Float64(searchParams + 16); 6581 } 6582 searchParams_ffi["category"] = A.load.Enum(searchParams + 24, ["all", "audio", "image", "video", "document"]); 6583 6584 const _ret = WEBEXT.fileManagerPrivate.searchFiles(searchParams_ffi); 6585 A.store.Ref(retPtr, _ret); 6586 return A.H.TRUE; 6587 } catch (err: any) { 6588 A.store.Ref(errPtr, err); 6589 return A.H.FALSE; 6590 } 6591 }, 6592 "has_SearchFilesByHashes": (): heap.Ref<boolean> => { 6593 if (WEBEXT?.fileManagerPrivate && "searchFilesByHashes" in WEBEXT?.fileManagerPrivate) { 6594 return A.H.TRUE; 6595 } 6596 return A.H.FALSE; 6597 }, 6598 "func_SearchFilesByHashes": (fn: Pointer): void => { 6599 A.store.Ref(fn, WEBEXT.fileManagerPrivate.searchFilesByHashes); 6600 }, 6601 "call_SearchFilesByHashes": (retPtr: Pointer, volumeId: heap.Ref<object>, hashList: heap.Ref<object>): void => { 6602 const _ret = WEBEXT.fileManagerPrivate.searchFilesByHashes(A.H.get<object>(volumeId), A.H.get<object>(hashList)); 6603 A.store.Ref(retPtr, _ret); 6604 }, 6605 "try_SearchFilesByHashes": ( 6606 retPtr: Pointer, 6607 errPtr: Pointer, 6608 volumeId: heap.Ref<object>, 6609 hashList: heap.Ref<object> 6610 ): heap.Ref<boolean> => { 6611 try { 6612 const _ret = WEBEXT.fileManagerPrivate.searchFilesByHashes( 6613 A.H.get<object>(volumeId), 6614 A.H.get<object>(hashList) 6615 ); 6616 A.store.Ref(retPtr, _ret); 6617 return A.H.TRUE; 6618 } catch (err: any) { 6619 A.store.Ref(errPtr, err); 6620 return A.H.FALSE; 6621 } 6622 }, 6623 "has_SelectAndroidPickerApp": (): heap.Ref<boolean> => { 6624 if (WEBEXT?.fileManagerPrivate && "selectAndroidPickerApp" in WEBEXT?.fileManagerPrivate) { 6625 return A.H.TRUE; 6626 } 6627 return A.H.FALSE; 6628 }, 6629 "func_SelectAndroidPickerApp": (fn: Pointer): void => { 6630 A.store.Ref(fn, WEBEXT.fileManagerPrivate.selectAndroidPickerApp); 6631 }, 6632 "call_SelectAndroidPickerApp": (retPtr: Pointer, androidApp: Pointer): void => { 6633 const androidApp_ffi = {}; 6634 6635 androidApp_ffi["name"] = A.load.Ref(androidApp + 0, undefined); 6636 androidApp_ffi["packageName"] = A.load.Ref(androidApp + 4, undefined); 6637 androidApp_ffi["activityName"] = A.load.Ref(androidApp + 8, undefined); 6638 if (A.load.Bool(androidApp + 12 + 8)) { 6639 androidApp_ffi["iconSet"] = {}; 6640 androidApp_ffi["iconSet"]["icon16x16Url"] = A.load.Ref(androidApp + 12 + 0, undefined); 6641 androidApp_ffi["iconSet"]["icon32x32Url"] = A.load.Ref(androidApp + 12 + 4, undefined); 6642 } 6643 6644 const _ret = WEBEXT.fileManagerPrivate.selectAndroidPickerApp(androidApp_ffi); 6645 A.store.Ref(retPtr, _ret); 6646 }, 6647 "try_SelectAndroidPickerApp": (retPtr: Pointer, errPtr: Pointer, androidApp: Pointer): heap.Ref<boolean> => { 6648 try { 6649 const androidApp_ffi = {}; 6650 6651 androidApp_ffi["name"] = A.load.Ref(androidApp + 0, undefined); 6652 androidApp_ffi["packageName"] = A.load.Ref(androidApp + 4, undefined); 6653 androidApp_ffi["activityName"] = A.load.Ref(androidApp + 8, undefined); 6654 if (A.load.Bool(androidApp + 12 + 8)) { 6655 androidApp_ffi["iconSet"] = {}; 6656 androidApp_ffi["iconSet"]["icon16x16Url"] = A.load.Ref(androidApp + 12 + 0, undefined); 6657 androidApp_ffi["iconSet"]["icon32x32Url"] = A.load.Ref(androidApp + 12 + 4, undefined); 6658 } 6659 6660 const _ret = WEBEXT.fileManagerPrivate.selectAndroidPickerApp(androidApp_ffi); 6661 A.store.Ref(retPtr, _ret); 6662 return A.H.TRUE; 6663 } catch (err: any) { 6664 A.store.Ref(errPtr, err); 6665 return A.H.FALSE; 6666 } 6667 }, 6668 "has_SelectFile": (): heap.Ref<boolean> => { 6669 if (WEBEXT?.fileManagerPrivate && "selectFile" in WEBEXT?.fileManagerPrivate) { 6670 return A.H.TRUE; 6671 } 6672 return A.H.FALSE; 6673 }, 6674 "func_SelectFile": (fn: Pointer): void => { 6675 A.store.Ref(fn, WEBEXT.fileManagerPrivate.selectFile); 6676 }, 6677 "call_SelectFile": ( 6678 retPtr: Pointer, 6679 selectedPath: heap.Ref<object>, 6680 index: number, 6681 forOpening: heap.Ref<boolean>, 6682 shouldReturnLocalPath: heap.Ref<boolean> 6683 ): void => { 6684 const _ret = WEBEXT.fileManagerPrivate.selectFile( 6685 A.H.get<object>(selectedPath), 6686 index, 6687 forOpening === A.H.TRUE, 6688 shouldReturnLocalPath === A.H.TRUE 6689 ); 6690 A.store.Ref(retPtr, _ret); 6691 }, 6692 "try_SelectFile": ( 6693 retPtr: Pointer, 6694 errPtr: Pointer, 6695 selectedPath: heap.Ref<object>, 6696 index: number, 6697 forOpening: heap.Ref<boolean>, 6698 shouldReturnLocalPath: heap.Ref<boolean> 6699 ): heap.Ref<boolean> => { 6700 try { 6701 const _ret = WEBEXT.fileManagerPrivate.selectFile( 6702 A.H.get<object>(selectedPath), 6703 index, 6704 forOpening === A.H.TRUE, 6705 shouldReturnLocalPath === A.H.TRUE 6706 ); 6707 A.store.Ref(retPtr, _ret); 6708 return A.H.TRUE; 6709 } catch (err: any) { 6710 A.store.Ref(errPtr, err); 6711 return A.H.FALSE; 6712 } 6713 }, 6714 "has_SelectFiles": (): heap.Ref<boolean> => { 6715 if (WEBEXT?.fileManagerPrivate && "selectFiles" in WEBEXT?.fileManagerPrivate) { 6716 return A.H.TRUE; 6717 } 6718 return A.H.FALSE; 6719 }, 6720 "func_SelectFiles": (fn: Pointer): void => { 6721 A.store.Ref(fn, WEBEXT.fileManagerPrivate.selectFiles); 6722 }, 6723 "call_SelectFiles": ( 6724 retPtr: Pointer, 6725 selectedPaths: heap.Ref<object>, 6726 shouldReturnLocalPath: heap.Ref<boolean> 6727 ): void => { 6728 const _ret = WEBEXT.fileManagerPrivate.selectFiles( 6729 A.H.get<object>(selectedPaths), 6730 shouldReturnLocalPath === A.H.TRUE 6731 ); 6732 A.store.Ref(retPtr, _ret); 6733 }, 6734 "try_SelectFiles": ( 6735 retPtr: Pointer, 6736 errPtr: Pointer, 6737 selectedPaths: heap.Ref<object>, 6738 shouldReturnLocalPath: heap.Ref<boolean> 6739 ): heap.Ref<boolean> => { 6740 try { 6741 const _ret = WEBEXT.fileManagerPrivate.selectFiles( 6742 A.H.get<object>(selectedPaths), 6743 shouldReturnLocalPath === A.H.TRUE 6744 ); 6745 A.store.Ref(retPtr, _ret); 6746 return A.H.TRUE; 6747 } catch (err: any) { 6748 A.store.Ref(errPtr, err); 6749 return A.H.FALSE; 6750 } 6751 }, 6752 "has_SendFeedback": (): heap.Ref<boolean> => { 6753 if (WEBEXT?.fileManagerPrivate && "sendFeedback" in WEBEXT?.fileManagerPrivate) { 6754 return A.H.TRUE; 6755 } 6756 return A.H.FALSE; 6757 }, 6758 "func_SendFeedback": (fn: Pointer): void => { 6759 A.store.Ref(fn, WEBEXT.fileManagerPrivate.sendFeedback); 6760 }, 6761 "call_SendFeedback": (retPtr: Pointer): void => { 6762 const _ret = WEBEXT.fileManagerPrivate.sendFeedback(); 6763 }, 6764 "try_SendFeedback": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 6765 try { 6766 const _ret = WEBEXT.fileManagerPrivate.sendFeedback(); 6767 return A.H.TRUE; 6768 } catch (err: any) { 6769 A.store.Ref(errPtr, err); 6770 return A.H.FALSE; 6771 } 6772 }, 6773 "has_SetDefaultTask": (): heap.Ref<boolean> => { 6774 if (WEBEXT?.fileManagerPrivate && "setDefaultTask" in WEBEXT?.fileManagerPrivate) { 6775 return A.H.TRUE; 6776 } 6777 return A.H.FALSE; 6778 }, 6779 "func_SetDefaultTask": (fn: Pointer): void => { 6780 A.store.Ref(fn, WEBEXT.fileManagerPrivate.setDefaultTask); 6781 }, 6782 "call_SetDefaultTask": ( 6783 retPtr: Pointer, 6784 descriptor: Pointer, 6785 entries: heap.Ref<object>, 6786 mimeTypes: heap.Ref<object> 6787 ): void => { 6788 const descriptor_ffi = {}; 6789 6790 descriptor_ffi["appId"] = A.load.Ref(descriptor + 0, undefined); 6791 descriptor_ffi["taskType"] = A.load.Ref(descriptor + 4, undefined); 6792 descriptor_ffi["actionId"] = A.load.Ref(descriptor + 8, undefined); 6793 6794 const _ret = WEBEXT.fileManagerPrivate.setDefaultTask( 6795 descriptor_ffi, 6796 A.H.get<object>(entries), 6797 A.H.get<object>(mimeTypes) 6798 ); 6799 A.store.Ref(retPtr, _ret); 6800 }, 6801 "try_SetDefaultTask": ( 6802 retPtr: Pointer, 6803 errPtr: Pointer, 6804 descriptor: Pointer, 6805 entries: heap.Ref<object>, 6806 mimeTypes: heap.Ref<object> 6807 ): heap.Ref<boolean> => { 6808 try { 6809 const descriptor_ffi = {}; 6810 6811 descriptor_ffi["appId"] = A.load.Ref(descriptor + 0, undefined); 6812 descriptor_ffi["taskType"] = A.load.Ref(descriptor + 4, undefined); 6813 descriptor_ffi["actionId"] = A.load.Ref(descriptor + 8, undefined); 6814 6815 const _ret = WEBEXT.fileManagerPrivate.setDefaultTask( 6816 descriptor_ffi, 6817 A.H.get<object>(entries), 6818 A.H.get<object>(mimeTypes) 6819 ); 6820 A.store.Ref(retPtr, _ret); 6821 return A.H.TRUE; 6822 } catch (err: any) { 6823 A.store.Ref(errPtr, err); 6824 return A.H.FALSE; 6825 } 6826 }, 6827 "has_SetPreferences": (): heap.Ref<boolean> => { 6828 if (WEBEXT?.fileManagerPrivate && "setPreferences" in WEBEXT?.fileManagerPrivate) { 6829 return A.H.TRUE; 6830 } 6831 return A.H.FALSE; 6832 }, 6833 "func_SetPreferences": (fn: Pointer): void => { 6834 A.store.Ref(fn, WEBEXT.fileManagerPrivate.setPreferences); 6835 }, 6836 "call_SetPreferences": (retPtr: Pointer, changeInfo: Pointer): void => { 6837 const changeInfo_ffi = {}; 6838 6839 if (A.load.Bool(changeInfo + 9)) { 6840 changeInfo_ffi["driveSyncEnabledOnMeteredNetwork"] = A.load.Bool(changeInfo + 0); 6841 } 6842 if (A.load.Bool(changeInfo + 10)) { 6843 changeInfo_ffi["arcEnabled"] = A.load.Bool(changeInfo + 1); 6844 } 6845 if (A.load.Bool(changeInfo + 11)) { 6846 changeInfo_ffi["arcRemovableMediaAccessEnabled"] = A.load.Bool(changeInfo + 2); 6847 } 6848 changeInfo_ffi["folderShortcuts"] = A.load.Ref(changeInfo + 4, undefined); 6849 if (A.load.Bool(changeInfo + 12)) { 6850 changeInfo_ffi["driveFsBulkPinningEnabled"] = A.load.Bool(changeInfo + 8); 6851 } 6852 6853 const _ret = WEBEXT.fileManagerPrivate.setPreferences(changeInfo_ffi); 6854 }, 6855 "try_SetPreferences": (retPtr: Pointer, errPtr: Pointer, changeInfo: Pointer): heap.Ref<boolean> => { 6856 try { 6857 const changeInfo_ffi = {}; 6858 6859 if (A.load.Bool(changeInfo + 9)) { 6860 changeInfo_ffi["driveSyncEnabledOnMeteredNetwork"] = A.load.Bool(changeInfo + 0); 6861 } 6862 if (A.load.Bool(changeInfo + 10)) { 6863 changeInfo_ffi["arcEnabled"] = A.load.Bool(changeInfo + 1); 6864 } 6865 if (A.load.Bool(changeInfo + 11)) { 6866 changeInfo_ffi["arcRemovableMediaAccessEnabled"] = A.load.Bool(changeInfo + 2); 6867 } 6868 changeInfo_ffi["folderShortcuts"] = A.load.Ref(changeInfo + 4, undefined); 6869 if (A.load.Bool(changeInfo + 12)) { 6870 changeInfo_ffi["driveFsBulkPinningEnabled"] = A.load.Bool(changeInfo + 8); 6871 } 6872 6873 const _ret = WEBEXT.fileManagerPrivate.setPreferences(changeInfo_ffi); 6874 return A.H.TRUE; 6875 } catch (err: any) { 6876 A.store.Ref(errPtr, err); 6877 return A.H.FALSE; 6878 } 6879 }, 6880 "has_SharePathsWithCrostini": (): heap.Ref<boolean> => { 6881 if (WEBEXT?.fileManagerPrivate && "sharePathsWithCrostini" in WEBEXT?.fileManagerPrivate) { 6882 return A.H.TRUE; 6883 } 6884 return A.H.FALSE; 6885 }, 6886 "func_SharePathsWithCrostini": (fn: Pointer): void => { 6887 A.store.Ref(fn, WEBEXT.fileManagerPrivate.sharePathsWithCrostini); 6888 }, 6889 "call_SharePathsWithCrostini": ( 6890 retPtr: Pointer, 6891 vmName: heap.Ref<object>, 6892 entries: heap.Ref<object>, 6893 persist: heap.Ref<boolean> 6894 ): void => { 6895 const _ret = WEBEXT.fileManagerPrivate.sharePathsWithCrostini( 6896 A.H.get<object>(vmName), 6897 A.H.get<object>(entries), 6898 persist === A.H.TRUE 6899 ); 6900 A.store.Ref(retPtr, _ret); 6901 }, 6902 "try_SharePathsWithCrostini": ( 6903 retPtr: Pointer, 6904 errPtr: Pointer, 6905 vmName: heap.Ref<object>, 6906 entries: heap.Ref<object>, 6907 persist: heap.Ref<boolean> 6908 ): heap.Ref<boolean> => { 6909 try { 6910 const _ret = WEBEXT.fileManagerPrivate.sharePathsWithCrostini( 6911 A.H.get<object>(vmName), 6912 A.H.get<object>(entries), 6913 persist === A.H.TRUE 6914 ); 6915 A.store.Ref(retPtr, _ret); 6916 return A.H.TRUE; 6917 } catch (err: any) { 6918 A.store.Ref(errPtr, err); 6919 return A.H.FALSE; 6920 } 6921 }, 6922 "has_SharesheetHasTargets": (): heap.Ref<boolean> => { 6923 if (WEBEXT?.fileManagerPrivate && "sharesheetHasTargets" in WEBEXT?.fileManagerPrivate) { 6924 return A.H.TRUE; 6925 } 6926 return A.H.FALSE; 6927 }, 6928 "func_SharesheetHasTargets": (fn: Pointer): void => { 6929 A.store.Ref(fn, WEBEXT.fileManagerPrivate.sharesheetHasTargets); 6930 }, 6931 "call_SharesheetHasTargets": (retPtr: Pointer, entries: heap.Ref<object>): void => { 6932 const _ret = WEBEXT.fileManagerPrivate.sharesheetHasTargets(A.H.get<object>(entries)); 6933 A.store.Ref(retPtr, _ret); 6934 }, 6935 "try_SharesheetHasTargets": (retPtr: Pointer, errPtr: Pointer, entries: heap.Ref<object>): heap.Ref<boolean> => { 6936 try { 6937 const _ret = WEBEXT.fileManagerPrivate.sharesheetHasTargets(A.H.get<object>(entries)); 6938 A.store.Ref(retPtr, _ret); 6939 return A.H.TRUE; 6940 } catch (err: any) { 6941 A.store.Ref(errPtr, err); 6942 return A.H.FALSE; 6943 } 6944 }, 6945 "has_ShowPolicyDialog": (): heap.Ref<boolean> => { 6946 if (WEBEXT?.fileManagerPrivate && "showPolicyDialog" in WEBEXT?.fileManagerPrivate) { 6947 return A.H.TRUE; 6948 } 6949 return A.H.FALSE; 6950 }, 6951 "func_ShowPolicyDialog": (fn: Pointer): void => { 6952 A.store.Ref(fn, WEBEXT.fileManagerPrivate.showPolicyDialog); 6953 }, 6954 "call_ShowPolicyDialog": (retPtr: Pointer, taskId: number, type: number): void => { 6955 const _ret = WEBEXT.fileManagerPrivate.showPolicyDialog( 6956 taskId, 6957 type > 0 && type <= 2 ? ["warning", "error"][type - 1] : undefined 6958 ); 6959 }, 6960 "try_ShowPolicyDialog": (retPtr: Pointer, errPtr: Pointer, taskId: number, type: number): heap.Ref<boolean> => { 6961 try { 6962 const _ret = WEBEXT.fileManagerPrivate.showPolicyDialog( 6963 taskId, 6964 type > 0 && type <= 2 ? ["warning", "error"][type - 1] : undefined 6965 ); 6966 return A.H.TRUE; 6967 } catch (err: any) { 6968 A.store.Ref(errPtr, err); 6969 return A.H.FALSE; 6970 } 6971 }, 6972 "has_SinglePartitionFormat": (): heap.Ref<boolean> => { 6973 if (WEBEXT?.fileManagerPrivate && "singlePartitionFormat" in WEBEXT?.fileManagerPrivate) { 6974 return A.H.TRUE; 6975 } 6976 return A.H.FALSE; 6977 }, 6978 "func_SinglePartitionFormat": (fn: Pointer): void => { 6979 A.store.Ref(fn, WEBEXT.fileManagerPrivate.singlePartitionFormat); 6980 }, 6981 "call_SinglePartitionFormat": ( 6982 retPtr: Pointer, 6983 deviceStoragePath: heap.Ref<object>, 6984 filesystem: number, 6985 volumeLabel: heap.Ref<object> 6986 ): void => { 6987 const _ret = WEBEXT.fileManagerPrivate.singlePartitionFormat( 6988 A.H.get<object>(deviceStoragePath), 6989 filesystem > 0 && filesystem <= 3 ? ["vfat", "exfat", "ntfs"][filesystem - 1] : undefined, 6990 A.H.get<object>(volumeLabel) 6991 ); 6992 }, 6993 "try_SinglePartitionFormat": ( 6994 retPtr: Pointer, 6995 errPtr: Pointer, 6996 deviceStoragePath: heap.Ref<object>, 6997 filesystem: number, 6998 volumeLabel: heap.Ref<object> 6999 ): heap.Ref<boolean> => { 7000 try { 7001 const _ret = WEBEXT.fileManagerPrivate.singlePartitionFormat( 7002 A.H.get<object>(deviceStoragePath), 7003 filesystem > 0 && filesystem <= 3 ? ["vfat", "exfat", "ntfs"][filesystem - 1] : undefined, 7004 A.H.get<object>(volumeLabel) 7005 ); 7006 return A.H.TRUE; 7007 } catch (err: any) { 7008 A.store.Ref(errPtr, err); 7009 return A.H.FALSE; 7010 } 7011 }, 7012 "has_StartIOTask": (): heap.Ref<boolean> => { 7013 if (WEBEXT?.fileManagerPrivate && "startIOTask" in WEBEXT?.fileManagerPrivate) { 7014 return A.H.TRUE; 7015 } 7016 return A.H.FALSE; 7017 }, 7018 "func_StartIOTask": (fn: Pointer): void => { 7019 A.store.Ref(fn, WEBEXT.fileManagerPrivate.startIOTask); 7020 }, 7021 "call_StartIOTask": (retPtr: Pointer, type: number, entries: heap.Ref<object>, params: Pointer): void => { 7022 const params_ffi = {}; 7023 7024 params_ffi["destinationFolder"] = A.load.Ref(params + 0, undefined); 7025 params_ffi["password"] = A.load.Ref(params + 4, undefined); 7026 if (A.load.Bool(params + 9)) { 7027 params_ffi["showNotification"] = A.load.Bool(params + 8); 7028 } 7029 7030 const _ret = WEBEXT.fileManagerPrivate.startIOTask( 7031 type > 0 && type <= 9 7032 ? ["copy", "delete", "empty_trash", "extract", "move", "restore", "restore_to_destination", "trash", "zip"][ 7033 type - 1 7034 ] 7035 : undefined, 7036 A.H.get<object>(entries), 7037 params_ffi 7038 ); 7039 A.store.Ref(retPtr, _ret); 7040 }, 7041 "try_StartIOTask": ( 7042 retPtr: Pointer, 7043 errPtr: Pointer, 7044 type: number, 7045 entries: heap.Ref<object>, 7046 params: Pointer 7047 ): heap.Ref<boolean> => { 7048 try { 7049 const params_ffi = {}; 7050 7051 params_ffi["destinationFolder"] = A.load.Ref(params + 0, undefined); 7052 params_ffi["password"] = A.load.Ref(params + 4, undefined); 7053 if (A.load.Bool(params + 9)) { 7054 params_ffi["showNotification"] = A.load.Bool(params + 8); 7055 } 7056 7057 const _ret = WEBEXT.fileManagerPrivate.startIOTask( 7058 type > 0 && type <= 9 7059 ? ["copy", "delete", "empty_trash", "extract", "move", "restore", "restore_to_destination", "trash", "zip"][ 7060 type - 1 7061 ] 7062 : undefined, 7063 A.H.get<object>(entries), 7064 params_ffi 7065 ); 7066 A.store.Ref(retPtr, _ret); 7067 return A.H.TRUE; 7068 } catch (err: any) { 7069 A.store.Ref(errPtr, err); 7070 return A.H.FALSE; 7071 } 7072 }, 7073 "has_ToggleAddedToHoldingSpace": (): heap.Ref<boolean> => { 7074 if (WEBEXT?.fileManagerPrivate && "toggleAddedToHoldingSpace" in WEBEXT?.fileManagerPrivate) { 7075 return A.H.TRUE; 7076 } 7077 return A.H.FALSE; 7078 }, 7079 "func_ToggleAddedToHoldingSpace": (fn: Pointer): void => { 7080 A.store.Ref(fn, WEBEXT.fileManagerPrivate.toggleAddedToHoldingSpace); 7081 }, 7082 "call_ToggleAddedToHoldingSpace": (retPtr: Pointer, entries: heap.Ref<object>, added: heap.Ref<boolean>): void => { 7083 const _ret = WEBEXT.fileManagerPrivate.toggleAddedToHoldingSpace(A.H.get<object>(entries), added === A.H.TRUE); 7084 A.store.Ref(retPtr, _ret); 7085 }, 7086 "try_ToggleAddedToHoldingSpace": ( 7087 retPtr: Pointer, 7088 errPtr: Pointer, 7089 entries: heap.Ref<object>, 7090 added: heap.Ref<boolean> 7091 ): heap.Ref<boolean> => { 7092 try { 7093 const _ret = WEBEXT.fileManagerPrivate.toggleAddedToHoldingSpace(A.H.get<object>(entries), added === A.H.TRUE); 7094 A.store.Ref(retPtr, _ret); 7095 return A.H.TRUE; 7096 } catch (err: any) { 7097 A.store.Ref(errPtr, err); 7098 return A.H.FALSE; 7099 } 7100 }, 7101 "has_UnsharePathWithCrostini": (): heap.Ref<boolean> => { 7102 if (WEBEXT?.fileManagerPrivate && "unsharePathWithCrostini" in WEBEXT?.fileManagerPrivate) { 7103 return A.H.TRUE; 7104 } 7105 return A.H.FALSE; 7106 }, 7107 "func_UnsharePathWithCrostini": (fn: Pointer): void => { 7108 A.store.Ref(fn, WEBEXT.fileManagerPrivate.unsharePathWithCrostini); 7109 }, 7110 "call_UnsharePathWithCrostini": (retPtr: Pointer, vmName: heap.Ref<object>, entry: heap.Ref<object>): void => { 7111 const _ret = WEBEXT.fileManagerPrivate.unsharePathWithCrostini(A.H.get<object>(vmName), A.H.get<object>(entry)); 7112 A.store.Ref(retPtr, _ret); 7113 }, 7114 "try_UnsharePathWithCrostini": ( 7115 retPtr: Pointer, 7116 errPtr: Pointer, 7117 vmName: heap.Ref<object>, 7118 entry: heap.Ref<object> 7119 ): heap.Ref<boolean> => { 7120 try { 7121 const _ret = WEBEXT.fileManagerPrivate.unsharePathWithCrostini(A.H.get<object>(vmName), A.H.get<object>(entry)); 7122 A.store.Ref(retPtr, _ret); 7123 return A.H.TRUE; 7124 } catch (err: any) { 7125 A.store.Ref(errPtr, err); 7126 return A.H.FALSE; 7127 } 7128 }, 7129 "has_ValidatePathNameLength": (): heap.Ref<boolean> => { 7130 if (WEBEXT?.fileManagerPrivate && "validatePathNameLength" in WEBEXT?.fileManagerPrivate) { 7131 return A.H.TRUE; 7132 } 7133 return A.H.FALSE; 7134 }, 7135 "func_ValidatePathNameLength": (fn: Pointer): void => { 7136 A.store.Ref(fn, WEBEXT.fileManagerPrivate.validatePathNameLength); 7137 }, 7138 "call_ValidatePathNameLength": (retPtr: Pointer, parentEntry: heap.Ref<object>, name: heap.Ref<object>): void => { 7139 const _ret = WEBEXT.fileManagerPrivate.validatePathNameLength( 7140 A.H.get<object>(parentEntry), 7141 A.H.get<object>(name) 7142 ); 7143 A.store.Ref(retPtr, _ret); 7144 }, 7145 "try_ValidatePathNameLength": ( 7146 retPtr: Pointer, 7147 errPtr: Pointer, 7148 parentEntry: heap.Ref<object>, 7149 name: heap.Ref<object> 7150 ): heap.Ref<boolean> => { 7151 try { 7152 const _ret = WEBEXT.fileManagerPrivate.validatePathNameLength( 7153 A.H.get<object>(parentEntry), 7154 A.H.get<object>(name) 7155 ); 7156 A.store.Ref(retPtr, _ret); 7157 return A.H.TRUE; 7158 } catch (err: any) { 7159 A.store.Ref(errPtr, err); 7160 return A.H.FALSE; 7161 } 7162 }, 7163 "has_Zoom": (): heap.Ref<boolean> => { 7164 if (WEBEXT?.fileManagerPrivate && "zoom" in WEBEXT?.fileManagerPrivate) { 7165 return A.H.TRUE; 7166 } 7167 return A.H.FALSE; 7168 }, 7169 "func_Zoom": (fn: Pointer): void => { 7170 A.store.Ref(fn, WEBEXT.fileManagerPrivate.zoom); 7171 }, 7172 "call_Zoom": (retPtr: Pointer, operation: number): void => { 7173 const _ret = WEBEXT.fileManagerPrivate.zoom( 7174 operation > 0 && operation <= 3 ? ["in", "out", "reset"][operation - 1] : undefined 7175 ); 7176 }, 7177 "try_Zoom": (retPtr: Pointer, errPtr: Pointer, operation: number): heap.Ref<boolean> => { 7178 try { 7179 const _ret = WEBEXT.fileManagerPrivate.zoom( 7180 operation > 0 && operation <= 3 ? ["in", "out", "reset"][operation - 1] : undefined 7181 ); 7182 return A.H.TRUE; 7183 } catch (err: any) { 7184 A.store.Ref(errPtr, err); 7185 return A.H.FALSE; 7186 } 7187 }, 7188 }; 7189 });