remote/test/puppeteer/test-d/ElementHandle.test-d.ts

   1 /**
   2  * @license
   3  * Copyright 2024 Google Inc.
   4  * SPDX-License-Identifier: Apache-2.0
   5  */
   6 import type {ElementHandle} from 'puppeteer';
   7 import {expectNotType, expectType} from 'tsd';
   8
   9 declare const handle: ElementHandle;
  10
  11 {
  12   {
  13     {
  14       expectType<ElementHandle<HTMLAnchorElement> | null>(await handle.$('a'));
  15       expectNotType<ElementHandle<Element> | null>(await handle.$('a'));
  16     }
  17     {
  18       expectType<ElementHandle<HTMLAnchorElement> | null>(
  19         await handle.$('a#id'),
  20       );
  21       expectNotType<ElementHandle<Element> | null>(await handle.$('a#id'));
  22     }
  23     {
  24       expectType<ElementHandle<HTMLAnchorElement> | null>(
  25         await handle.$('a.class'),
  26       );
  27       expectNotType<ElementHandle<Element> | null>(await handle.$('a.class'));
  28     }
  29     {
  30       expectType<ElementHandle<HTMLAnchorElement> | null>(
  31         await handle.$('a[attr=value]'),
  32       );
  33       expectNotType<ElementHandle<Element> | null>(
  34         await handle.$('a[attr=value]'),
  35       );
  36     }
  37     {
  38       expectType<ElementHandle<HTMLAnchorElement> | null>(
  39         await handle.$('a:psuedo-class'),
  40       );
  41       expectNotType<ElementHandle<Element> | null>(
  42         await handle.$('a:pseudo-class'),
  43       );
  44     }
  45     {
  46       expectType<ElementHandle<HTMLAnchorElement> | null>(
  47         await handle.$('a:func(arg)'),
  48       );
  49       expectNotType<ElementHandle<Element> | null>(
  50         await handle.$('a:func(arg)'),
  51       );
  52     }
  53   }
  54   {
  55     {
  56       expectType<ElementHandle<HTMLDivElement> | null>(await handle.$('div'));
  57       expectNotType<ElementHandle<Element> | null>(await handle.$('div'));
  58     }
  59     {
  60       expectType<ElementHandle<HTMLDivElement> | null>(
  61         await handle.$('div#id'),
  62       );
  63       expectNotType<ElementHandle<Element> | null>(await handle.$('div#id'));
  64     }
  65     {
  66       expectType<ElementHandle<HTMLDivElement> | null>(
  67         await handle.$('div.class'),
  68       );
  69       expectNotType<ElementHandle<Element> | null>(await handle.$('div.class'));
  70     }
  71     {
  72       expectType<ElementHandle<HTMLDivElement> | null>(
  73         await handle.$('div[attr=value]'),
  74       );
  75       expectNotType<ElementHandle<Element> | null>(
  76         await handle.$('div[attr=value]'),
  77       );
  78     }
  79     {
  80       expectType<ElementHandle<HTMLDivElement> | null>(
  81         await handle.$('div:psuedo-class'),
  82       );
  83       expectNotType<ElementHandle<Element> | null>(
  84         await handle.$('div:pseudo-class'),
  85       );
  86     }
  87     {
  88       expectType<ElementHandle<HTMLDivElement> | null>(
  89         await handle.$('div:func(arg)'),
  90       );
  91       expectNotType<ElementHandle<Element> | null>(
  92         await handle.$('div:func(arg)'),
  93       );
  94     }
  95   }
  96   {
  97     {
  98       expectType<ElementHandle<Element> | null>(await handle.$('some-custom'));
  99     }
 100     {
 101       expectType<ElementHandle<Element> | null>(
 102         await handle.$('some-custom#id'),
 103       );
 104     }
 105     {
 106       expectType<ElementHandle<Element> | null>(
 107         await handle.$('some-custom.class'),
 108       );
 109     }
 110     {
 111       expectType<ElementHandle<Element> | null>(
 112         await handle.$('some-custom[attr=value]'),
 113       );
 114     }
 115     {
 116       expectType<ElementHandle<Element> | null>(
 117         await handle.$('some-custom:pseudo-class'),
 118       );
 119     }
 120     {
 121       expectType<ElementHandle<Element> | null>(
 122         await handle.$('some-custom:func(arg)'),
 123       );
 124     }
 125   }
 126   {
 127     {
 128       expectType<ElementHandle<Element> | null>(await handle.$(''));
 129     }
 130     {
 131       expectType<ElementHandle<Element> | null>(await handle.$('#id'));
 132     }
 133     {
 134       expectType<ElementHandle<Element> | null>(await handle.$('.class'));
 135     }
 136     {
 137       expectType<ElementHandle<Element> | null>(await handle.$('[attr=value]'));
 138     }
 139     {
 140       expectType<ElementHandle<Element> | null>(
 141         await handle.$(':pseudo-class'),
 142       );
 143     }
 144     {
 145       expectType<ElementHandle<Element> | null>(await handle.$(':func(arg)'));
 146     }
 147   }
 148   {
 149     {
 150       expectType<ElementHandle<HTMLAnchorElement> | null>(
 151         await handle.$('div > a'),
 152       );
 153       expectNotType<ElementHandle<Element> | null>(await handle.$('div > a'));
 154     }
 155     {
 156       expectType<ElementHandle<HTMLAnchorElement> | null>(
 157         await handle.$('div > a#id'),
 158       );
 159       expectNotType<ElementHandle<Element> | null>(
 160         await handle.$('div > a#id'),
 161       );
 162     }
 163     {
 164       expectType<ElementHandle<HTMLAnchorElement> | null>(
 165         await handle.$('div > a.class'),
 166       );
 167       expectNotType<ElementHandle<Element> | null>(
 168         await handle.$('div > a.class'),
 169       );
 170     }
 171     {
 172       expectType<ElementHandle<HTMLAnchorElement> | null>(
 173         await handle.$('div > a[attr=value]'),
 174       );
 175       expectNotType<ElementHandle<Element> | null>(
 176         await handle.$('div > a[attr=value]'),
 177       );
 178     }
 179     {
 180       expectType<ElementHandle<HTMLAnchorElement> | null>(
 181         await handle.$('div > a:psuedo-class'),
 182       );
 183       expectNotType<ElementHandle<Element> | null>(
 184         await handle.$('div > a:pseudo-class'),
 185       );
 186     }
 187     {
 188       expectType<ElementHandle<HTMLAnchorElement> | null>(
 189         await handle.$('div > a:func(arg)'),
 190       );
 191       expectNotType<ElementHandle<Element> | null>(
 192         await handle.$('div > a:func(arg)'),
 193       );
 194     }
 195   }
 196   {
 197     {
 198       expectType<ElementHandle<HTMLDivElement> | null>(
 199         await handle.$('div > div'),
 200       );
 201       expectNotType<ElementHandle<Element> | null>(await handle.$('div > div'));
 202     }
 203     {
 204       expectType<ElementHandle<HTMLDivElement> | null>(
 205         await handle.$('div > div#id'),
 206       );
 207       expectNotType<ElementHandle<Element> | null>(
 208         await handle.$('div > div#id'),
 209       );
 210     }
 211     {
 212       expectType<ElementHandle<HTMLDivElement> | null>(
 213         await handle.$('div > div.class'),
 214       );
 215       expectNotType<ElementHandle<Element> | null>(
 216         await handle.$('div > div.class'),
 217       );
 218     }
 219     {
 220       expectType<ElementHandle<HTMLDivElement> | null>(
 221         await handle.$('div > div[attr=value]'),
 222       );
 223       expectNotType<ElementHandle<Element> | null>(
 224         await handle.$('div > div[attr=value]'),
 225       );
 226     }
 227     {
 228       expectType<ElementHandle<HTMLDivElement> | null>(
 229         await handle.$('div > div:psuedo-class'),
 230       );
 231       expectNotType<ElementHandle<Element> | null>(
 232         await handle.$('div > div:pseudo-class'),
 233       );
 234     }
 235     {
 236       expectType<ElementHandle<HTMLDivElement> | null>(
 237         await handle.$('div > div:func(arg)'),
 238       );
 239       expectNotType<ElementHandle<Element> | null>(
 240         await handle.$('div > div:func(arg)'),
 241       );
 242     }
 243   }
 244   {
 245     {
 246       expectType<ElementHandle<Element> | null>(
 247         await handle.$('div > some-custom'),
 248       );
 249     }
 250     {
 251       expectType<ElementHandle<Element> | null>(
 252         await handle.$('div > some-custom#id'),
 253       );
 254     }
 255     {
 256       expectType<ElementHandle<Element> | null>(
 257         await handle.$('div > some-custom.class'),
 258       );
 259     }
 260     {
 261       expectType<ElementHandle<Element> | null>(
 262         await handle.$('div > some-custom[attr=value]'),
 263       );
 264     }
 265     {
 266       expectType<ElementHandle<Element> | null>(
 267         await handle.$('div > some-custom:pseudo-class'),
 268       );
 269     }
 270     {
 271       expectType<ElementHandle<Element> | null>(
 272         await handle.$('div > some-custom:func(arg)'),
 273       );
 274     }
 275   }
 276   {
 277     {
 278       expectType<ElementHandle<Element> | null>(await handle.$('div > #id'));
 279     }
 280     {
 281       expectType<ElementHandle<Element> | null>(await handle.$('div > .class'));
 282     }
 283     {
 284       expectType<ElementHandle<Element> | null>(
 285         await handle.$('div > [attr=value]'),
 286       );
 287     }
 288     {
 289       expectType<ElementHandle<Element> | null>(
 290         await handle.$('div > :pseudo-class'),
 291       );
 292     }
 293     {
 294       expectType<ElementHandle<Element> | null>(
 295         await handle.$('div > :func(arg)'),
 296       );
 297     }
 298   }
 299   {
 300     {
 301       expectType<ElementHandle<HTMLAnchorElement> | null>(
 302         await handle.$('div > a'),
 303       );
 304       expectNotType<ElementHandle<Element> | null>(await handle.$('div > a'));
 305     }
 306     {
 307       expectType<ElementHandle<HTMLAnchorElement> | null>(
 308         await handle.$('div > a#id'),
 309       );
 310       expectNotType<ElementHandle<Element> | null>(
 311         await handle.$('div > a#id'),
 312       );
 313     }
 314     {
 315       expectType<ElementHandle<HTMLAnchorElement> | null>(
 316         await handle.$('div > a.class'),
 317       );
 318       expectNotType<ElementHandle<Element> | null>(
 319         await handle.$('div > a.class'),
 320       );
 321     }
 322     {
 323       expectType<ElementHandle<HTMLAnchorElement> | null>(
 324         await handle.$('div > a[attr=value]'),
 325       );
 326       expectNotType<ElementHandle<Element> | null>(
 327         await handle.$('div > a[attr=value]'),
 328       );
 329     }
 330     {
 331       expectType<ElementHandle<HTMLAnchorElement> | null>(
 332         await handle.$('div > a:psuedo-class'),
 333       );
 334       expectNotType<ElementHandle<Element> | null>(
 335         await handle.$('div > a:pseudo-class'),
 336       );
 337     }
 338     {
 339       expectType<ElementHandle<HTMLAnchorElement> | null>(
 340         await handle.$('div > a:func(arg)'),
 341       );
 342       expectNotType<ElementHandle<Element> | null>(
 343         await handle.$('div > a:func(arg)'),
 344       );
 345     }
 346   }
 347   {
 348     {
 349       expectType<ElementHandle<HTMLDivElement> | null>(
 350         await handle.$('div > div'),
 351       );
 352       expectNotType<ElementHandle<Element> | null>(await handle.$('div > div'));
 353     }
 354     {
 355       expectType<ElementHandle<HTMLDivElement> | null>(
 356         await handle.$('div > div#id'),
 357       );
 358       expectNotType<ElementHandle<Element> | null>(
 359         await handle.$('div > div#id'),
 360       );
 361     }
 362     {
 363       expectType<ElementHandle<HTMLDivElement> | null>(
 364         await handle.$('div > div.class'),
 365       );
 366       expectNotType<ElementHandle<Element> | null>(
 367         await handle.$('div > div.class'),
 368       );
 369     }
 370     {
 371       expectType<ElementHandle<HTMLDivElement> | null>(
 372         await handle.$('div > div[attr=value]'),
 373       );
 374       expectNotType<ElementHandle<Element> | null>(
 375         await handle.$('div > div[attr=value]'),
 376       );
 377     }
 378     {
 379       expectType<ElementHandle<HTMLDivElement> | null>(
 380         await handle.$('div > div:psuedo-class'),
 381       );
 382       expectNotType<ElementHandle<Element> | null>(
 383         await handle.$('div > div:pseudo-class'),
 384       );
 385     }
 386     {
 387       expectType<ElementHandle<HTMLDivElement> | null>(
 388         await handle.$('div > div:func(arg)'),
 389       );
 390       expectNotType<ElementHandle<Element> | null>(
 391         await handle.$('div > div:func(arg)'),
 392       );
 393     }
 394   }
 395   {
 396     {
 397       expectType<ElementHandle<Element> | null>(
 398         await handle.$('div > some-custom'),
 399       );
 400     }
 401     {
 402       expectType<ElementHandle<Element> | null>(
 403         await handle.$('div > some-custom#id'),
 404       );
 405     }
 406     {
 407       expectType<ElementHandle<Element> | null>(
 408         await handle.$('div > some-custom.class'),
 409       );
 410     }
 411     {
 412       expectType<ElementHandle<Element> | null>(
 413         await handle.$('div > some-custom[attr=value]'),
 414       );
 415     }
 416     {
 417       expectType<ElementHandle<Element> | null>(
 418         await handle.$('div > some-custom:pseudo-class'),
 419       );
 420     }
 421     {
 422       expectType<ElementHandle<Element> | null>(
 423         await handle.$('div > some-custom:func(arg)'),
 424       );
 425     }
 426   }
 427   {
 428     {
 429       expectType<ElementHandle<Element> | null>(await handle.$('div > #id'));
 430     }
 431     {
 432       expectType<ElementHandle<Element> | null>(await handle.$('div > .class'));
 433     }
 434     {
 435       expectType<ElementHandle<Element> | null>(
 436         await handle.$('div > [attr=value]'),
 437       );
 438     }
 439     {
 440       expectType<ElementHandle<Element> | null>(
 441         await handle.$('div > :pseudo-class'),
 442       );
 443     }
 444     {
 445       expectType<ElementHandle<Element> | null>(
 446         await handle.$('div > :func(arg)'),
 447       );
 448     }
 449   }
 450 }
 451
 452 {
 453   {
 454     {
 455       expectType<Array<ElementHandle<HTMLAnchorElement>>>(await handle.$$('a'));
 456       expectNotType<Array<ElementHandle<Element>>>(await handle.$$('a'));
 457     }
 458     {
 459       expectType<Array<ElementHandle<HTMLAnchorElement>>>(
 460         await handle.$$('a#id'),
 461       );
 462       expectNotType<Array<ElementHandle<Element>>>(await handle.$$('a#id'));
 463     }
 464     {
 465       expectType<Array<ElementHandle<HTMLAnchorElement>>>(
 466         await handle.$$('a.class'),
 467       );
 468       expectNotType<Array<ElementHandle<Element>>>(await handle.$$('a.class'));
 469     }
 470     {
 471       expectType<Array<ElementHandle<HTMLAnchorElement>>>(
 472         await handle.$$('a[attr=value]'),
 473       );
 474       expectNotType<Array<ElementHandle<Element>>>(
 475         await handle.$$('a[attr=value]'),
 476       );
 477     }
 478     {
 479       expectType<Array<ElementHandle<HTMLAnchorElement>>>(
 480         await handle.$$('a:psuedo-class'),
 481       );
 482       expectNotType<Array<ElementHandle<Element>>>(
 483         await handle.$$('a:pseudo-class'),
 484       );
 485     }
 486     {
 487       expectType<Array<ElementHandle<HTMLAnchorElement>>>(
 488         await handle.$$('a:func(arg)'),
 489       );
 490       expectNotType<Array<ElementHandle<Element>>>(
 491         await handle.$$('a:func(arg)'),
 492       );
 493     }
 494   }
 495   {
 496     {
 497       expectType<Array<ElementHandle<HTMLDivElement>>>(await handle.$$('div'));
 498       expectNotType<Array<ElementHandle<Element>>>(await handle.$$('div'));
 499     }
 500     {
 501       expectType<Array<ElementHandle<HTMLDivElement>>>(
 502         await handle.$$('div#id'),
 503       );
 504       expectNotType<Array<ElementHandle<Element>>>(await handle.$$('div#id'));
 505     }
 506     {
 507       expectType<Array<ElementHandle<HTMLDivElement>>>(
 508         await handle.$$('div.class'),
 509       );
 510       expectNotType<Array<ElementHandle<Element>>>(
 511         await handle.$$('div.class'),
 512       );
 513     }
 514     {
 515       expectType<Array<ElementHandle<HTMLDivElement>>>(
 516         await handle.$$('div[attr=value]'),
 517       );
 518       expectNotType<Array<ElementHandle<Element>>>(
 519         await handle.$$('div[attr=value]'),
 520       );
 521     }
 522     {
 523       expectType<Array<ElementHandle<HTMLDivElement>>>(
 524         await handle.$$('div:psuedo-class'),
 525       );
 526       expectNotType<Array<ElementHandle<Element>>>(
 527         await handle.$$('div:pseudo-class'),
 528       );
 529     }
 530     {
 531       expectType<Array<ElementHandle<HTMLDivElement>>>(
 532         await handle.$$('div:func(arg)'),
 533       );
 534       expectNotType<Array<ElementHandle<Element>>>(
 535         await handle.$$('div:func(arg)'),
 536       );
 537     }
 538   }
 539   {
 540     {
 541       expectType<Array<ElementHandle<Element>>>(await handle.$$('some-custom'));
 542     }
 543     {
 544       expectType<Array<ElementHandle<Element>>>(
 545         await handle.$$('some-custom#id'),
 546       );
 547     }
 548     {
 549       expectType<Array<ElementHandle<Element>>>(
 550         await handle.$$('some-custom.class'),
 551       );
 552     }
 553     {
 554       expectType<Array<ElementHandle<Element>>>(
 555         await handle.$$('some-custom[attr=value]'),
 556       );
 557     }
 558     {
 559       expectType<Array<ElementHandle<Element>>>(
 560         await handle.$$('some-custom:pseudo-class'),
 561       );
 562     }
 563     {
 564       expectType<Array<ElementHandle<Element>>>(
 565         await handle.$$('some-custom:func(arg)'),
 566       );
 567     }
 568   }
 569   {
 570     {
 571       expectType<Array<ElementHandle<Element>>>(await handle.$$(''));
 572     }
 573     {
 574       expectType<Array<ElementHandle<Element>>>(await handle.$$('#id'));
 575     }
 576     {
 577       expectType<Array<ElementHandle<Element>>>(await handle.$$('.class'));
 578     }
 579     {
 580       expectType<Array<ElementHandle<Element>>>(
 581         await handle.$$('[attr=value]'),
 582       );
 583     }
 584     {
 585       expectType<Array<ElementHandle<Element>>>(
 586         await handle.$$(':pseudo-class'),
 587       );
 588     }
 589     {
 590       expectType<Array<ElementHandle<Element>>>(await handle.$$(':func(arg)'));
 591     }
 592   }
 593   {
 594     {
 595       expectType<Array<ElementHandle<HTMLAnchorElement>>>(
 596         await handle.$$('div > a'),
 597       );
 598       expectNotType<Array<ElementHandle<Element>>>(await handle.$$('div > a'));
 599     }
 600     {
 601       expectType<Array<ElementHandle<HTMLAnchorElement>>>(
 602         await handle.$$('div > a#id'),
 603       );
 604       expectNotType<Array<ElementHandle<Element>>>(
 605         await handle.$$('div > a#id'),
 606       );
 607     }
 608     {
 609       expectType<Array<ElementHandle<HTMLAnchorElement>>>(
 610         await handle.$$('div > a.class'),
 611       );
 612       expectNotType<Array<ElementHandle<Element>>>(
 613         await handle.$$('div > a.class'),
 614       );
 615     }
 616     {
 617       expectType<Array<ElementHandle<HTMLAnchorElement>>>(
 618         await handle.$$('div > a[attr=value]'),
 619       );
 620       expectNotType<Array<ElementHandle<Element>>>(
 621         await handle.$$('div > a[attr=value]'),
 622       );
 623     }
 624     {
 625       expectType<Array<ElementHandle<HTMLAnchorElement>>>(
 626         await handle.$$('div > a:psuedo-class'),
 627       );
 628       expectNotType<Array<ElementHandle<Element>>>(
 629         await handle.$$('div > a:pseudo-class'),
 630       );
 631     }
 632     {
 633       expectType<Array<ElementHandle<HTMLAnchorElement>>>(
 634         await handle.$$('div > a:func(arg)'),
 635       );
 636       expectNotType<Array<ElementHandle<Element>>>(
 637         await handle.$$('div > a:func(arg)'),
 638       );
 639     }
 640   }
 641   {
 642     {
 643       expectType<Array<ElementHandle<HTMLDivElement>>>(
 644         await handle.$$('div > div'),
 645       );
 646       expectNotType<Array<ElementHandle<Element>>>(
 647         await handle.$$('div > div'),
 648       );
 649     }
 650     {
 651       expectType<Array<ElementHandle<HTMLDivElement>>>(
 652         await handle.$$('div > div#id'),
 653       );
 654       expectNotType<Array<ElementHandle<Element>>>(
 655         await handle.$$('div > div#id'),
 656       );
 657     }
 658     {
 659       expectType<Array<ElementHandle<HTMLDivElement>>>(
 660         await handle.$$('div > div.class'),
 661       );
 662       expectNotType<Array<ElementHandle<Element>>>(
 663         await handle.$$('div > div.class'),
 664       );
 665     }
 666     {
 667       expectType<Array<ElementHandle<HTMLDivElement>>>(
 668         await handle.$$('div > div[attr=value]'),
 669       );
 670       expectNotType<Array<ElementHandle<Element>>>(
 671         await handle.$$('div > div[attr=value]'),
 672       );
 673     }
 674     {
 675       expectType<Array<ElementHandle<HTMLDivElement>>>(
 676         await handle.$$('div > div:psuedo-class'),
 677       );
 678       expectNotType<Array<ElementHandle<Element>>>(
 679         await handle.$$('div > div:pseudo-class'),
 680       );
 681     }
 682     {
 683       expectType<Array<ElementHandle<HTMLDivElement>>>(
 684         await handle.$$('div > div:func(arg)'),
 685       );
 686       expectNotType<Array<ElementHandle<Element>>>(
 687         await handle.$$('div > div:func(arg)'),
 688       );
 689     }
 690   }
 691   {
 692     {
 693       expectType<Array<ElementHandle<Element>>>(
 694         await handle.$$('div > some-custom'),
 695       );
 696     }
 697     {
 698       expectType<Array<ElementHandle<Element>>>(
 699         await handle.$$('div > some-custom#id'),
 700       );
 701     }
 702     {
 703       expectType<Array<ElementHandle<Element>>>(
 704         await handle.$$('div > some-custom.class'),
 705       );
 706     }
 707     {
 708       expectType<Array<ElementHandle<Element>>>(
 709         await handle.$$('div > some-custom[attr=value]'),
 710       );
 711     }
 712     {
 713       expectType<Array<ElementHandle<Element>>>(
 714         await handle.$$('div > some-custom:pseudo-class'),
 715       );
 716     }
 717     {
 718       expectType<Array<ElementHandle<Element>>>(
 719         await handle.$$('div > some-custom:func(arg)'),
 720       );
 721     }
 722   }
 723   {
 724     {
 725       expectType<Array<ElementHandle<Element>>>(await handle.$$('div > #id'));
 726     }
 727     {
 728       expectType<Array<ElementHandle<Element>>>(
 729         await handle.$$('div > .class'),
 730       );
 731     }
 732     {
 733       expectType<Array<ElementHandle<Element>>>(
 734         await handle.$$('div > [attr=value]'),
 735       );
 736     }
 737     {
 738       expectType<Array<ElementHandle<Element>>>(
 739         await handle.$$('div > :pseudo-class'),
 740       );
 741     }
 742     {
 743       expectType<Array<ElementHandle<Element>>>(
 744         await handle.$$('div > :func(arg)'),
 745       );
 746     }
 747   }
 748   {
 749     {
 750       expectType<Array<ElementHandle<HTMLAnchorElement>>>(
 751         await handle.$$('div > a'),
 752       );
 753       expectNotType<Array<ElementHandle<Element>>>(await handle.$$('div > a'));
 754     }
 755     {
 756       expectType<Array<ElementHandle<HTMLAnchorElement>>>(
 757         await handle.$$('div > a#id'),
 758       );
 759       expectNotType<Array<ElementHandle<Element>>>(
 760         await handle.$$('div > a#id'),
 761       );
 762     }
 763     {
 764       expectType<Array<ElementHandle<HTMLAnchorElement>>>(
 765         await handle.$$('div > a.class'),
 766       );
 767       expectNotType<Array<ElementHandle<Element>>>(
 768         await handle.$$('div > a.class'),
 769       );
 770     }
 771     {
 772       expectType<Array<ElementHandle<HTMLAnchorElement>>>(
 773         await handle.$$('div > a[attr=value]'),
 774       );
 775       expectNotType<Array<ElementHandle<Element>>>(
 776         await handle.$$('div > a[attr=value]'),
 777       );
 778     }
 779     {
 780       expectType<Array<ElementHandle<HTMLAnchorElement>>>(
 781         await handle.$$('div > a:psuedo-class'),
 782       );
 783       expectNotType<Array<ElementHandle<Element>>>(
 784         await handle.$$('div > a:pseudo-class'),
 785       );
 786     }
 787     {
 788       expectType<Array<ElementHandle<HTMLAnchorElement>>>(
 789         await handle.$$('div > a:func(arg)'),
 790       );
 791       expectNotType<Array<ElementHandle<Element>>>(
 792         await handle.$$('div > a:func(arg)'),
 793       );
 794     }
 795   }
 796   {
 797     {
 798       expectType<Array<ElementHandle<HTMLDivElement>>>(
 799         await handle.$$('div > div'),
 800       );
 801       expectNotType<Array<ElementHandle<Element>>>(
 802         await handle.$$('div > div'),
 803       );
 804     }
 805     {
 806       expectType<Array<ElementHandle<HTMLDivElement>>>(
 807         await handle.$$('div > div#id'),
 808       );
 809       expectNotType<Array<ElementHandle<Element>>>(
 810         await handle.$$('div > div#id'),
 811       );
 812     }
 813     {
 814       expectType<Array<ElementHandle<HTMLDivElement>>>(
 815         await handle.$$('div > div.class'),
 816       );
 817       expectNotType<Array<ElementHandle<Element>>>(
 818         await handle.$$('div > div.class'),
 819       );
 820     }
 821     {
 822       expectType<Array<ElementHandle<HTMLDivElement>>>(
 823         await handle.$$('div > div[attr=value]'),
 824       );
 825       expectNotType<Array<ElementHandle<Element>>>(
 826         await handle.$$('div > div[attr=value]'),
 827       );
 828     }
 829     {
 830       expectType<Array<ElementHandle<HTMLDivElement>>>(
 831         await handle.$$('div > div:psuedo-class'),
 832       );
 833       expectNotType<Array<ElementHandle<Element>>>(
 834         await handle.$$('div > div:pseudo-class'),
 835       );
 836     }
 837     {
 838       expectType<Array<ElementHandle<HTMLDivElement>>>(
 839         await handle.$$('div > div:func(arg)'),
 840       );
 841       expectNotType<Array<ElementHandle<Element>>>(
 842         await handle.$$('div > div:func(arg)'),
 843       );
 844     }
 845   }
 846   {
 847     {
 848       expectType<Array<ElementHandle<Element>>>(
 849         await handle.$$('div > some-custom'),
 850       );
 851     }
 852     {
 853       expectType<Array<ElementHandle<Element>>>(
 854         await handle.$$('div > some-custom#id'),
 855       );
 856     }
 857     {
 858       expectType<Array<ElementHandle<Element>>>(
 859         await handle.$$('div > some-custom.class'),
 860       );
 861     }
 862     {
 863       expectType<Array<ElementHandle<Element>>>(
 864         await handle.$$('div > some-custom[attr=value]'),
 865       );
 866     }
 867     {
 868       expectType<Array<ElementHandle<Element>>>(
 869         await handle.$$('div > some-custom:pseudo-class'),
 870       );
 871     }
 872     {
 873       expectType<Array<ElementHandle<Element>>>(
 874         await handle.$$('div > some-custom:func(arg)'),
 875       );
 876     }
 877   }
 878   {
 879     {
 880       expectType<Array<ElementHandle<Element>>>(await handle.$$('div > #id'));
 881     }
 882     {
 883       expectType<Array<ElementHandle<Element>>>(
 884         await handle.$$('div > .class'),
 885       );
 886     }
 887     {
 888       expectType<Array<ElementHandle<Element>>>(
 889         await handle.$$('div > [attr=value]'),
 890       );
 891     }
 892     {
 893       expectType<Array<ElementHandle<Element>>>(
 894         await handle.$$('div > :pseudo-class'),
 895       );
 896     }
 897     {
 898       expectType<Array<ElementHandle<Element>>>(
 899         await handle.$$('div > :func(arg)'),
 900       );
 901     }
 902   }
 903 }
 904
 905 {
 906   expectType<void>(
 907     await handle.$eval(
 908       'a',
 909       (element, int) => {
 910         expectType<HTMLAnchorElement>(element);
 911         expectType<number>(int);
 912       },
 913       1,
 914     ),
 915   );
 916   expectType<void>(
 917     await handle.$eval(
 918       'div',
 919       (element, int, str) => {
 920         expectType<HTMLDivElement>(element);
 921         expectType<number>(int);
 922         expectType<string>(str);
 923       },
 924       1,
 925       '',
 926     ),
 927   );
 928   expectType<number>(
 929     await handle.$eval(
 930       'a',
 931       (element, value) => {
 932         expectType<HTMLAnchorElement>(element);
 933         return value;
 934       },
 935       1,
 936     ),
 937   );
 938   expectType<number>(
 939     await handle.$eval(
 940       'some-element',
 941       (element, value) => {
 942         expectType<Element>(element);
 943         return value;
 944       },
 945       1,
 946     ),
 947   );
 948   expectType<HTMLAnchorElement>(
 949     await handle.$eval('a', element => {
 950       return element;
 951     }),
 952   );
 953   expectType<unknown>(await handle.$eval('a', 'document'));
 954 }
 955
 956 {
 957   expectType<void>(
 958     await handle.$$eval(
 959       'a',
 960       (elements, int) => {
 961         expectType<HTMLAnchorElement[]>(elements);
 962         expectType<number>(int);
 963       },
 964       1,
 965     ),
 966   );
 967   expectType<void>(
 968     await handle.$$eval(
 969       'div',
 970       (elements, int, str) => {
 971         expectType<HTMLDivElement[]>(elements);
 972         expectType<number>(int);
 973         expectType<string>(str);
 974       },
 975       1,
 976       '',
 977     ),
 978   );
 979   expectType<number>(
 980     await handle.$$eval(
 981       'a',
 982       (elements, value) => {
 983         expectType<HTMLAnchorElement[]>(elements);
 984         return value;
 985       },
 986       1,
 987     ),
 988   );
 989   expectType<number>(
 990     await handle.$$eval(
 991       'some-element',
 992       (elements, value) => {
 993         expectType<Element[]>(elements);
 994         return value;
 995       },
 996       1,
 997     ),
 998   );
 999   expectType<HTMLAnchorElement[]>(
1000     await handle.$$eval('a', elements => {
1001       return elements;
1002     }),
1003   );
1004   expectType<unknown>(await handle.$$eval('a', 'document'));
1005 }
1006
1007 {
1008   {
1009     expectType<ElementHandle<HTMLAnchorElement> | null>(
1010       await handle.waitForSelector('a'),
1011     );
1012     expectNotType<ElementHandle<Element> | null>(
1013       await handle.waitForSelector('a'),
1014     );
1015   }
1016   {
1017     expectType<ElementHandle<HTMLDivElement> | null>(
1018       await handle.waitForSelector('div'),
1019     );
1020     expectNotType<ElementHandle<Element> | null>(
1021       await handle.waitForSelector('div'),
1022     );
1023   }
1024   {
1025     expectType<ElementHandle<Element> | null>(
1026       await handle.waitForSelector('some-custom'),
1027     );
1028   }
1029 }