Selenium WebDriver

const { Builder, By, Key, until } = require('selenium-webdriver');

import { Builder, By, Key, until } from 'selenium-webdriver';

const { Builder, By, Key, until } = require('selenium-webdriver');

async function example() {
  // Create a new WebDriver instance
  let driver = await new Builder().forBrowser('chrome').build();
  
  try {
    // Navigate to a website
    await driver.get('https://www.example.com');
    
    // Find an element and interact with it
    let searchBox = await driver.findElement(By.name('q'));
    await searchBox.sendKeys('selenium webdriver', Key.RETURN);
    
    // Wait for results to load and take a screenshot
    await driver.wait(until.titleContains('selenium'), 5000);
    await driver.takeScreenshot();
    
  } finally {
    // Always quit the driver
    await driver.quit();
  }
}

class Builder {
  constructor();
  forBrowser(name: string, version?: string, platform?: string): Builder;
  withCapabilities(capabilities: Capabilities): Builder;
  usingServer(url: string): Builder;
  setChromeOptions(options: chrome.Options): Builder;
  setFirefoxOptions(options: firefox.Options): Builder;
  build(): ThenableWebDriver;
}

class By {
  static id(id: string): By;
  static css(selector: string): By;
  static xpath(xpath: string): By;
  static name(name: string): By;
  static className(name: string): By;
  static linkText(text: string): By;
  static partialLinkText(text: string): By;
  static tagName(name: string): By;
}

class WebDriver {
  get(url: string): Promise<void>;
  getCurrentUrl(): Promise<string>;
  getTitle(): Promise<string>;
  findElement(locator: By): Promise<WebElement>;
  findElements(locator: By): Promise<WebElement[]>;
  executeScript(script: string | Function, ...args: any[]): Promise<any>;
  takeScreenshot(): Promise<string>;
  actions(options?: object): Actions;
  quit(): Promise<void>;
}

class WebElement {
  click(): Promise<void>;
  sendKeys(...keys: (string | number)[]): Promise<void>;
  getText(): Promise<string>;
  getAttribute(name: string): Promise<string>;
  isDisplayed(): Promise<boolean>;
  isEnabled(): Promise<boolean>;
  isSelected(): Promise<boolean>;
}

function titleIs(title: string): Condition<boolean>;
function titleContains(substr: string): Condition<boolean>;
function elementLocated(locator: By): Condition<WebElement>;
function elementIsVisible(elementOrLocator: WebElement | By): Condition<WebElement>;
function elementIsClickable(elementOrLocator: WebElement | By): Condition<WebElement>;
function elementTextContains(elementOrLocator: WebElement | By, text: string): Condition<boolean>;

// Chrome
class chrome.Options extends Capabilities {
  addArguments(...args: string[]): chrome.Options;
  addExtensions(...paths: string[]): chrome.Options;
  setChromeBinaryPath(path: string): chrome.Options;
  setMobileEmulation(config: object): chrome.Options;
}

// Firefox
class firefox.Options extends Capabilities {
  setBinary(binary: string): firefox.Options;
  setProfile(profile: firefox.Profile): firefox.Options;
  addArguments(...args: string[]): firefox.Options;
  setPreference(key: string, value: any): firefox.Options;
}

class Actions {
  constructor(driver: WebDriver);
  click(element?: WebElement): Actions;
  doubleClick(element?: WebElement): Actions;
  dragAndDrop(source: WebElement, target: WebElement): Actions;
  keyDown(key: string, element?: WebElement): Actions;
  keyUp(key: string, element?: WebElement): Actions;
  move(options: object): Actions;
  perform(): Promise<void>;
}

class Select {
  constructor(element: WebElement);
  selectByIndex(index: number): Promise<void>;
  selectByValue(value: string): Promise<void>;
  selectByVisibleText(text: string): Promise<void>;
  getOptions(): Promise<WebElement[]>;
}

class WebDriverError extends Error {}
class NoSuchElementError extends WebDriverError {}
class ElementNotInteractableError extends WebDriverError {}
class TimeoutError extends WebDriverError {}
class StaleElementReferenceError extends WebDriverError {}
class InvalidSelectorError extends WebDriverError {}

class BrowsingContext {
  create(type: string, options?: object): Promise<BrowsingContext>;
  navigate(url: string, wait?: string): Promise<NavigateResult>;
  captureScreenshot(options?: object): Promise<string>;
  locateElement(locator: Locator): Promise<WebElement>;
  printPage(options?: object): Promise<PrintResult>;
}

class LogInspector {
  constructor(driver: WebDriver);
  onLog(callback: (logEntry: object) => void): Promise<void>;
}

interface Capabilities {
  get(key: string): any;
  set(key: string, value: any): void;
  has(key: string): boolean;
  merge(other: Capabilities): Capabilities;
}

interface Condition<T> {
  description(): string;
}

interface ThenableWebDriver extends WebDriver {
  then<TResult1, TResult2>(
    onfulfilled?: ((value: WebDriver) => TResult1 | PromiseLike<TResult1>) | null,
    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null
  ): Promise<TResult1 | TResult2>;
}

interface Session {
  getId(): string;
  getCapabilities(): Capabilities;
}

interface Rectangle {
  x: number;
  y: number;
  width: number;
  height: number;
}

interface WebElementCondition extends Condition<WebElement> {}

interface WebElementPromise extends Promise<WebElement>, WebElement {}

interface FileDetector {
  handleFile(driver: WebDriver, path: string): Promise<string>;
}

interface RelativeBy extends By {
  above(locator: By | WebElement): RelativeBy;
  below(locator: By | WebElement): RelativeBy;
  toLeftOf(locator: By | WebElement): RelativeBy;
  toRightOf(locator: By | WebElement): RelativeBy;
  near(locator: By | WebElement): RelativeBy;
}

interface Executor {
  execute(command: Command): Promise<any>;
}

interface ScriptManager {
  addPreloadScript(script: string): Promise<string>;
  removePreloadScript(script: string): Promise<void>;
}

interface NetworkManager {
  addIntercept(phases: string[], urlPatterns?: string[]): Promise<string>;
  removeIntercept(intercept: string): Promise<void>;
  continueRequest(request: string, body?: object): Promise<void>;
}

const Key = {
  RETURN: '\\uE006',
  ENTER: '\\uE007',
  TAB: '\\uE004',
  ESCAPE: '\\uE00C',
  SPACE: '\\uE00D',
  ARROW_UP: '\\uE013',
  ARROW_DOWN: '\\uE015',
  ARROW_LEFT: '\\uE012',
  ARROW_RIGHT: '\\uE014'
};

const Browser = {
  CHROME: 'chrome',
  FIREFOX: 'firefox',
  SAFARI: 'safari',  
  EDGE: 'MicrosoftEdge',
  INTERNET_EXPLORER: 'internet explorer'
};

const Button = {
  LEFT: 0,
  MIDDLE: 1, 
  RIGHT: 2
};

const Origin = {
  VIEWPORT: 'viewport',
  POINTER: 'pointer'
};

const Capability = {
  BROWSER_NAME: 'browserName',
  BROWSER_VERSION: 'browserVersion',
  PLATFORM_NAME: 'platformName',
  ACCEPT_INSECURE_CERTS: 'acceptInsecureCerts',
  PAGE_LOAD_STRATEGY: 'pageLoadStrategy',
  PROXY: 'proxy',
  SET_WINDOW_RECT: 'setWindowRect',
  TIMEOUTS: 'timeouts',
  UNHANDLED_PROMPT_BEHAVIOR: 'unhandledPromptBehavior'
};