github.com/primecitizens/pcz/std@v0.2.1/plat/js/webext/bookmarkmanagerprivate/bindings/ffi_bindings.ts (about) 1 import { importModule, Application, heap, Pointer } from "@ffi"; 2 3 importModule("plat/js/webext/bookmarkmanagerprivate", (A: Application) => { 4 const WEBEXT = typeof globalThis.browser === "undefined" ? globalThis.chrome : globalThis.browser; 5 6 return { 7 "store_BookmarkNodeDataElement": (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 + 20, false); 12 A.store.Ref(ptr + 0, undefined); 13 A.store.Ref(ptr + 4, undefined); 14 A.store.Ref(ptr + 8, undefined); 15 A.store.Ref(ptr + 12, undefined); 16 A.store.Ref(ptr + 16, undefined); 17 } else { 18 A.store.Bool(ptr + 20, true); 19 A.store.Ref(ptr + 0, x["children"]); 20 A.store.Ref(ptr + 4, x["id"]); 21 A.store.Ref(ptr + 8, x["parentId"]); 22 A.store.Ref(ptr + 12, x["title"]); 23 A.store.Ref(ptr + 16, x["url"]); 24 } 25 }, 26 "load_BookmarkNodeDataElement": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 27 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 28 29 x["children"] = A.load.Ref(ptr + 0, undefined); 30 x["id"] = A.load.Ref(ptr + 4, undefined); 31 x["parentId"] = A.load.Ref(ptr + 8, undefined); 32 x["title"] = A.load.Ref(ptr + 12, undefined); 33 x["url"] = A.load.Ref(ptr + 16, undefined); 34 return create === A.H.TRUE ? A.H.push(x) : ref; 35 }, 36 37 "store_BookmarkNodeData": (ptr: Pointer, ref: heap.Ref<any>) => { 38 const x = A.H.get<any>(ref); 39 40 if (typeof x === "undefined") { 41 A.store.Bool(ptr + 5, false); 42 A.store.Ref(ptr + 0, undefined); 43 A.store.Bool(ptr + 4, false); 44 } else { 45 A.store.Bool(ptr + 5, true); 46 A.store.Ref(ptr + 0, x["elements"]); 47 A.store.Bool(ptr + 4, x["sameProfile"] ? true : false); 48 } 49 }, 50 "load_BookmarkNodeData": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 51 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 52 53 x["elements"] = A.load.Ref(ptr + 0, undefined); 54 x["sameProfile"] = A.load.Bool(ptr + 4); 55 return create === A.H.TRUE ? A.H.push(x) : ref; 56 }, 57 "has_CanPaste": (): heap.Ref<boolean> => { 58 if (WEBEXT?.bookmarkManagerPrivate && "canPaste" in WEBEXT?.bookmarkManagerPrivate) { 59 return A.H.TRUE; 60 } 61 return A.H.FALSE; 62 }, 63 "func_CanPaste": (fn: Pointer): void => { 64 A.store.Ref(fn, WEBEXT.bookmarkManagerPrivate.canPaste); 65 }, 66 "call_CanPaste": (retPtr: Pointer, parentId: heap.Ref<object>): void => { 67 const _ret = WEBEXT.bookmarkManagerPrivate.canPaste(A.H.get<object>(parentId)); 68 A.store.Ref(retPtr, _ret); 69 }, 70 "try_CanPaste": (retPtr: Pointer, errPtr: Pointer, parentId: heap.Ref<object>): heap.Ref<boolean> => { 71 try { 72 const _ret = WEBEXT.bookmarkManagerPrivate.canPaste(A.H.get<object>(parentId)); 73 A.store.Ref(retPtr, _ret); 74 return A.H.TRUE; 75 } catch (err: any) { 76 A.store.Ref(errPtr, err); 77 return A.H.FALSE; 78 } 79 }, 80 "has_Copy": (): heap.Ref<boolean> => { 81 if (WEBEXT?.bookmarkManagerPrivate && "copy" in WEBEXT?.bookmarkManagerPrivate) { 82 return A.H.TRUE; 83 } 84 return A.H.FALSE; 85 }, 86 "func_Copy": (fn: Pointer): void => { 87 A.store.Ref(fn, WEBEXT.bookmarkManagerPrivate.copy); 88 }, 89 "call_Copy": (retPtr: Pointer, idList: heap.Ref<object>): void => { 90 const _ret = WEBEXT.bookmarkManagerPrivate.copy(A.H.get<object>(idList)); 91 A.store.Ref(retPtr, _ret); 92 }, 93 "try_Copy": (retPtr: Pointer, errPtr: Pointer, idList: heap.Ref<object>): heap.Ref<boolean> => { 94 try { 95 const _ret = WEBEXT.bookmarkManagerPrivate.copy(A.H.get<object>(idList)); 96 A.store.Ref(retPtr, _ret); 97 return A.H.TRUE; 98 } catch (err: any) { 99 A.store.Ref(errPtr, err); 100 return A.H.FALSE; 101 } 102 }, 103 "has_Cut": (): heap.Ref<boolean> => { 104 if (WEBEXT?.bookmarkManagerPrivate && "cut" in WEBEXT?.bookmarkManagerPrivate) { 105 return A.H.TRUE; 106 } 107 return A.H.FALSE; 108 }, 109 "func_Cut": (fn: Pointer): void => { 110 A.store.Ref(fn, WEBEXT.bookmarkManagerPrivate.cut); 111 }, 112 "call_Cut": (retPtr: Pointer, idList: heap.Ref<object>): void => { 113 const _ret = WEBEXT.bookmarkManagerPrivate.cut(A.H.get<object>(idList)); 114 A.store.Ref(retPtr, _ret); 115 }, 116 "try_Cut": (retPtr: Pointer, errPtr: Pointer, idList: heap.Ref<object>): heap.Ref<boolean> => { 117 try { 118 const _ret = WEBEXT.bookmarkManagerPrivate.cut(A.H.get<object>(idList)); 119 A.store.Ref(retPtr, _ret); 120 return A.H.TRUE; 121 } catch (err: any) { 122 A.store.Ref(errPtr, err); 123 return A.H.FALSE; 124 } 125 }, 126 "has_Drop": (): heap.Ref<boolean> => { 127 if (WEBEXT?.bookmarkManagerPrivate && "drop" in WEBEXT?.bookmarkManagerPrivate) { 128 return A.H.TRUE; 129 } 130 return A.H.FALSE; 131 }, 132 "func_Drop": (fn: Pointer): void => { 133 A.store.Ref(fn, WEBEXT.bookmarkManagerPrivate.drop); 134 }, 135 "call_Drop": (retPtr: Pointer, parentId: heap.Ref<object>, index: number): void => { 136 const _ret = WEBEXT.bookmarkManagerPrivate.drop(A.H.get<object>(parentId), index); 137 A.store.Ref(retPtr, _ret); 138 }, 139 "try_Drop": (retPtr: Pointer, errPtr: Pointer, parentId: heap.Ref<object>, index: number): heap.Ref<boolean> => { 140 try { 141 const _ret = WEBEXT.bookmarkManagerPrivate.drop(A.H.get<object>(parentId), index); 142 A.store.Ref(retPtr, _ret); 143 return A.H.TRUE; 144 } catch (err: any) { 145 A.store.Ref(errPtr, err); 146 return A.H.FALSE; 147 } 148 }, 149 "has_Export": (): heap.Ref<boolean> => { 150 if (WEBEXT?.bookmarkManagerPrivate && "export" in WEBEXT?.bookmarkManagerPrivate) { 151 return A.H.TRUE; 152 } 153 return A.H.FALSE; 154 }, 155 "func_Export": (fn: Pointer): void => { 156 A.store.Ref(fn, WEBEXT.bookmarkManagerPrivate.export); 157 }, 158 "call_Export": (retPtr: Pointer): void => { 159 const _ret = WEBEXT.bookmarkManagerPrivate.export(); 160 A.store.Ref(retPtr, _ret); 161 }, 162 "try_Export": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 163 try { 164 const _ret = WEBEXT.bookmarkManagerPrivate.export(); 165 A.store.Ref(retPtr, _ret); 166 return A.H.TRUE; 167 } catch (err: any) { 168 A.store.Ref(errPtr, err); 169 return A.H.FALSE; 170 } 171 }, 172 "has_GetSubtree": (): heap.Ref<boolean> => { 173 if (WEBEXT?.bookmarkManagerPrivate && "getSubtree" in WEBEXT?.bookmarkManagerPrivate) { 174 return A.H.TRUE; 175 } 176 return A.H.FALSE; 177 }, 178 "func_GetSubtree": (fn: Pointer): void => { 179 A.store.Ref(fn, WEBEXT.bookmarkManagerPrivate.getSubtree); 180 }, 181 "call_GetSubtree": (retPtr: Pointer, id: heap.Ref<object>, foldersOnly: heap.Ref<boolean>): void => { 182 const _ret = WEBEXT.bookmarkManagerPrivate.getSubtree(A.H.get<object>(id), foldersOnly === A.H.TRUE); 183 A.store.Ref(retPtr, _ret); 184 }, 185 "try_GetSubtree": ( 186 retPtr: Pointer, 187 errPtr: Pointer, 188 id: heap.Ref<object>, 189 foldersOnly: heap.Ref<boolean> 190 ): heap.Ref<boolean> => { 191 try { 192 const _ret = WEBEXT.bookmarkManagerPrivate.getSubtree(A.H.get<object>(id), foldersOnly === A.H.TRUE); 193 A.store.Ref(retPtr, _ret); 194 return A.H.TRUE; 195 } catch (err: any) { 196 A.store.Ref(errPtr, err); 197 return A.H.FALSE; 198 } 199 }, 200 "has_Import": (): heap.Ref<boolean> => { 201 if (WEBEXT?.bookmarkManagerPrivate && "import" in WEBEXT?.bookmarkManagerPrivate) { 202 return A.H.TRUE; 203 } 204 return A.H.FALSE; 205 }, 206 "func_Import": (fn: Pointer): void => { 207 A.store.Ref(fn, WEBEXT.bookmarkManagerPrivate.import); 208 }, 209 "call_Import": (retPtr: Pointer): void => { 210 const _ret = WEBEXT.bookmarkManagerPrivate.import(); 211 A.store.Ref(retPtr, _ret); 212 }, 213 "try_Import": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 214 try { 215 const _ret = WEBEXT.bookmarkManagerPrivate.import(); 216 A.store.Ref(retPtr, _ret); 217 return A.H.TRUE; 218 } catch (err: any) { 219 A.store.Ref(errPtr, err); 220 return A.H.FALSE; 221 } 222 }, 223 "has_OnDragEnter": (): heap.Ref<boolean> => { 224 if (WEBEXT?.bookmarkManagerPrivate?.onDragEnter && "addListener" in WEBEXT?.bookmarkManagerPrivate?.onDragEnter) { 225 return A.H.TRUE; 226 } 227 return A.H.FALSE; 228 }, 229 "func_OnDragEnter": (fn: Pointer): void => { 230 A.store.Ref(fn, WEBEXT.bookmarkManagerPrivate.onDragEnter.addListener); 231 }, 232 "call_OnDragEnter": (retPtr: Pointer, callback: heap.Ref<object>): void => { 233 const _ret = WEBEXT.bookmarkManagerPrivate.onDragEnter.addListener(A.H.get<object>(callback)); 234 }, 235 "try_OnDragEnter": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 236 try { 237 const _ret = WEBEXT.bookmarkManagerPrivate.onDragEnter.addListener(A.H.get<object>(callback)); 238 return A.H.TRUE; 239 } catch (err: any) { 240 A.store.Ref(errPtr, err); 241 return A.H.FALSE; 242 } 243 }, 244 "has_OffDragEnter": (): heap.Ref<boolean> => { 245 if ( 246 WEBEXT?.bookmarkManagerPrivate?.onDragEnter && 247 "removeListener" in WEBEXT?.bookmarkManagerPrivate?.onDragEnter 248 ) { 249 return A.H.TRUE; 250 } 251 return A.H.FALSE; 252 }, 253 "func_OffDragEnter": (fn: Pointer): void => { 254 A.store.Ref(fn, WEBEXT.bookmarkManagerPrivate.onDragEnter.removeListener); 255 }, 256 "call_OffDragEnter": (retPtr: Pointer, callback: heap.Ref<object>): void => { 257 const _ret = WEBEXT.bookmarkManagerPrivate.onDragEnter.removeListener(A.H.get<object>(callback)); 258 }, 259 "try_OffDragEnter": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 260 try { 261 const _ret = WEBEXT.bookmarkManagerPrivate.onDragEnter.removeListener(A.H.get<object>(callback)); 262 return A.H.TRUE; 263 } catch (err: any) { 264 A.store.Ref(errPtr, err); 265 return A.H.FALSE; 266 } 267 }, 268 "has_HasOnDragEnter": (): heap.Ref<boolean> => { 269 if (WEBEXT?.bookmarkManagerPrivate?.onDragEnter && "hasListener" in WEBEXT?.bookmarkManagerPrivate?.onDragEnter) { 270 return A.H.TRUE; 271 } 272 return A.H.FALSE; 273 }, 274 "func_HasOnDragEnter": (fn: Pointer): void => { 275 A.store.Ref(fn, WEBEXT.bookmarkManagerPrivate.onDragEnter.hasListener); 276 }, 277 "call_HasOnDragEnter": (retPtr: Pointer, callback: heap.Ref<object>): void => { 278 const _ret = WEBEXT.bookmarkManagerPrivate.onDragEnter.hasListener(A.H.get<object>(callback)); 279 A.store.Bool(retPtr, _ret); 280 }, 281 "try_HasOnDragEnter": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 282 try { 283 const _ret = WEBEXT.bookmarkManagerPrivate.onDragEnter.hasListener(A.H.get<object>(callback)); 284 A.store.Bool(retPtr, _ret); 285 return A.H.TRUE; 286 } catch (err: any) { 287 A.store.Ref(errPtr, err); 288 return A.H.FALSE; 289 } 290 }, 291 "has_OnDragLeave": (): heap.Ref<boolean> => { 292 if (WEBEXT?.bookmarkManagerPrivate?.onDragLeave && "addListener" in WEBEXT?.bookmarkManagerPrivate?.onDragLeave) { 293 return A.H.TRUE; 294 } 295 return A.H.FALSE; 296 }, 297 "func_OnDragLeave": (fn: Pointer): void => { 298 A.store.Ref(fn, WEBEXT.bookmarkManagerPrivate.onDragLeave.addListener); 299 }, 300 "call_OnDragLeave": (retPtr: Pointer, callback: heap.Ref<object>): void => { 301 const _ret = WEBEXT.bookmarkManagerPrivate.onDragLeave.addListener(A.H.get<object>(callback)); 302 }, 303 "try_OnDragLeave": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 304 try { 305 const _ret = WEBEXT.bookmarkManagerPrivate.onDragLeave.addListener(A.H.get<object>(callback)); 306 return A.H.TRUE; 307 } catch (err: any) { 308 A.store.Ref(errPtr, err); 309 return A.H.FALSE; 310 } 311 }, 312 "has_OffDragLeave": (): heap.Ref<boolean> => { 313 if ( 314 WEBEXT?.bookmarkManagerPrivate?.onDragLeave && 315 "removeListener" in WEBEXT?.bookmarkManagerPrivate?.onDragLeave 316 ) { 317 return A.H.TRUE; 318 } 319 return A.H.FALSE; 320 }, 321 "func_OffDragLeave": (fn: Pointer): void => { 322 A.store.Ref(fn, WEBEXT.bookmarkManagerPrivate.onDragLeave.removeListener); 323 }, 324 "call_OffDragLeave": (retPtr: Pointer, callback: heap.Ref<object>): void => { 325 const _ret = WEBEXT.bookmarkManagerPrivate.onDragLeave.removeListener(A.H.get<object>(callback)); 326 }, 327 "try_OffDragLeave": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 328 try { 329 const _ret = WEBEXT.bookmarkManagerPrivate.onDragLeave.removeListener(A.H.get<object>(callback)); 330 return A.H.TRUE; 331 } catch (err: any) { 332 A.store.Ref(errPtr, err); 333 return A.H.FALSE; 334 } 335 }, 336 "has_HasOnDragLeave": (): heap.Ref<boolean> => { 337 if (WEBEXT?.bookmarkManagerPrivate?.onDragLeave && "hasListener" in WEBEXT?.bookmarkManagerPrivate?.onDragLeave) { 338 return A.H.TRUE; 339 } 340 return A.H.FALSE; 341 }, 342 "func_HasOnDragLeave": (fn: Pointer): void => { 343 A.store.Ref(fn, WEBEXT.bookmarkManagerPrivate.onDragLeave.hasListener); 344 }, 345 "call_HasOnDragLeave": (retPtr: Pointer, callback: heap.Ref<object>): void => { 346 const _ret = WEBEXT.bookmarkManagerPrivate.onDragLeave.hasListener(A.H.get<object>(callback)); 347 A.store.Bool(retPtr, _ret); 348 }, 349 "try_HasOnDragLeave": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 350 try { 351 const _ret = WEBEXT.bookmarkManagerPrivate.onDragLeave.hasListener(A.H.get<object>(callback)); 352 A.store.Bool(retPtr, _ret); 353 return A.H.TRUE; 354 } catch (err: any) { 355 A.store.Ref(errPtr, err); 356 return A.H.FALSE; 357 } 358 }, 359 "has_OnDrop": (): heap.Ref<boolean> => { 360 if (WEBEXT?.bookmarkManagerPrivate?.onDrop && "addListener" in WEBEXT?.bookmarkManagerPrivate?.onDrop) { 361 return A.H.TRUE; 362 } 363 return A.H.FALSE; 364 }, 365 "func_OnDrop": (fn: Pointer): void => { 366 A.store.Ref(fn, WEBEXT.bookmarkManagerPrivate.onDrop.addListener); 367 }, 368 "call_OnDrop": (retPtr: Pointer, callback: heap.Ref<object>): void => { 369 const _ret = WEBEXT.bookmarkManagerPrivate.onDrop.addListener(A.H.get<object>(callback)); 370 }, 371 "try_OnDrop": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 372 try { 373 const _ret = WEBEXT.bookmarkManagerPrivate.onDrop.addListener(A.H.get<object>(callback)); 374 return A.H.TRUE; 375 } catch (err: any) { 376 A.store.Ref(errPtr, err); 377 return A.H.FALSE; 378 } 379 }, 380 "has_OffDrop": (): heap.Ref<boolean> => { 381 if (WEBEXT?.bookmarkManagerPrivate?.onDrop && "removeListener" in WEBEXT?.bookmarkManagerPrivate?.onDrop) { 382 return A.H.TRUE; 383 } 384 return A.H.FALSE; 385 }, 386 "func_OffDrop": (fn: Pointer): void => { 387 A.store.Ref(fn, WEBEXT.bookmarkManagerPrivate.onDrop.removeListener); 388 }, 389 "call_OffDrop": (retPtr: Pointer, callback: heap.Ref<object>): void => { 390 const _ret = WEBEXT.bookmarkManagerPrivate.onDrop.removeListener(A.H.get<object>(callback)); 391 }, 392 "try_OffDrop": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 393 try { 394 const _ret = WEBEXT.bookmarkManagerPrivate.onDrop.removeListener(A.H.get<object>(callback)); 395 return A.H.TRUE; 396 } catch (err: any) { 397 A.store.Ref(errPtr, err); 398 return A.H.FALSE; 399 } 400 }, 401 "has_HasOnDrop": (): heap.Ref<boolean> => { 402 if (WEBEXT?.bookmarkManagerPrivate?.onDrop && "hasListener" in WEBEXT?.bookmarkManagerPrivate?.onDrop) { 403 return A.H.TRUE; 404 } 405 return A.H.FALSE; 406 }, 407 "func_HasOnDrop": (fn: Pointer): void => { 408 A.store.Ref(fn, WEBEXT.bookmarkManagerPrivate.onDrop.hasListener); 409 }, 410 "call_HasOnDrop": (retPtr: Pointer, callback: heap.Ref<object>): void => { 411 const _ret = WEBEXT.bookmarkManagerPrivate.onDrop.hasListener(A.H.get<object>(callback)); 412 A.store.Bool(retPtr, _ret); 413 }, 414 "try_HasOnDrop": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 415 try { 416 const _ret = WEBEXT.bookmarkManagerPrivate.onDrop.hasListener(A.H.get<object>(callback)); 417 A.store.Bool(retPtr, _ret); 418 return A.H.TRUE; 419 } catch (err: any) { 420 A.store.Ref(errPtr, err); 421 return A.H.FALSE; 422 } 423 }, 424 "has_OpenInNewTab": (): heap.Ref<boolean> => { 425 if (WEBEXT?.bookmarkManagerPrivate && "openInNewTab" in WEBEXT?.bookmarkManagerPrivate) { 426 return A.H.TRUE; 427 } 428 return A.H.FALSE; 429 }, 430 "func_OpenInNewTab": (fn: Pointer): void => { 431 A.store.Ref(fn, WEBEXT.bookmarkManagerPrivate.openInNewTab); 432 }, 433 "call_OpenInNewTab": (retPtr: Pointer, id: heap.Ref<object>, active: heap.Ref<boolean>): void => { 434 const _ret = WEBEXT.bookmarkManagerPrivate.openInNewTab(A.H.get<object>(id), active === A.H.TRUE); 435 }, 436 "try_OpenInNewTab": ( 437 retPtr: Pointer, 438 errPtr: Pointer, 439 id: heap.Ref<object>, 440 active: heap.Ref<boolean> 441 ): heap.Ref<boolean> => { 442 try { 443 const _ret = WEBEXT.bookmarkManagerPrivate.openInNewTab(A.H.get<object>(id), active === A.H.TRUE); 444 return A.H.TRUE; 445 } catch (err: any) { 446 A.store.Ref(errPtr, err); 447 return A.H.FALSE; 448 } 449 }, 450 "has_OpenInNewWindow": (): heap.Ref<boolean> => { 451 if (WEBEXT?.bookmarkManagerPrivate && "openInNewWindow" in WEBEXT?.bookmarkManagerPrivate) { 452 return A.H.TRUE; 453 } 454 return A.H.FALSE; 455 }, 456 "func_OpenInNewWindow": (fn: Pointer): void => { 457 A.store.Ref(fn, WEBEXT.bookmarkManagerPrivate.openInNewWindow); 458 }, 459 "call_OpenInNewWindow": (retPtr: Pointer, idList: heap.Ref<object>, incognito: heap.Ref<boolean>): void => { 460 const _ret = WEBEXT.bookmarkManagerPrivate.openInNewWindow(A.H.get<object>(idList), incognito === A.H.TRUE); 461 }, 462 "try_OpenInNewWindow": ( 463 retPtr: Pointer, 464 errPtr: Pointer, 465 idList: heap.Ref<object>, 466 incognito: heap.Ref<boolean> 467 ): heap.Ref<boolean> => { 468 try { 469 const _ret = WEBEXT.bookmarkManagerPrivate.openInNewWindow(A.H.get<object>(idList), incognito === A.H.TRUE); 470 return A.H.TRUE; 471 } catch (err: any) { 472 A.store.Ref(errPtr, err); 473 return A.H.FALSE; 474 } 475 }, 476 "has_Paste": (): heap.Ref<boolean> => { 477 if (WEBEXT?.bookmarkManagerPrivate && "paste" in WEBEXT?.bookmarkManagerPrivate) { 478 return A.H.TRUE; 479 } 480 return A.H.FALSE; 481 }, 482 "func_Paste": (fn: Pointer): void => { 483 A.store.Ref(fn, WEBEXT.bookmarkManagerPrivate.paste); 484 }, 485 "call_Paste": (retPtr: Pointer, parentId: heap.Ref<object>, selectedIdList: heap.Ref<object>): void => { 486 const _ret = WEBEXT.bookmarkManagerPrivate.paste(A.H.get<object>(parentId), A.H.get<object>(selectedIdList)); 487 A.store.Ref(retPtr, _ret); 488 }, 489 "try_Paste": ( 490 retPtr: Pointer, 491 errPtr: Pointer, 492 parentId: heap.Ref<object>, 493 selectedIdList: heap.Ref<object> 494 ): heap.Ref<boolean> => { 495 try { 496 const _ret = WEBEXT.bookmarkManagerPrivate.paste(A.H.get<object>(parentId), A.H.get<object>(selectedIdList)); 497 A.store.Ref(retPtr, _ret); 498 return A.H.TRUE; 499 } catch (err: any) { 500 A.store.Ref(errPtr, err); 501 return A.H.FALSE; 502 } 503 }, 504 "has_Redo": (): heap.Ref<boolean> => { 505 if (WEBEXT?.bookmarkManagerPrivate && "redo" in WEBEXT?.bookmarkManagerPrivate) { 506 return A.H.TRUE; 507 } 508 return A.H.FALSE; 509 }, 510 "func_Redo": (fn: Pointer): void => { 511 A.store.Ref(fn, WEBEXT.bookmarkManagerPrivate.redo); 512 }, 513 "call_Redo": (retPtr: Pointer): void => { 514 const _ret = WEBEXT.bookmarkManagerPrivate.redo(); 515 }, 516 "try_Redo": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 517 try { 518 const _ret = WEBEXT.bookmarkManagerPrivate.redo(); 519 return A.H.TRUE; 520 } catch (err: any) { 521 A.store.Ref(errPtr, err); 522 return A.H.FALSE; 523 } 524 }, 525 "has_RemoveTrees": (): heap.Ref<boolean> => { 526 if (WEBEXT?.bookmarkManagerPrivate && "removeTrees" in WEBEXT?.bookmarkManagerPrivate) { 527 return A.H.TRUE; 528 } 529 return A.H.FALSE; 530 }, 531 "func_RemoveTrees": (fn: Pointer): void => { 532 A.store.Ref(fn, WEBEXT.bookmarkManagerPrivate.removeTrees); 533 }, 534 "call_RemoveTrees": (retPtr: Pointer, idList: heap.Ref<object>): void => { 535 const _ret = WEBEXT.bookmarkManagerPrivate.removeTrees(A.H.get<object>(idList)); 536 A.store.Ref(retPtr, _ret); 537 }, 538 "try_RemoveTrees": (retPtr: Pointer, errPtr: Pointer, idList: heap.Ref<object>): heap.Ref<boolean> => { 539 try { 540 const _ret = WEBEXT.bookmarkManagerPrivate.removeTrees(A.H.get<object>(idList)); 541 A.store.Ref(retPtr, _ret); 542 return A.H.TRUE; 543 } catch (err: any) { 544 A.store.Ref(errPtr, err); 545 return A.H.FALSE; 546 } 547 }, 548 "has_SortChildren": (): heap.Ref<boolean> => { 549 if (WEBEXT?.bookmarkManagerPrivate && "sortChildren" in WEBEXT?.bookmarkManagerPrivate) { 550 return A.H.TRUE; 551 } 552 return A.H.FALSE; 553 }, 554 "func_SortChildren": (fn: Pointer): void => { 555 A.store.Ref(fn, WEBEXT.bookmarkManagerPrivate.sortChildren); 556 }, 557 "call_SortChildren": (retPtr: Pointer, parentId: heap.Ref<object>): void => { 558 const _ret = WEBEXT.bookmarkManagerPrivate.sortChildren(A.H.get<object>(parentId)); 559 }, 560 "try_SortChildren": (retPtr: Pointer, errPtr: Pointer, parentId: heap.Ref<object>): heap.Ref<boolean> => { 561 try { 562 const _ret = WEBEXT.bookmarkManagerPrivate.sortChildren(A.H.get<object>(parentId)); 563 return A.H.TRUE; 564 } catch (err: any) { 565 A.store.Ref(errPtr, err); 566 return A.H.FALSE; 567 } 568 }, 569 "has_StartDrag": (): heap.Ref<boolean> => { 570 if (WEBEXT?.bookmarkManagerPrivate && "startDrag" in WEBEXT?.bookmarkManagerPrivate) { 571 return A.H.TRUE; 572 } 573 return A.H.FALSE; 574 }, 575 "func_StartDrag": (fn: Pointer): void => { 576 A.store.Ref(fn, WEBEXT.bookmarkManagerPrivate.startDrag); 577 }, 578 "call_StartDrag": ( 579 retPtr: Pointer, 580 idList: heap.Ref<object>, 581 dragNodeIndex: number, 582 isFromTouch: heap.Ref<boolean>, 583 x: number, 584 y: number 585 ): void => { 586 const _ret = WEBEXT.bookmarkManagerPrivate.startDrag( 587 A.H.get<object>(idList), 588 dragNodeIndex, 589 isFromTouch === A.H.TRUE, 590 x, 591 y 592 ); 593 }, 594 "try_StartDrag": ( 595 retPtr: Pointer, 596 errPtr: Pointer, 597 idList: heap.Ref<object>, 598 dragNodeIndex: number, 599 isFromTouch: heap.Ref<boolean>, 600 x: number, 601 y: number 602 ): heap.Ref<boolean> => { 603 try { 604 const _ret = WEBEXT.bookmarkManagerPrivate.startDrag( 605 A.H.get<object>(idList), 606 dragNodeIndex, 607 isFromTouch === A.H.TRUE, 608 x, 609 y 610 ); 611 return A.H.TRUE; 612 } catch (err: any) { 613 A.store.Ref(errPtr, err); 614 return A.H.FALSE; 615 } 616 }, 617 "has_Undo": (): heap.Ref<boolean> => { 618 if (WEBEXT?.bookmarkManagerPrivate && "undo" in WEBEXT?.bookmarkManagerPrivate) { 619 return A.H.TRUE; 620 } 621 return A.H.FALSE; 622 }, 623 "func_Undo": (fn: Pointer): void => { 624 A.store.Ref(fn, WEBEXT.bookmarkManagerPrivate.undo); 625 }, 626 "call_Undo": (retPtr: Pointer): void => { 627 const _ret = WEBEXT.bookmarkManagerPrivate.undo(); 628 }, 629 "try_Undo": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 630 try { 631 const _ret = WEBEXT.bookmarkManagerPrivate.undo(); 632 return A.H.TRUE; 633 } catch (err: any) { 634 A.store.Ref(errPtr, err); 635 return A.H.FALSE; 636 } 637 }, 638 }; 639 });