// Type definitions for Selenium WebDriverJS 2.39.0 // Project: https://code.google.com/p/selenium/ // Definitions by: Bill Armstrong // Definitions: https://github.com/borisyankov/DefinitelyTyped declare module webdriver { module logging { /** * A hash describing log preferences. * @typedef {Object.} */ var Preferences: any; /** * Log level names from WebDriver's JSON wire protocol. * @enum {string} */ class LevelName { static ALL: string; static DEBUG: string; static INFO: string; static WARNING: string; static SEVERE: string; static OFF: string; } /** * Common log types. * @enum {string} */ class Type { /** Logs originating from the browser. */ static BROWSER: string; /** Logs from a WebDriver client. */ static CLIENT: string; /** Logs from a WebDriver implementation. */ static DRIVER: string; /** Logs related to performance. */ static PERFORMANCE: string; /** Logs from the remote server. */ static SERVER: string; } /** * Logging levels. * @enum {{value: number, name: webdriver.logging.LevelName}} */ class Level { //region Static Properties static ALL: Level; static DEBUG: Level; static INFO: Level; static WARNING: Level; static SEVERE: Level; static OFF: Level; //endregion //region Properties value: number; name: string; //endregion } /** * Converts a level name or value to a {@link webdriver.logging.Level} value. * If the name/value is not recognized, {@link webdriver.logging.Level.ALL} * will be returned. * @param {(number|string)} nameOrValue The log level name, or value, to * convert . * @return {!webdriver.logging.Level} The converted level. */ function getLevel(nameOrValue: string): webdriver.logging.Level; function getLevel(nameOrValue: number): webdriver.logging.Level; /** * A single log entry. */ class Entry { //region Constructors /** * @param {(!webdriver.logging.Level|string)} level The entry level. * @param {string} message The log message. * @param {number=} opt_timestamp The time this entry was generated, in * milliseconds since 0:00:00, January 1, 1970 UTC. If omitted, the * current time will be used. * @param {string=} opt_type The log type, if known. * @constructor */ constructor(level: webdriver.logging.Level, message: string, opt_timestamp?:number, opt_type?:string); constructor(level: string, message: string, opt_timestamp?:number, opt_type?:string); //endregion //region Public Properties /** @type {!webdriver.logging.Level} */ level: webdriver.logging.Level; /** @type {string} */ message: string; /** @type {number} */ timestamp: number; /** @type {string} */ type: string; //endregion //region Static Methods /** * Converts a {@link goog.debug.LogRecord} into a * {@link webdriver.logging.Entry}. * @param {!goog.debug.LogRecord} logRecord The record to convert. * @param {string=} opt_type The log type. * @return {!webdriver.logging.Entry} The converted entry. */ static fromClosureLogRecord(logRecord: any, opt_type?:string): webdriver.logging.Entry; //endregion //region Methods /** * @return {{level: string, message: string, timestamp: number, * type: string}} The JSON representation of this entry. */ toJSON(): webdriver.logging.Level; //endregion } } module promise { //region Functions /** * @return {!webdriver.promise.ControlFlow} The currently active control flow. */ function controlFlow(): webdriver.promise.ControlFlow; /** * Creates a new control flow. The provided callback will be invoked as the * first task within the new flow, with the flow as its sole argument. Returns * a promise that resolves to the callback result. * @param {function(!webdriver.promise.ControlFlow)} callback The entry point * to the newly created flow. * @return {!webdriver.promise.Promise} A promise that resolves to the callback * result. */ function createFlow(callback: (flow: webdriver.promise.ControlFlow) => any): webdriver.promise.Promise; /** * Determines whether a {@code value} should be treated as a promise. * Any object whose "then" property is a function will be considered a promise. * * @param {*} value The value to test. * @return {boolean} Whether the value is a promise. */ function isPromise(value: any): boolean; /** * Creates a promise that will be resolved at a set time in the future. * @param {number} ms The amount of time, in milliseconds, to wait before * resolving the promise. * @return {!webdriver.promise.Promise} The promise. */ function delayed(ms: number): webdriver.promise.Promise; /** * Creates a new deferred object. * @param {Function=} opt_canceller Function to call when cancelling the * computation of this instance's value. * @return {!webdriver.promise.Deferred} The new deferred object. */ function defer(opt_canceller?: any): webdriver.promise.Deferred; /** * Creates a promise that has been resolved with the given value. * @param {*=} opt_value The resolved value. * @return {!webdriver.promise.Promise} The resolved promise. */ function fulfilled(opt_value?: any): webdriver.promise.Promise; /** * Creates a promise that has been rejected with the given reason. * @param {*=} opt_reason The rejection reason; may be any value, but is * usually an Error or a string. * @return {!webdriver.promise.Promise} The rejected promise. */ function rejected(opt_reason?: any): webdriver.promise.Promise; /** * Wraps a function that is assumed to be a node-style callback as its final * argument. This callback takes two arguments: an error value (which will be * null if the call succeeded), and the success value as the second argument. * If the call fails, the returned promise will be rejected, otherwise it will * be resolved with the result. * @param {!Function} fn The function to wrap. * @return {!webdriver.promise.Promise} A promise that will be resolved with the * result of the provided function's callback. */ function checkedNodeCall(fn: (error: any, value: any) => any): webdriver.promise.Promise; /** * Registers an observer on a promised {@code value}, returning a new promise * that will be resolved when the value is. If {@code value} is not a promise, * then the return promise will be immediately resolved. * @param {*} value The value to observe. * @param {Function=} opt_callback The function to call when the value is * resolved successfully. * @param {Function=} opt_errback The function to call when the value is * rejected. * @return {!webdriver.promise.Promise} A new promise. */ function when(value: any, opt_callback?: (value: any) => any, opt_errback?: (error: any) => any): webdriver.promise.Promise; /** * Invokes the appropriate callback function as soon as a promised * {@code value} is resolved. This function is similar to * {@code webdriver.promise.when}, except it does not return a new promise. * @param {*} value The value to observe. * @param {Function} callback The function to call when the value is * resolved successfully. * @param {Function=} opt_errback The function to call when the value is * rejected. */ function asap(value: any, callback: (value: any) => any, opt_errback?: (error: any) => any): void; /** * Returns a promise that will be resolved with the input value in a * fully-resolved state. If the value is an array, each element will be fully * resolved. Likewise, if the value is an object, all keys will be fully * resolved. In both cases, all nested arrays and objects will also be * fully resolved. All fields are resolved in place; the returned promise will * resolve on {@code value} and not a copy. * * Warning: This function makes no checks against objects that contain * cyclical references: * * var value = {}; * value['self'] = value; * webdriver.promise.fullyResolved(value); // Stack overflow. * * @param {*} value The value to fully resolve. * @return {!webdriver.promise.Promise} A promise for a fully resolved version * of the input value. */ function fullyResolved(value: any): webdriver.promise.Promise; /** * Changes the default flow to use when no others are active. * @param {!webdriver.promise.ControlFlow} flow The new default flow. * @throws {Error} If the default flow is not currently active. */ function setDefaultFlow(flow: webdriver.promise.ControlFlow): void; //endregion /** * Represents the eventual value of a completed operation. Each promise may be * in one of three states: pending, resolved, or rejected. Each promise starts * in the pending state and may make a single transition to either a * fulfilled or failed state. * *

This class is based on the Promise/A proposal from CommonJS. Additional * functions are provided for API compatibility with Dojo Deferred objects. * * @see http://wiki.commonjs.org/wiki/Promises/A */ class Promise { //region Constructors /** * @constructor * @see http://wiki.commonjs.org/wiki/Promises/A */ constructor(); //endregion //region Methods /** * Cancels the computation of this promise's value, rejecting the promise in the * process. * @param {*} reason The reason this promise is being cancelled. If not an * {@code Error}, one will be created using the value's string * representation. */ cancel(reason: any): void; /** @return {boolean} Whether this promise's value is still being computed. */ isPending(): boolean; /** * Registers listeners for when this instance is resolved. This function most * overridden by subtypes. * * @param {Function=} opt_callback The function to call if this promise is * successfully resolved. The function should expect a single argument: the * promise's resolved value. * @param {Function=} opt_errback The function to call if this promise is * rejected. The function should expect a single argument: the rejection * reason. * @return {!webdriver.promise.Promise} A new promise which will be resolved * with the result of the invoked callback. */ then(opt_callback?: (value: any) => any, opt_errback?: (error: any) => any): Promise; /** * Registers a function to be invoked when this promise is successfully * resolved. This function is provided for backwards compatibility with the * Dojo Deferred API. * * @param {Function} callback The function to call if this promise is * successfully resolved. The function should expect a single argument: the * promise's resolved value. * @param {!Object=} opt_self The object which |this| should refer to when the * function is invoked. * @return {!webdriver.promise.Promise} A new promise which will be resolved * with the result of the invoked callback. */ addCallback(callback: (value: any) => any, opt_self?: any): Promise; /** * Registers a function to be invoked when this promise is rejected. * This function is provided for backwards compatibility with the * Dojo Deferred API. * * @param {Function} errback The function to call if this promise is * rejected. The function should expect a single argument: the rejection * reason. * @param {!Object=} opt_self The object which |this| should refer to when the * function is invoked. * @return {!webdriver.promise.Promise} A new promise which will be resolved * with the result of the invoked callback. */ addErrback(errback: (error: any) => any, opt_self?: any): Promise; /** * Registers a function to be invoked when this promise is either rejected or * resolved. This function is provided for backwards compatibility with the * Dojo Deferred API. * * @param {Function} callback The function to call when this promise is * either resolved or rejected. The function should expect a single * argument: the resolved value or rejection error. * @param {!Object=} opt_self The object which |this| should refer to when the * function is invoked. * @return {!webdriver.promise.Promise} A new promise which will be resolved * with the result of the invoked callback. */ addBoth(callback : (value: any) => any, opt_self?: any): Promise; /** * An alias for {@code webdriver.promise.Promise.prototype.then} that permits * the scope of the invoked function to be specified. This function is provided * for backwards compatibility with the Dojo Deferred API. * * @param {Function} callback The function to call if this promise is * successfully resolved. The function should expect a single argument: the * promise's resolved value. * @param {Function} errback The function to call if this promise is * rejected. The function should expect a single argument: the rejection * reason. * @param {!Object=} opt_self The object which |this| should refer to when the * function is invoked. * @return {!webdriver.promise.Promise} A new promise which will be resolved * with the result of the invoked callback. */ addCallbacks(callback: (value: any) => any, errback: (error: any) => any, opt_self?: any): Promise; //endregion } /** * Represents a value that will be resolved at some point in the future. This * class represents the protected "producer" half of a Promise - each Deferred * has a {@code promise} property that may be returned to consumers for * registering callbacks, reserving the ability to resolve the deferred to the * producer. * *

If this Deferred is rejected and there are no listeners registered before * the next turn of the event loop, the rejection will be passed to the * {@link webdriver.promise.ControlFlow} as an unhandled failure. * *

If this Deferred is cancelled, the cancellation reason will be forward to * the Deferred's canceller function (if provided). The canceller may return a * truth-y value to override the reason provided for rejection. * * @extends {webdriver.promise.Promise} */ class Deferred extends Promise { //region Constructors /** * * @param {Function=} opt_canceller Function to call when cancelling the * computation of this instance's value. * @param {webdriver.promise.ControlFlow=} opt_flow The control flow * this instance was created under. This should only be provided during * unit tests. * @constructor */ constructor(opt_canceller?: any, opt_flow?: webdriver.promise.ControlFlow); //endregion //region Properties /** * The consumer promise for this instance. Provides protected access to the * callback registering functions. * @type {!webdriver.promise.Promise} */ promise: webdriver.promise.Promise; //endregion //region Methods /** * Rejects this promise. If the error is itself a promise, this instance will * be chained to it and be rejected with the error's resolved value. * @param {*=} opt_error The rejection reason, typically either a * {@code Error} or a {@code string}. */ reject(opt_error?: any): void; errback(opt_error?: any): void; /** * Resolves this promise with the given value. If the value is itself a * promise and not a reference to this deferred, this instance will wait for * it before resolving. * @param {*=} opt_value The resolved value. */ fulfill(opt_value?: any): void; /** * Cancels the computation of this promise's value and flags the promise as a * rejected value. * @param {*=} opt_reason The reason for cancelling this promise. */ cancel(opt_reason?: any): void; /** * Removes all of the listeners previously registered on this deferred. * @throws {Error} If this deferred has already been resolved. */ removeAll(): void; //endregion } interface IControlFlowTimer { clearInterval: (ms: number) => void; clearTimeout: (ms: number) => void; setInterval: (fn: any, ms: number) => number; setTimeout: (fn: any, ms: number) => number; } /** * Handles the execution of scheduled tasks, each of which may be an * asynchronous operation. The control flow will ensure tasks are executed in * the ordered scheduled, starting each task only once those before it have * completed. * *

Each task scheduled within this flow may return a * {@link webdriver.promise.Promise} to indicate it is an asynchronous * operation. The ControlFlow will wait for such promises to be resolved before * marking the task as completed. * *

Tasks and each callback registered on a {@link webdriver.promise.Deferred} * will be run in their own ControlFlow frame. Any tasks scheduled within a * frame will have priority over previously scheduled tasks. Furthermore, if * any of the tasks in the frame fails, the remainder of the tasks in that frame * will be discarded and the failure will be propagated to the user through the * callback/task's promised result. * *

Each time a ControlFlow empties its task queue, it will fire an * {@link webdriver.promise.ControlFlow.EventType.IDLE} event. Conversely, * whenever the flow terminates due to an unhandled error, it will remove all * remaining tasks in its queue and fire an * {@link webdriver.promise.ControlFlow.EventType.UNCAUGHT_EXCEPTION} event. If * there are no listeners registered with the flow, the error will be * rethrown to the global error handler. * * @extends {webdriver.EventEmitter} */ class ControlFlow extends webdriver.EventEmitter { //region Constructors /** * @param {webdriver.promise.ControlFlow.Timer=} opt_timer The timer object * to use. Should only be set for testing. * @constructor */ constructor(opt_timer?: webdriver.promise.IControlFlowTimer); //endregion //region Properties /** * The timer used by this instance. * @type {webdriver.promise.ControlFlow.Timer} */ timer: webdriver.promise.IControlFlowTimer; //endregion //region Static Properties /** * The default timer object, which uses the global timer functions. * @type {webdriver.promise.ControlFlow.Timer} */ static defaultTimer: webdriver.promise.IControlFlowTimer; /** * Events that may be emitted by an {@link webdriver.promise.ControlFlow}. * @enum {string} */ static EventType: { /** Emitted when all tasks have been successfully executed. */ IDLE: string; /** Emitted whenever a new task has been scheduled. */ SCHEDULE_TASK: string; /** * Emitted whenever a control flow aborts due to an unhandled promise * rejection. This event will be emitted along with the offending rejection * reason. Upon emitting this event, the control flow will empty its task * queue and revert to its initial state. */ UNCAUGHT_EXCEPTION: string; }; /** * How often, in milliseconds, the event loop should run. * @type {number} * @const */ static EVENT_LOOP_FREQUENCY: number; //endregion //region Methods /** * Resets this instance, clearing its queue and removing all event listeners. */ reset(): void; /** * Returns a summary of the recent task activity for this instance. This * includes the most recently completed task, as well as any parent tasks. In * the returned summary, the task at index N is considered a sub-task of the * task at index N+1. * @return {!Array.} A summary of this instance's recent task * activity. */ getHistory(): string[]; /** Clears this instance's task history. */ clearHistory(): void; /** * Appends a summary of this instance's recent task history to the given * error's stack trace. This function will also ensure the error's stack trace * is in canonical form. * @param {!(Error|goog.testing.JsUnitException)} e The error to annotate. * @return {!(Error|goog.testing.JsUnitException)} The annotated error. */ annotateError(e: any): any; /** * @return {string} The scheduled tasks still pending with this instance. */ getSchedule(): string; /** * Schedules a task for execution. If there is nothing currently in the * queue, the task will be executed in the next turn of the event loop. * * @param {!Function} fn The function to call to start the task. If the * function returns a {@link webdriver.promise.Promise}, this instance * will wait for it to be resolved before starting the next task. * @param {string=} opt_description A description of the task. * @return {!webdriver.promise.Promise} A promise that will be resolved with * the result of the action. */ execute(fn: any, opt_description?: string): webdriver.promise.Promise; /** * Inserts a {@code setTimeout} into the command queue. This is equivalent to * a thread sleep in a synchronous programming language. * * @param {number} ms The timeout delay, in milliseconds. * @param {string=} opt_description A description to accompany the timeout. * @return {!webdriver.promise.Promise} A promise that will be resolved with * the result of the action. */ timeout(ms: number, opt_description?: string): webdriver.promise.Promise; /** * Schedules a task that shall wait for a condition to hold. Each condition * function may return any value, but it will always be evaluated as a boolean. * *

Condition functions may schedule sub-tasks with this instance, however, * their execution time will be factored into whether a wait has timed out. * *

In the event a condition returns a Promise, the polling loop will wait for * it to be resolved before evaluating whether the condition has been satisfied. * The resolution time for a promise is factored into whether a wait has timed * out. * *

If the condition function throws, or returns a rejected promise, the * wait task will fail. * * @param {!Function} condition The condition function to poll. * @param {number} timeout How long to wait, in milliseconds, for the condition * to hold before timing out. * @param {string=} opt_message An optional error message to include if the * wait times out; defaults to the empty string. * @return {!webdriver.promise.Promise} A promise that will be resolved when the * condition has been satisified. The promise shall be rejected if the wait * times out waiting for the condition. */ wait(condition: any, timeout: number, opt_message?: string): webdriver.promise.Promise; /** * Schedules a task that will wait for another promise to resolve. The resolved * promise's value will be returned as the task result. * @param {!webdriver.promise.Promise} promise The promise to wait on. * @return {!webdriver.promise.Promise} A promise that will resolve when the * task has completed. */ await(promise: webdriver.promise.Promise): webdriver.promise.Promise; //endregion } } module error { // NOTE: A class was used instead of an Enum so that it could be extended in Protractor. class ErrorCode { static SUCCESS: number; static NO_SUCH_ELEMENT: number; static NO_SUCH_FRAME: number; static UNKNOWN_COMMAND: number; static UNSUPPORTED_OPERATION: number; // Alias for UNKNOWN_COMMAND. static STALE_ELEMENT_REFERENCE: number; static ELEMENT_NOT_VISIBLE: number; static INVALID_ELEMENT_STATE: number; static UNKNOWN_ERROR: number; static ELEMENT_NOT_SELECTABLE: number; static JAVASCRIPT_ERROR: number; static XPATH_LOOKUP_ERROR: number; static TIMEOUT: number; static NO_SUCH_WINDOW: number; static INVALID_COOKIE_DOMAIN: number; static UNABLE_TO_SET_COOKIE: number; static MODAL_DIALOG_OPENED: number; static NO_MODAL_DIALOG_OPEN: number; static SCRIPT_TIMEOUT: number; static INVALID_ELEMENT_COORDINATES: number; static IME_NOT_AVAILABLE: number; static IME_ENGINE_ACTIVATION_FAILED: number; static INVALID_SELECTOR_ERROR: number; static SESSION_NOT_CREATED: number; static MOVE_TARGET_OUT_OF_BOUNDS: number; static SQL_DATABASE_ERROR: number; static INVALID_XPATH_SELECTOR: number; static INVALID_XPATH_SELECTOR_RETURN_TYPE: number; // The following error codes are derived straight from HTTP return codes. static METHOD_NOT_ALLOWED: number; } /** * Error extension that includes error status codes from the WebDriver wire * protocol: * http://code.google.com/p/selenium/wiki/JsonWireProtocol#Response_Status_Codes * * @extends {Error} */ class Error { //region Constructors /** * @param {!bot.ErrorCode} code The error's status code. * @param {string=} opt_message Optional error message. * @constructor */ constructor(code: number, opt_message?: string); //endregion //region Static Properties /** * Status strings enumerated in the W3C WebDriver working draft. * @enum {string} * @see http://www.w3.org/TR/webdriver/#status-codes */ static State: { ELEMENT_NOT_SELECTABLE: string; ELEMENT_NOT_VISIBLE: string; IME_ENGINE_ACTIVATION_FAILED: string; IME_NOT_AVAILABLE: string; INVALID_COOKIE_DOMAIN: string; INVALID_ELEMENT_COORDINATES: string; INVALID_ELEMENT_STATE: string; INVALID_SELECTOR: string; JAVASCRIPT_ERROR: string; MOVE_TARGET_OUT_OF_BOUNDS: string; NO_SUCH_ALERT: string; NO_SUCH_DOM: string; NO_SUCH_ELEMENT: string; NO_SUCH_FRAME: string; NO_SUCH_WINDOW: string; SCRIPT_TIMEOUT: string; SESSION_NOT_CREATED: string; STALE_ELEMENT_REFERENCE: string; SUCCESS: string; TIMEOUT: string; UNABLE_TO_SET_COOKIE: string; UNEXPECTED_ALERT_OPEN: string; UNKNOWN_COMMAND: string; UNKNOWN_ERROR: string; UNSUPPORTED_OPERATION: string; } //endregion //region Properties /** * This error's status code. * @type {!bot.ErrorCode} */ code: number; /** @type {string} */ state: string; /** @override */ message: string; /** @override */ name: string; /** @override */ stack: string; /** * Flag used for duck-typing when this code is embedded in a Firefox extension. * This is required since an Error thrown in one component and then reported * to another will fail instanceof checks in the second component. * @type {boolean} */ isAutomationError: boolean; //endregion //region Methods /** @return {string} The string representation of this error. */ toString(): string; //endregion } } module process { /** * Queries for a named environment variable. * @param {string} name The name of the environment variable to look up. * @param {string=} opt_default The default value if the named variable is not * defined. * @return {string} The queried environment variable. */ function getEnv(name: string, opt_default?: string): string; /** * @return {boolean} Whether the current process is Node's native process * object. */ function isNative(): boolean; /** * Sets an environment value. If the new value is either null or undefined, the * environment variable will be cleared. * @param {string} name The value to set. * @param {*} value The new value; will be coerced to a string. */ function setEnv(name: string, value: any): void; } /** * Creates new {@code webdriver.WebDriver} clients. Upon instantiation, each * Builder will configure itself based on the following environment variables: *

*
{@code webdriver.AbstractBuilder.SERVER_URL_ENV}
*
Defines the remote WebDriver server that should be used for command * command execution; may be overridden using * {@code webdriver.AbstractBuilder.prototype.usingServer}.
*
*/ class AbstractBuilder { //region Constructors /** * @constructor */ constructor(); //endregion //region Static Properties /** * Environment variable that defines the URL of the WebDriver server that * should be used for all new WebDriver clients. This setting may be overridden * using {@code #usingServer(url)}. * @type {string} * @const * @see webdriver.process.getEnv */ static SERVER_URL_ENV: string; /** * The default URL of the WebDriver server to use if * {@link webdriver.AbstractBuilder.SERVER_URL_ENV} is not set. * @type {string} * @const */ static DEFAULT_SERVER_URL: string; //endregion //region Methods /** * Configures which WebDriver server should be used for new sessions. Overrides * the value loaded from the {@link webdriver.AbstractBuilder.SERVER_URL_ENV} * upon creation of this instance. * @param {string} url URL of the server to use. * @return {!webdriver.AbstractBuilder} This Builder instance for chain calling. */ usingServer(url: string): AbstractBuilder; /** * @return {string} The URL of the WebDriver server this instance is configured * to use. */ getServerUrl(): string; /** * Sets the desired capabilities when requesting a new session. This will * overwrite any previously set desired capabilities. * @param {!(Object|webdriver.Capabilities)} capabilities The desired * capabilities for a new session. * @return {!webdriver.AbstractBuilder} This Builder instance for chain calling. */ withCapabilities(capabilities: webdriver.Capabilities): AbstractBuilder; withCapabilities(capabilities: any): AbstractBuilder; /** * @return {!webdriver.Capabilities} The current desired capabilities for this * builder. */ getCapabilities(): webdriver.Capabilities; /** * Builds a new {@link webdriver.WebDriver} instance using this builder's * current configuration. * @return {!webdriver.WebDriver} A new WebDriver client. */ build(): webdriver.WebDriver; //endregion } interface ILocation { x: number; y: number; } /** * Enumeration of the buttons used in the advanced interactions API. * NOTE: A TypeScript enum was not used so that this class could be extended in Protractor. * @enum {number} */ class Button { static LEFT: number; static MIDDLE: number; static RIGHT: number; } /** * Representations of pressable keys that aren't text. These are stored in * the Unicode PUA (Private Use Area) code points, 0xE000-0xF8FF. Refer to * http://www.google.com.au/search?&q=unicode+pua&btnG=Search * NOTE: A class was used instead of an Enum so that it could be extended in Protractor * * @enum {string} */ class Key { static NULL: string; static CANCEL: string; // ^break static HELP: string; static BACK_SPACE: string; static TAB: string; static CLEAR: string; static RETURN: string; static ENTER: string; static SHIFT: string; static CONTROL: string; static ALT: string; static PAUSE: string; static ESCAPE: string; static SPACE: string; static PAGE_UP: string; static PAGE_DOWN: string; static END: string; static HOME: string; static ARROW_LEFT: string; static LEFT: string; static ARROW_UP: string; static UP: string; static ARROW_RIGHT: string; static RIGHT: string; static ARROW_DOWN: string; static DOWN: string; static INSERT: string; static DELETE: string; static SEMICOLON: string; static EQUALS: string; static NUMPAD0: string; // number pad keys static NUMPAD1: string; static NUMPAD2: string; static NUMPAD3: string; static NUMPAD4: string; static NUMPAD5: string; static NUMPAD6: string; static NUMPAD7: string; static NUMPAD8: string; static NUMPAD9: string; static MULTIPLY: string; static ADD: string; static SEPARATOR: string; static SUBTRACT: string; static DECIMAL: string; static DIVIDE: string; static F1: string; // function keys static F2: string; static F3: string; static F4: string; static F5: string; static F6: string; static F7: string; static F8: string; static F9: string; static F10: string; static F11: string; static F12: string; static COMMAND: string; // Apple command key static META: string; // alias for Windows key /** * Simulate pressing many keys at once in a "chord". Takes a sequence of * {@link webdriver.Key}s or strings, appends each of the values to a string, * and adds the chord termination key ({@link webdriver.Key.NULL}) and returns * the resultant string. * * Note: when the low-level webdriver key handlers see Keys.NULL, active * modifier keys (CTRL/ALT/SHIFT/etc) release via a keyup event. * * @param {...string} var_args The key sequence to concatenate. * @return {string} The null-terminated key sequence. * @see http://code.google.com/p/webdriver/issues/detail?id=79 */ static chord(...var_args: string[]): string; } /** * Class for defining sequences of complex user interactions. Each sequence * will not be executed until {@link #perform} is called. * *

Example:


     *   new webdriver.ActionSequence(driver).
     *       keyDown(webdriver.Key.SHIFT).
     *       click(element1).
     *       click(element2).
     *       dragAndDrop(element3, element4).
     *       keyUp(webdriver.Key.SHIFT).
     *       perform();
     *
* */ class ActionSequence { //region Constructors /** * @param {!webdriver.WebDriver} driver The driver instance to use. * @constructor */ constructor(driver: webdriver.WebDriver); //endregion //region Methods /** * Executes this action sequence. * @return {!webdriver.promise.Promise} A promise that will be resolved once * this sequence has completed. */ perform(): webdriver.promise.Promise; /** * Moves the mouse. The location to move to may be specified in terms of the * mouse's current location, an offset relative to the top-left corner of an * element, or an element (in which case the middle of the element is used). * @param {(!webdriver.WebElement|{x: number, y: number})} location The * location to drag to, as either another WebElement or an offset in pixels. * @param {{x: number, y: number}=} opt_offset An optional offset, in pixels. * Defaults to (0, 0). * @return {!webdriver.ActionSequence} A self reference. */ mouseMove(location: webdriver.WebElement, opt_offset?: ILocation): ActionSequence mouseMove(location: ILocation): ActionSequence /** * Presses a mouse button. The mouse button will not be released until * {@link #mouseUp} is called, regardless of whether that call is made in this * sequence or another. The behavior for out-of-order events (e.g. mouseDown, * click) is undefined. * *

If an element is provided, the mouse will first be moved to the center * of that element. This is equivalent to: * 

sequence.mouseMove(element).mouseDown()
* *

Warning: this method currently only supports the left mouse button. See * http://code.google.com/p/selenium/issues/detail?id=4047 * * @param {(webdriver.WebElement|webdriver.Button)=} opt_elementOrButton Either * the element to interact with or the button to click with. * Defaults to {@link webdriver.Button.LEFT} if neither an element nor * button is specified. * @param {webdriver.Button=} opt_button The button to use. Defaults to * {@link webdriver.Button.LEFT}. Ignored if a button is provided as the * first argument. * @return {!webdriver.ActionSequence} A self reference. */ mouseDown(opt_elementOrButton?: webdriver.WebElement, opt_button?: number): ActionSequence; mouseDown(opt_elementOrButton?: number): ActionSequence; /** * Releases a mouse button. Behavior is undefined for calling this function * without a previous call to {@link #mouseDown}. * *

If an element is provided, the mouse will first be moved to the center * of that element. This is equivalent to: * 

sequence.mouseMove(element).mouseUp()
* *

Warning: this method currently only supports the left mouse button. See * http://code.google.com/p/selenium/issues/detail?id=4047 * * @param {(webdriver.WebElement|webdriver.Button)=} opt_elementOrButton Either * the element to interact with or the button to click with. * Defaults to {@link webdriver.Button.LEFT} if neither an element nor * button is specified. * @param {webdriver.Button=} opt_button The button to use. Defaults to * {@link webdriver.Button.LEFT}. Ignored if a button is provided as the * first argument. * @return {!webdriver.ActionSequence} A self reference. */ mouseUp(opt_elementOrButton?: webdriver.WebElement, opt_button?: number): ActionSequence; mouseUp(opt_elementOrButton?: number): ActionSequence; /** * Convenience function for performing a "drag and drop" manuever. The target * element may be moved to the location of another element, or by an offset (in * pixels). * @param {!webdriver.WebElement} element The element to drag. * @param {(!webdriver.WebElement|{x: number, y: number})} location The * location to drag to, either as another WebElement or an offset in pixels. * @return {!webdriver.ActionSequence} A self reference. */ dragAndDrop(element: webdriver.WebElement, location: webdriver.WebElement): ActionSequence; dragAndDrop(element: webdriver.WebElement, location: ILocation): ActionSequence; /** * Clicks a mouse button. * *

If an element is provided, the mouse will first be moved to the center * of that element. This is equivalent to: * 

sequence.mouseMove(element).click()
* * @param {(webdriver.WebElement|webdriver.Button)=} opt_elementOrButton Either * the element to interact with or the button to click with. * Defaults to {@link webdriver.Button.LEFT} if neither an element nor * button is specified. * @param {webdriver.Button=} opt_button The button to use. Defaults to * {@link webdriver.Button.LEFT}. Ignored if a button is provided as the * first argument. * @return {!webdriver.ActionSequence} A self reference. */ click(opt_elementOrButton?: webdriver.WebElement, opt_button?: number): ActionSequence; click(opt_elementOrButton?: number): ActionSequence; /** * Double-clicks a mouse button. * *

If an element is provided, the mouse will first be moved to the center of * that element. This is equivalent to: * 

sequence.mouseMove(element).doubleClick()
* *

Warning: this method currently only supports the left mouse button. See * http://code.google.com/p/selenium/issues/detail?id=4047 * * @param {(webdriver.WebElement|webdriver.Button)=} opt_elementOrButton Either * the element to interact with or the button to click with. * Defaults to {@link webdriver.Button.LEFT} if neither an element nor * button is specified. * @param {webdriver.Button=} opt_button The button to use. Defaults to * {@link webdriver.Button.LEFT}. Ignored if a button is provided as the * first argument. * @return {!webdriver.ActionSequence} A self reference. */ doubleClick(opt_elementOrButton?: webdriver.WebElement, opt_button?: number): ActionSequence; doubleClick(opt_elementOrButton?: number): ActionSequence; /** * Performs a modifier key press. The modifier key is not released * until {@link #keyUp} or {@link #sendKeys} is called. The key press will be * targetted at the currently focused element. * @param {!webdriver.Key} key The modifier key to push. Must be one of * {ALT, CONTROL, SHIFT, COMMAND, META}. * @return {!webdriver.ActionSequence} A self reference. * @throws {Error} If the key is not a valid modifier key. */ keyDown(key: string): ActionSequence; /** * Performs a modifier key release. The release is targetted at the currently * focused element. * @param {!webdriver.Key} key The modifier key to release. Must be one of * {ALT, CONTROL, SHIFT, COMMAND, META}. * @return {!webdriver.ActionSequence} A self reference. * @throws {Error} If the key is not a valid modifier key. */ keyUp(key: string): ActionSequence; /** * Simulates typing multiple keys. Each modifier key encountered in the * sequence will not be released until it is encountered again. All key events * will be targetted at the currently focused element. * @param {...(string|!webdriver.Key|!Array.<(string|!webdriver.Key)>)} var_args * The keys to type. * @return {!webdriver.ActionSequence} A self reference. * @throws {Error} If the key is not a valid modifier key. */ sendKeys(...var_args: any[]): ActionSequence; //endregion } /** * Represents a modal dialog such as {@code alert}, {@code confirm}, or * {@code prompt}. Provides functions to retrieve the message displayed with * the alert, accept or dismiss the alert, and set the response text (in the * case of {@code prompt}). * @extends {webdriver.promise.Deferred} */ class Alert extends webdriver.promise.Deferred { //region Constructors /** * @param {!webdriver.WebDriver} driver The driver controlling the browser this * alert is attached to. * @param {!(string|webdriver.promise.Promise)} text Either the message text * displayed with this alert, or a promise that will be resolved to said * text. * @constructor */ constructor(driver: webdriver.WebDriver, text: string); constructor(driver: webdriver.WebDriver, text: webdriver.promise.Promise); //endregion //region Methods /** * Retrieves the message text displayed with this alert. For instance, if the * alert were opened with alert("hello"), then this would return "hello". * @return {!webdriver.promise.Promise} A promise that will be resolved to the * text displayed with this alert. */ getText(): webdriver.promise.Promise; /** * Accepts this alert. * @return {!webdriver.promise.Promise} A promise that will be resolved when * this command has completed. */ accept(): webdriver.promise.Promise; /** * Dismisses this alert. * @return {!webdriver.promise.Promise} A promise that will be resolved when * this command has completed. */ dismiss(): webdriver.promise.Promise; /** * Sets the response text on this alert. This command will return an error if * the underlying alert does not support response text (e.g. window.alert and * window.confirm). * @param {string} text The text to set. * @return {!webdriver.promise.Promise} A promise that will be resolved when * this command has completed. */ sendKeys(text: string): webdriver.promise.Promise; //endregion } /** * An error returned to indicate that there is an unhandled modal dialog on the * current page. * @extends {bot.Error} */ class UnhandledAlertError extends webdriver.error.Error { //region Constructors /** * @param {string} message The error message. * @param {!webdriver.Alert} alert The alert handle. * @constructor */ constructor(message: string, alert: webdriver.Alert); //endregion //region Methods /** * @return {!webdriver.Alert} The open alert. */ getAlert(): webdriver.Alert; //endregion } /** * Recognized browser names. * @enum {string} */ class Browser { static ANDROID: string; static CHROME: string; static FIREFOX: string; static INTERNET_EXPLORER: string; static IPAD: string; static IPHONE: string; static OPERA: string; static PHANTOM_JS: string; static SAFARI: string; static HTMLUNIT: string; } /** * @extends {webdriver.AbstractBuilder} */ class Builder extends AbstractBuilder { //region Constructors /** * @constructor */ constructor(); //endregion //region Static Properties /** * Environment variable that defines the session ID of an existing WebDriver * session to use when creating clients. If set, all new Builder instances will * default to creating clients that use this session. To create a new session, * use {@code #useExistingSession(boolean)}. The use of this environment * variable requires that {@link webdriver.AbstractBuilder.SERVER_URL_ENV} also * be set. * @type {string} * @const * @see webdriver.process.getEnv */ static SESSION_ID_ENV: string; //endregion //region Methods /** * Configures the builder to create a client that will use an existing WebDriver * session. * @param {string} id The existing session ID to use. * @return {!webdriver.AbstractBuilder} This Builder instance for chain calling. */ usingSession(id: string): webdriver.AbstractBuilder; /** * @return {string} The ID of the session, if any, this builder is configured * to reuse. */ getSession(): string; /** * @override */ build(): webdriver.WebDriver; //endregion } /** * Common webdriver capability keys. * @enum {string} */ class Capability { /** * Indicates whether a driver should accept all SSL certs by default. This * capability only applies when requesting a new session. To query whether * a driver can handle insecure SSL certs, see * {@link webdriver.Capability.SECURE_SSL}. */ static ACCEPT_SSL_CERTS: string; /** * The browser name. Common browser names are defined in the * {@link webdriver.Browser} enum. */ static BROWSER_NAME: string; /** * Whether the driver is capable of handling modal alerts (e.g. alert, * confirm, prompt). To define how a driver should handle alerts, * use {@link webdriver.Capability.UNEXPECTED_ALERT_BEHAVIOR}. */ static HANDLES_ALERTS: string; /** * Key for the logging driver logging preferences. */ static LOGGING_PREFS: string; /** * Describes the platform the browser is running on. Will be one of * ANDROID, IOS, LINUX, MAC, UNIX, or WINDOWS. When requesting a * session, ANY may be used to indicate no platform preference (this is * semantically equivalent to omitting the platform capability). */ static PLATFORM: string; /** * Describes the proxy configuration to use for a new WebDriver session. */ static PROXY: string; /** Whether the driver supports changing the brower's orientation. */ static ROTATABLE: string; /** * Whether a driver is only capable of handling secure SSL certs. To request * that a driver accept insecure SSL certs by default, use * {@link webdriver.Capability.ACCEPT_SSL_CERTS}. */ static SECURE_SSL: string; /** Whether the driver supports manipulating the app cache. */ static SUPPORTS_APPLICATION_CACHE: string; /** * Whether the driver supports controlling the browser's internet * connectivity. */ static SUPPORTS_BROWSER_CONNECTION: string; /** Whether the driver supports locating elements with CSS selectors. */ static SUPPORTS_CSS_SELECTORS: string; /** Whether the browser supports JavaScript. */ static SUPPORTS_JAVASCRIPT: string; /** Whether the driver supports controlling the browser's location info. */ static SUPPORTS_LOCATION_CONTEXT: string; /** Whether the driver supports taking screenshots. */ static TAKES_SCREENSHOT: string; /** * Defines how the driver should handle unexpected alerts. The value should * be one of "accept", "dismiss", or "ignore. */ static UNEXPECTED_ALERT_BEHAVIOR: string; /** Defines the browser version. */ static VERSION: string; } class Capabilities { //region Constructors /** * @param {(webdriver.Capabilities|Object)=} opt_other Another set of * capabilities to merge into this instance. * @constructor */ constructor(opt_other?: Capabilities); constructor(opt_other?: any); //endregion //region Methods /** @return {!Object} The JSON representation of this instance. */ toJSON(): any; /** * Merges another set of capabilities into this instance. Any duplicates in * the provided set will override those already set on this instance. * @param {!(webdriver.Capabilities|Object)} other The capabilities to * merge into this instance. * @return {!webdriver.Capabilities} A self reference. */ merge(other: Capabilities): Capabilities; merge(other: any): Capabilities; /** * @param {string} key The capability to set. * @param {*} value The capability value. Capability values must be JSON * serializable. Pass {@code null} to unset the capability. * @return {!webdriver.Capabilities} A self reference. */ set(key: string, value: any): Capabilities; /** * @param {string} key The capability to return. * @return {*} The capability with the given key, or {@code null} if it has * not been set. */ get(key: string): any; /** * @param {string} key The capability to check. * @return {boolean} Whether the specified capability is set. */ has(key: string): boolean; //endregion //region Static Methods /** * @return {!webdriver.Capabilities} A basic set of capabilities for Android. */ static android(): Capabilities; /** * @return {!webdriver.Capabilities} A basic set of capabilities for Chrome. */ static chrome(): Capabilities; /** * @return {!webdriver.Capabilities} A basic set of capabilities for Firefox. */ static firefox(): Capabilities; /** * @return {!webdriver.Capabilities} A basic set of capabilities for * Internet Explorer. */ static ie(): Capabilities; /** * @return {!webdriver.Capabilities} A basic set of capabilities for iPad. */ static ipad(): Capabilities; /** * @return {!webdriver.Capabilities} A basic set of capabilities for iPhone. */ static iphone(): Capabilities; /** * @return {!webdriver.Capabilities} A basic set of capabilities for Opera. */ static opera(): Capabilities; /** * @return {!webdriver.Capabilities} A basic set of capabilities for * PhantomJS. */ static phantomjs(): Capabilities; /** * @return {!webdriver.Capabilities} A basic set of capabilities for Safari. */ static safari(): Capabilities; /** * @return {!webdriver.Capabilities} A basic set of capabilities for HTMLUnit. */ static htmlunit(): Capabilities; /** * @return {!webdriver.Capabilities} A basic set of capabilities for HTMLUnit * with enabled Javascript. */ static htmlunitwithjs(): Capabilities; //endregion } /** * An enumeration of valid command string. * NOTE: A Class was used instead of an Enum so that the class could be extended in Protractor. */ class CommandName { static GET_SERVER_STATUS: string; static NEW_SESSION: string; static GET_SESSIONS: string; static DESCRIBE_SESSION: string; static CLOSE: string; static QUIT: string; static GET_CURRENT_URL: string; static GET: string; static GO_BACK: string; static GO_FORWARD: string; static REFRESH: string; static ADD_COOKIE: string; static GET_COOKIE: string; static GET_ALL_COOKIES: string; static DELETE_COOKIE: string; static DELETE_ALL_COOKIES: string; static GET_ACTIVE_ELEMENT: string; static FIND_ELEMENT: string; static FIND_ELEMENTS: string; static FIND_CHILD_ELEMENT: string; static FIND_CHILD_ELEMENTS: string; static CLEAR_ELEMENT: string; static CLICK_ELEMENT: string; static SEND_KEYS_TO_ELEMENT: string; static SUBMIT_ELEMENT: string; static GET_CURRENT_WINDOW_HANDLE: string; static GET_WINDOW_HANDLES: string; static GET_WINDOW_POSITION: string; static SET_WINDOW_POSITION: string; static GET_WINDOW_SIZE: string; static SET_WINDOW_SIZE: string; static MAXIMIZE_WINDOW: string; static SWITCH_TO_WINDOW: string; static SWITCH_TO_FRAME: string; static GET_PAGE_SOURCE: string; static GET_TITLE: string; static EXECUTE_SCRIPT: string; static EXECUTE_ASYNC_SCRIPT: string; static GET_ELEMENT_TEXT: string; static GET_ELEMENT_TAG_NAME: string; static IS_ELEMENT_SELECTED: string; static IS_ELEMENT_ENABLED: string; static IS_ELEMENT_DISPLAYED: string; static GET_ELEMENT_LOCATION: string; static GET_ELEMENT_LOCATION_IN_VIEW: string; static GET_ELEMENT_SIZE: string; static GET_ELEMENT_ATTRIBUTE: string; static GET_ELEMENT_VALUE_OF_CSS_PROPERTY: string; static ELEMENT_EQUALS: string; static SCREENSHOT: string; static IMPLICITLY_WAIT: string; static SET_SCRIPT_TIMEOUT: string; static SET_TIMEOUT: string; static ACCEPT_ALERT: string; static DISMISS_ALERT: string; static GET_ALERT_TEXT: string; static SET_ALERT_TEXT: string; static EXECUTE_SQL: string; static GET_LOCATION: string; static SET_LOCATION: string; static GET_APP_CACHE: string; static GET_APP_CACHE_STATUS: string; static CLEAR_APP_CACHE: string; static IS_BROWSER_ONLINE: string; static SET_BROWSER_ONLINE: string; static GET_LOCAL_STORAGE_ITEM: string; static GET_LOCAL_STORAGE_KEYS: string; static SET_LOCAL_STORAGE_ITEM: string; static REMOVE_LOCAL_STORAGE_ITEM: string; static CLEAR_LOCAL_STORAGE: string; static GET_LOCAL_STORAGE_SIZE: string; static GET_SESSION_STORAGE_ITEM: string; static GET_SESSION_STORAGE_KEYS: string; static SET_SESSION_STORAGE_ITEM: string; static REMOVE_SESSION_STORAGE_ITEM: string; static CLEAR_SESSION_STORAGE: string; static GET_SESSION_STORAGE_SIZE: string; static SET_SCREEN_ORIENTATION: string; static GET_SCREEN_ORIENTATION: string; // These belong to the Advanced user interactions - an element is // optional for these commands. static CLICK: string; static DOUBLE_CLICK: string; static MOUSE_DOWN: string; static MOUSE_UP: string; static MOVE_TO: string; static SEND_KEYS_TO_ACTIVE_ELEMENT: string; // These belong to the Advanced Touch API static TOUCH_SINGLE_TAP: string; static TOUCH_DOWN: string; static TOUCH_UP: string; static TOUCH_MOVE: string; static TOUCH_SCROLL: string; static TOUCH_DOUBLE_TAP: string; static TOUCH_LONG_PRESS: string; static TOUCH_FLICK: string; static GET_AVAILABLE_LOG_TYPES: string; static GET_LOG: string; static GET_SESSION_LOGS: string; } /** * Describes a command to be executed by the WebDriverJS framework. * @param {!webdriver.CommandName} name The name of this command. * @constructor */ class Command { //region Constructors /** * @param {!webdriver.CommandName} name The name of this command. * @constructor */ constructor(name: string); //endregion //region Methods /** * @return {!webdriver.CommandName} This command's name. */ getName(): string; /** * Sets a parameter to send with this command. * @param {string} name The parameter name. * @param {*} value The parameter value. * @return {!webdriver.Command} A self reference. */ setParameter(name: string, value: any): webdriver.Command; /** * Sets the parameters for this command. * @param {!Object.<*>} parameters The command parameters. * @return {!webdriver.Command} A self reference. */ setParameters(parameters: any): webdriver.Command; /** * Returns a named command parameter. * @param {string} key The parameter key to look up. * @return {*} The parameter value, or undefined if it has not been set. */ getParameter(key: string): any; /** * @return {!Object.<*>} The parameters to send with this command. */ getParameters(): any; //endregion } /** * Handles the execution of {@code webdriver.Command} objects. */ interface CommandExecutor { /** * Executes the given {@code command}. If there is an error executing the * command, the provided callback will be invoked with the offending error. * Otherwise, the callback will be invoked with a null Error and non-null * {@link bot.response.ResponseObject} object. * @param {!webdriver.Command} command The command to execute. * @param {function(Error, !bot.response.ResponseObject=)} callback the function * to invoke when the command response is ready. */ execute(command: webdriver.Command, callback: (error: Error, responseObject: any) => any ): void; } /** * Object that can emit events for others to listen for. This is used instead * of Closure's event system because it is much more light weight. The API is * based on Node's EventEmitters. */ class EventEmitter { //region Constructors /** * @constructor */ constructor(); //endregion //region Methods /** * Fires an event and calls all listeners. * @param {string} type The type of event to emit. * @param {...*} var_args Any arguments to pass to each listener. */ emit(type: string, ...var_args: any[]): void; /** * Returns a mutable list of listeners for a specific type of event. * @param {string} type The type of event to retrieve the listeners for. * @return {!Array.<{fn: !Function, oneshot: boolean, * scope: (Object|undefined)}>} The registered listeners for * the given event type. */ listeners(type: string): Array<{fn: any; oneshot: boolean; scope: any;}>; /** * Registers a listener. * @param {string} type The type of event to listen for. * @param {!Function} listenerFn The function to invoke when the event is fired. * @param {Object=} opt_scope The object in whose scope to invoke the listener. * @return {!webdriver.EventEmitter} A self reference. */ addListener(type: string, listenerFn: any, opt_scope?:any): EventEmitter; /** * Registers a one-time listener which will be called only the first time an * event is emitted, after which it will be removed. * @param {string} type The type of event to listen for. * @param {!Function} listenerFn The function to invoke when the event is fired. * @param {Object=} opt_scope The object in whose scope to invoke the listener. * @return {!webdriver.EventEmitter} A self reference. */ once(type: string, listenerFn: any, opt_scope?: any): EventEmitter; /** * An alias for {@code #addListener()}. * @param {string} type The type of event to listen for. * @param {!Function} listenerFn The function to invoke when the event is fired. * @param {Object=} opt_scope The object in whose scope to invoke the listener. * @return {!webdriver.EventEmitter} A self reference. */ on(type: string, listenerFn: any, opt_scope?:any): EventEmitter; /** * Removes a previously registered event listener. * @param {string} type The type of event to unregister. * @param {!Function} listenerFn The handler function to remove. * @return {!webdriver.EventEmitter} A self reference. */ removeListener(type: string, listenerFn: any): EventEmitter; /** * Removes all listeners for a specific type of event. If no event is * specified, all listeners across all types will be removed. * @param {string=} opt_type The type of event to remove listeners from. * @return {!webdriver.EventEmitter} A self reference. */ removeAllListeners(opt_type?: string): EventEmitter; //endregion } /** * @implements {webdriver.CommandExecutor} */ class FirefoxDomExecutor implements webdriver.CommandExecutor { //region Constructors /** * @constructor */ constructor(); //endregion //region Static Methods /** * @return {boolean} Whether the current environment supports the * FirefoxDomExecutor. */ static isAvailable(): boolean; //endretion //region Methods /** @override */ execute(command: webdriver.Command, callback: (error: Error, responseObject: any) => any ): void; //endregion } /** * Interface for navigating back and forth in the browser history. */ class WebDriverNavigation { //region Constructors /** * @param {!webdriver.WebDriver} driver The parent driver. * @constructor */ constructor(driver: webdriver.WebDriver); //endregion //region Methods /** * Schedules a command to navigate to a new URL. * @param {string} url The URL to navigate to. * @return {!webdriver.promise.Promise} A promise that will be resolved when the * URL has been loaded. */ to(url: string): webdriver.promise.Promise; /** * Schedules a command to move backwards in the browser history. * @return {!webdriver.promise.Promise} A promise that will be resolved when the * navigation event has completed. */ back(): webdriver.promise.Promise; /** * Schedules a command to move forwards in the browser history. * @return {!webdriver.promise.Promise} A promise that will be resolved when the * navigation event has completed. */ forward(): webdriver.promise.Promise; /** * Schedules a command to refresh the current page. * @return {!webdriver.promise.Promise} A promise that will be resolved when the * navigation event has completed. */ refresh(): webdriver.promise.Promise; //endregion } /** * Provides methods for managing browser and driver state. */ class WebDriverOptions { //region Constructors /** * @param {!webdriver.WebDriver} driver The parent driver. * @constructor */ constructor(driver: webdriver.WebDriver); //endregion //region Methods /** * Schedules a command to add a cookie. * @param {string} name The cookie name. * @param {string} value The cookie value. * @param {string=} opt_path The cookie path. * @param {string=} opt_domain The cookie domain. * @param {boolean=} opt_isSecure Whether the cookie is secure. * @param {(number|!Date)=} opt_expiry When the cookie expires. If specified as * a number, should be in milliseconds since midnight, January 1, 1970 UTC. * @return {!webdriver.promise.Promise} A promise that will be resolved when the * cookie has been added to the page. */ addCookie(name: string, value: string, opt_path?: string, opt_domain?: string, opt_isSecure?: boolean, opt_expiry?: number): webdriver.promise.Promise; addCookie(name: string, value: string, opt_path?: string, opt_domain?: string, opt_isSecure?: boolean, opt_expiry?: Date): webdriver.promise.Promise; /** * Schedules a command to delete all cookies visible to the current page. * @return {!webdriver.promise.Promise} A promise that will be resolved when all * cookies have been deleted. */ deleteAllCookies(): webdriver.promise.Promise; /** * Schedules a command to delete the cookie with the given name. This command is * a no-op if there is no cookie with the given name visible to the current * page. * @param {string} name The name of the cookie to delete. * @return {!webdriver.promise.Promise} A promise that will be resolved when the * cookie has been deleted. */ deleteCookie(name: string): webdriver.promise.Promise; /** * Schedules a command to retrieve all cookies visible to the current page. * Each cookie will be returned as a JSON object as described by the WebDriver * wire protocol. * @return {!webdriver.promise.Promise} A promise that will be resolved with the * cookies visible to the current page. * @see http://code.google.com/p/selenium/wiki/JsonWireProtocol#Cookie_JSON_Object */ getCookies(): webdriver.promise.Promise; /** * Schedules a command to retrieve the cookie with the given name. Returns null * if there is no such cookie. The cookie will be returned as a JSON object as * described by the WebDriver wire protocol. * @param {string} name The name of the cookie to retrieve. * @return {!webdriver.promise.Promise} A promise that will be resolved with the * named cookie, or {@code null} if there is no such cookie. * @see http://code.google.com/p/selenium/wiki/JsonWireProtocol#Cookie_JSON_Object */ getCookie(name: string): webdriver.promise.Promise; /** * @return {!webdriver.WebDriver.Logs} The interface for managing driver * logs. */ logs(): webdriver.WebDriverLogs; /** * @return {!webdriver.WebDriver.Timeouts} The interface for managing driver * timeouts. */ timeouts(): webdriver.WebDriverTimeouts; /** * @return {!webdriver.WebDriver.Window} The interface for managing the * current window. */ window(): webdriver.WebDriverWindow; //endregion } /** * An interface for managing timeout behavior for WebDriver instances. */ class WebDriverTimeouts { //region Constructors /** * @param {!webdriver.WebDriver} driver The parent driver. * @constructor */ constructor(driver: webdriver.WebDriver); //endregion //region Methods /** * Specifies the amount of time the driver should wait when searching for an * element if it is not immediately present. *

* When searching for a single element, the driver should poll the page * until the element has been found, or this timeout expires before failing * with a {@code bot.ErrorCode.NO_SUCH_ELEMENT} error. When searching * for multiple elements, the driver should poll the page until at least one * element has been found or this timeout has expired. *

* Setting the wait timeout to 0 (its default value), disables implicit * waiting. *

* Increasing the implicit wait timeout should be used judiciously as it * will have an adverse effect on test run time, especially when used with * slower location strategies like XPath. * * @param {number} ms The amount of time to wait, in milliseconds. * @return {!webdriver.promise.Promise} A promise that will be resolved when the * implicit wait timeout has been set. */ implicitlyWait(ms: number): webdriver.promise.Promise; /** * Sets the amount of time to wait, in milliseconds, for an asynchronous script * to finish execution before returning an error. If the timeout is less than or * equal to 0, the script will be allowed to run indefinitely. * * @param {number} ms The amount of time to wait, in milliseconds. * @return {!webdriver.promise.Promise} A promise that will be resolved when the * script timeout has been set. */ setScriptTimeout(ms: number): webdriver.promise.Promise; /** * Sets the amount of time to wait for a page load to complete before returning * an error. If the timeout is negative, page loads may be indefinite. * @param {number} ms The amount of time to wait, in milliseconds. * @return {!webdriver.promise.Promise} A promise that will be resolved when * the timeout has been set. */ pageLoadTimeout(ms: number): webdriver.promise.Promise; //endregion } /** * An interface for managing the current window. */ class WebDriverWindow { //region Constructors /** * @param {!webdriver.WebDriver} driver The parent driver. * @constructor */ constructor(driver: webdriver.WebDriver); //endregion //region Methods /** * Retrieves the window's current position, relative to the top left corner of * the screen. * @return {!webdriver.promise.Promise} A promise that will be resolved with the * window's position in the form of a {x:number, y:number} object literal. */ getPosition(): webdriver.promise.Promise; /** * Repositions the current window. * @param {number} x The desired horizontal position, relative to the left side * of the screen. * @param {number} y The desired vertical position, relative to the top of the * of the screen. * @return {!webdriver.promise.Promise} A promise that will be resolved when the * command has completed. */ setPosition(x: number, y: number): webdriver.promise.Promise; /** * Retrieves the window's current size. * @return {!webdriver.promise.Promise} A promise that will be resolved with the * window's size in the form of a {width:number, height:number} object * literal. */ getSize(): webdriver.promise.Promise; /** * Resizes the current window. * @param {number} width The desired window width. * @param {number} height The desired window height. * @return {!webdriver.promise.Promise} A promise that will be resolved when the * command has completed. */ setSize(width: number, height: number): webdriver.promise.Promise; /** * Maximizes the current window. * @return {!webdriver.promise.Promise} A promise that will be resolved when the * command has completed. */ maximize(): webdriver.promise.Promise; //endregion } /** * Interface for managing WebDriver log records. */ class WebDriverLogs { //region Constructors /** * @param {!webdriver.WebDriver} driver The parent driver. * @constructor */ constructor(driver: webdriver.WebDriver); //endregion //region /** * Fetches available log entries for the given type. * *

Note that log buffers are reset after each call, meaning that * available log entries correspond to those entries not yet returned for a * given log type. In practice, this means that this call will return the * available log entries since the last call, or from the start of the * session. * * @param {!webdriver.logging.Type} type The desired log type. * @return {!webdriver.promise.Promise.>} A * promise that will resolve to a list of log entries for the specified * type. */ get(type: string): webdriver.promise.Promise; /** * Retrieves the log types available to this driver. * @return {!webdriver.promise.Promise.>} A * promise that will resolve to a list of available log types. */ getAvailableLogTypes(): webdriver.promise.Promise; //endregion } /** * An interface for changing the focus of the driver to another frame or window. */ class WebDriverTargetLocator { //region Constructors /** * @param {!webdriver.WebDriver} driver The parent driver. * @constructor */ constructor(driver: webdriver.WebDriver); //endregion //region Methods /** * Schedules a command retrieve the {@code document.activeElement} element on * the current document, or {@code document.body} if activeElement is not * available. * @return {!webdriver.WebElement} The active element. */ activeElement(): webdriver.WebElement; /** * Schedules a command to switch focus of all future commands to the first frame * on the page. * @return {!webdriver.promise.Promise} A promise that will be resolved when the * driver has changed focus to the default content. */ defaultContent(): webdriver.promise.Promise; /** * Schedules a command to switch the focus of all future commands to another * frame on the page. *

* If the frame is specified by a number, the command will switch to the frame * by its (zero-based) index into the {@code window.frames} collection. *

* If the frame is specified by a string, the command will select the frame by * its name or ID. To select sub-frames, simply separate the frame names/IDs by * dots. As an example, "main.child" will select the frame with the name "main" * and then its child "child". *

* If the specified frame can not be found, the deferred result will errback * with a {@code bot.ErrorCode.NO_SUCH_FRAME} error. * @param {string|number} nameOrIndex The frame locator. * @return {!webdriver.promise.Promise} A promise that will be resolved when the * driver has changed focus to the specified frame. */ frame(nameOrIndex: string): webdriver.promise.Promise; frame(nameOrIndex: number): webdriver.promise.Promise; /** * Schedules a command to switch the focus of all future commands to another * window. Windows may be specified by their {@code window.name} attribute or * by its handle (as returned by {@code webdriver.WebDriver#getWindowHandles}). *

* If the specificed window can not be found, the deferred result will errback * with a {@code bot.ErrorCode.NO_SUCH_WINDOW} error. * @param {string} nameOrHandle The name or window handle of the window to * switch focus to. * @return {!webdriver.promise.Promise} A promise that will be resolved when the * driver has changed focus to the specified window. */ window(nameOrHandle: string): webdriver.promise.Promise; /** * Schedules a command to change focus to the active alert dialog. This command * will return a {@link bot.ErrorCode.NO_MODAL_DIALOG_OPEN} error if a modal * dialog is not currently open. * @return {!webdriver.Alert} The open alert. */ alert(): webdriver.Alert; //endregion } /** * Creates a new WebDriver client, which provides control over a browser. * * Every WebDriver command returns a {@code webdriver.promise.Promise} that * represents the result of that command. Callbacks may be registered on this * object to manipulate the command result or catch an expected error. Any * commands scheduled with a callback are considered sub-commands and will * execute before the next command in the current frame. For example: * * var message = []; * driver.call(message.push, message, 'a').then(function() { * driver.call(message.push, message, 'b'); * }); * driver.call(message.push, message, 'c'); * driver.call(function() { * alert('message is abc? ' + (message.join('') == 'abc')); * }); * */ class WebDriver { //region Constructors /** * @param {!(webdriver.Session|webdriver.promise.Promise)} session Either a * known session or a promise that will be resolved to a session. * @param {!webdriver.CommandExecutor} executor The executor to use when * sending commands to the browser. * @param {webdriver.promise.ControlFlow=} opt_flow The flow to * schedule commands through. Defaults to the active flow object. * @constructor */ constructor(session: webdriver.Session, executor: webdriver.CommandExecutor, opt_flow?: webdriver.promise.ControlFlow); constructor(session: webdriver.promise.Promise, executor: webdriver.CommandExecutor, opt_flow?: webdriver.promise.ControlFlow); //endregion //region Static Properties static Navigation: WebDriverNavigation; static Options: WebDriverOptions; static Timeouts: WebDriverTimeouts; static Window: WebDriverWindow; static Logs: WebDriverLogs; static TargetLocator: WebDriverTargetLocator; //endregion //region StaticMethods /** * Creates a new WebDriver client for an existing session. * @param {!webdriver.CommandExecutor} executor Command executor to use when * querying for session details. * @param {string} sessionId ID of the session to attach to. * @return {!webdriver.WebDriver} A new client for the specified session. */ static attachToSession(executor: webdriver.CommandExecutor, sessionId: string): WebDriver; /** * Creates a new WebDriver session. * @param {!webdriver.CommandExecutor} executor The executor to create the new * session with. * @param {!webdriver.Capabilities} desiredCapabilities The desired * capabilities for the new session. * @return {!webdriver.WebDriver} The driver for the newly created session. */ static createSession(executor: webdriver.CommandExecutor, desiredCapabilities: webdriver.Capabilities): WebDriver; //endregion //region Methods /** * @return {!webdriver.promise.ControlFlow} The control flow used by this * instance. */ controlFlow(): webdriver.promise.ControlFlow; /** * Schedules a {@code webdriver.Command} to be executed by this driver's * {@code webdriver.CommandExecutor}. * @param {!webdriver.Command} command The command to schedule. * @param {string} description A description of the command for debugging. * @return {!webdriver.promise.Promise} A promise that will be resolved with * the command result. */ schedule(command: webdriver.Command, description: string): webdriver.promise.Promise; /** * @return {!webdriver.promise.Promise} A promise for this client's session. */ getSession(): webdriver.promise.Promise; /** * @return {!webdriver.promise.Promise} A promise that will resolve with the * this instance's capabilities. */ getCapabilities(): webdriver.promise.Promise; /** * Schedules a command to quit the current session. After calling quit, this * instance will be invalidated and may no longer be used to issue commands * against the browser. * @return {!webdriver.promise.Promise} A promise that will be resolved when * the command has completed. */ quit(): webdriver.promise.Promise; /** * Creates a new action sequence using this driver. The sequence will not be * scheduled for execution until {@link webdriver.ActionSequence#perform} is * called. Example: * 


         *   driver.actions().
         *       mouseDown(element1).
         *       mouseMove(element2).
         *       mouseUp().
         *       perform();
         *
* @return {!webdriver.ActionSequence} A new action sequence for this instance. */ actions(): webdriver.ActionSequence; /** * Schedules a command to execute JavaScript in the context of the currently * selected frame or window. The script fragment will be executed as the body * of an anonymous function. If the script is provided as a function object, * that function will be converted to a string for injection into the target * window. * * Any arguments provided in addition to the script will be included as script * arguments and may be referenced using the {@code arguments} object. * Arguments may be a boolean, number, string, or {@code webdriver.WebElement}. * Arrays and objects may also be used as script arguments as long as each item * adheres to the types previously mentioned. * * The script may refer to any variables accessible from the current window. * Furthermore, the script will execute in the window's context, thus * {@code document} may be used to refer to the current document. Any local * variables will not be available once the script has finished executing, * though global variables will persist. * * If the script has a return value (i.e. if the script contains a return * statement), then the following steps will be taken for resolving this * functions return value: * * * @param {!(string|Function)} script The script to execute. * @param {...*} var_args The arguments to pass to the script. * @return {!webdriver.promise.Promise} A promise that will resolve to the * scripts return value. */ executeScript(script: string, ...var_args: any[]): webdriver.promise.Promise; executeScript(script: any, ...var_args: any[]): webdriver.promise.Promise; /** * Schedules a command to execute asynchronous JavaScript in the context of the * currently selected frame or window. The script fragment will be executed as * the body of an anonymous function. If the script is provided as a function * object, that function will be converted to a string for injection into the * target window. * * Any arguments provided in addition to the script will be included as script * arguments and may be referenced using the {@code arguments} object. * Arguments may be a boolean, number, string, or {@code webdriver.WebElement}. * Arrays and objects may also be used as script arguments as long as each item * adheres to the types previously mentioned. * * Unlike executing synchronous JavaScript with * {@code webdriver.WebDriver.prototype.executeScript}, scripts executed with * this function must explicitly signal they are finished by invoking the * provided callback. This callback will always be injected into the * executed function as the last argument, and thus may be referenced with * {@code arguments[arguments.length - 1]}. The following steps will be taken * for resolving this functions return value against the first argument to the * script's callback function: * * * Example #1: Performing a sleep that is synchronized with the currently * selected window: * 
         * var start = new Date().getTime();
         * driver.executeAsyncScript(
         *     'window.setTimeout(arguments[arguments.length - 1], 500);').
         *     then(function() {
         *       console.log('Elapsed time: ' + (new Date().getTime() - start) + ' ms');
         *     });
         *
* * Example #2: Synchronizing a test with an AJAX application: * 
         * var button = driver.findElement(By.id('compose-button'));
         * button.click();
         * driver.executeAsyncScript(
         *     'var callback = arguments[arguments.length - 1];' +
         *     'mailClient.getComposeWindowWidget().onload(callback);');
         * driver.switchTo().frame('composeWidget');
         * driver.findElement(By.id('to')).sendKEys('dog@example.com');
         *
* * Example #3: Injecting a XMLHttpRequest and waiting for the result. In this * example, the inject script is specified with a function literal. When using * this format, the function is converted to a string for injection, so it * should not reference any symbols not defined in the scope of the page under * test. * 
         * driver.executeAsyncScript(function() {
         *   var callback = arguments[arguments.length - 1];
         *   var xhr = new XMLHttpRequest();
         *   xhr.open("GET", "/resource/data.json", true);
         *   xhr.onreadystatechange = function() {
         *     if (xhr.readyState == 4) {
         *       callback(xhr.resposneText);
         *     }
         *   }
         *   xhr.send('');
         * }).then(function(str) {
         *   console.log(JSON.parse(str)['food']);
         * });
         *
* * @param {!(string|Function)} script The script to execute. * @param {...*} var_args The arguments to pass to the script. * @return {!webdriver.promise.Promise} A promise that will resolve to the * scripts return value. */ executeAsyncScript(script: string, ...var_args: any[]): webdriver.promise.Promise; executeAsyncScript(script: any, ...var_args: any[]): webdriver.promise.Promise; /** * Schedules a command to execute a custom function. * @param {!Function} fn The function to execute. * @param {Object=} opt_scope The object in whose scope to execute the function. * @param {...*} var_args Any arguments to pass to the function. * @return {!webdriver.promise.Promise} A promise that will be resolved with the * function's result. */ call(fn: any, opt_scope?: any, ...var_args: any[]): webdriver.promise.Promise; /** * Schedules a command to wait for a condition to hold, as defined by some * user supplied function. If any errors occur while evaluating the wait, they * will be allowed to propagate. * @param {function():boolean|!webdriver.promise.Promise} fn The function to * evaluate as a wait condition. * @param {number} timeout How long to wait for the condition to be true. * @param {string=} opt_message An optional message to use if the wait times * out. * @return {!webdriver.promise.Promise} A promise that will be resolved when the * wait condition has been satisfied. */ wait(fn: () => any, timeout: number, opt_message?: string): webdriver.promise.Promise; /** * Schedules a command to make the driver sleep for the given amount of time. * @param {number} ms The amount of time, in milliseconds, to sleep. * @return {!webdriver.promise.Promise} A promise that will be resolved when the * sleep has finished. */ sleep(ms: number): webdriver.promise.Promise; /** * Schedules a command to retrieve they current window handle. * @return {!webdriver.promise.Promise} A promise that will be resolved with the * current window handle. */ getWindowHandle(): webdriver.promise.Promise; /** * Schedules a command to retrieve the current list of available window handles. * @return {!webdriver.promise.Promise} A promise that will be resolved with an * array of window handles. */ getAllWindowHandles(): webdriver.promise.Promise; /** * Schedules a command to retrieve the current page's source. The page source * returned is a representation of the underlying DOM: do not expect it to be * formatted or escaped in the same way as the response sent from the web * server. * @return {!webdriver.promise.Promise} A promise that will be resolved with the * current page source. */ getPageSource(): webdriver.promise.Promise; /** * Schedules a command to close the current window. * @return {!webdriver.promise.Promise} A promise that will be resolved when * this command has completed. */ close(): webdriver.promise.Promise; /** * Schedules a command to navigate to the given URL. * @param {string} url The fully qualified URL to open. * @return {!webdriver.promise.Promise} A promise that will be resolved when the * document has finished loading. */ get(url: string): webdriver.promise.Promise; /** * Schedules a command to retrieve the URL of the current page. * @return {!webdriver.promise.Promise} A promise that will be resolved with the * current URL. */ getCurrentUrl(): webdriver.promise.Promise; /** * Schedules a command to retrieve the current page's title. * @return {!webdriver.promise.Promise} A promise that will be resolved with the * current page's title. */ getTitle(): webdriver.promise.Promise; /** * Schedule a command to find an element on the page. If the element cannot be * found, a {@code bot.ErrorCode.NO_SUCH_ELEMENT} result will be returned * by the driver. Unlike other commands, this error cannot be suppressed. In * other words, scheduling a command to find an element doubles as an assert * that the element is present on the page. To test whether an element is * present on the page, use {@code #isElementPresent} instead. * *

The search criteria for find an element may either be a * {@code webdriver.Locator} object, or a simple JSON object whose sole key * is one of the accepted locator strategies, as defined by * {@code webdriver.Locator.Strategy}. For example, the following two statements * are equivalent: * 

         * var e1 = driver.findElement(By.id('foo'));
         * var e2 = driver.findElement({id:'foo'});
         *
* *

When running in the browser, a WebDriver cannot manipulate DOM elements * directly; it may do so only through a {@link webdriver.WebElement} reference. * This function may be used to generate a WebElement from a DOM element. A * reference to the DOM element will be stored in a known location and this * driver will attempt to retrieve it through {@link #executeScript}. If the * element cannot be found (eg, it belongs to a different document than the * one this instance is currently focused on), a * {@link bot.ErrorCode.NO_SUCH_ELEMENT} error will be returned. * * @param {!(webdriver.Locator|Object.|Element)} locatorOrElement The * locator strategy to use when searching for the element, or the actual * DOM element to be located by the server. * @param {...} var_args Arguments to pass to {@code #executeScript} if using a * JavaScript locator. Otherwise ignored. * @return {!webdriver.WebElement} A WebElement that can be used to issue * commands against the located element. If the element is not found, the * element will be invalidated and all scheduled commands aborted. */ findElement(locatorOrElement: webdriver.Locator, ...var_args: any[]): webdriver.WebElement; findElement(locatorOrElement: any, ...var_args: any[]): webdriver.WebElement; /** * Schedules a command to test if an element is present on the page. * *

If given a DOM element, this function will check if it belongs to the * document the driver is currently focused on. Otherwise, the function will * test if at least one element can be found with the given search criteria. * * @param {!(webdriver.Locator|Object.|Element)} locatorOrElement The * locator strategy to use when searching for the element, or the actual * DOM element to be located by the server. * @param {...} var_args Arguments to pass to {@code #executeScript} if using a * JavaScript locator. Otherwise ignored. * @return {!webdriver.promise.Promise} A promise that will resolve to whether * the element is present on the page. */ isElementPresent(locatorOrElement: webdriver.Locator, ...var_args: any[]): webdriver.promise.Promise; isElementPresent(locatorOrElement: any, ...var_args: any[]): webdriver.promise.Promise; /** * Schedule a command to search for multiple elements on the page. * * @param {webdriver.Locator|Object.} locator The locator * strategy to use when searching for the element. * @param {...} var_args Arguments to pass to {@code #executeScript} if using a * JavaScript locator. Otherwise ignored. * @return {!webdriver.promise.Promise} A promise that will be resolved to an * array of the located {@link webdriver.WebElement}s. */ findElements(locator: webdriver.Locator, ...var_args: any[]): webdriver.promise.Promise; findElements(locator: any, ...var_args: any[]): webdriver.promise.Promise; /** * Schedule a command to take a screenshot. The driver makes a best effort to * return a screenshot of the following, in order of preference: *

    *
  1. Entire page *
  2. Current window *
  3. Visible portion of the current frame *
  4. The screenshot of the entire display containing the browser *
* * @return {!webdriver.promise.Promise} A promise that will be resolved to the * screenshot as a base-64 encoded PNG. */ takeScreenshot(): webdriver.promise.Promise; /** * @return {!webdriver.WebDriver.Options} The options interface for this * instance. */ manage(): webdriver.WebDriverOptions; /** * @return {!webdriver.WebDriver.Navigation} The navigation interface for this * instance. */ navigate(): webdriver.WebDriverNavigation; /** * @return {!webdriver.WebDriver.TargetLocator} The target locator interface for * this instance. */ switchTo(): webdriver.WebDriverTargetLocator //endregion } /** * Represents a DOM element. WebElements can be found by searching from the * document root using a {@code webdriver.WebDriver} instance, or by searching * under another {@code webdriver.WebElement}: * * driver.get('http://www.google.com'); * var searchForm = driver.findElement(By.tagName('form')); * var searchBox = searchForm.findElement(By.name('q')); * searchBox.sendKeys('webdriver'); * * The WebElement is implemented as a promise for compatibility with the promise * API. It will always resolve itself when its internal state has been fully * resolved and commands may be issued against the element. This can be used to * catch errors when an element cannot be located on the page: * * driver.findElement(By.id('not-there')).then(function(element) { * alert('Found an element that was not expected to be there!'); * }, function(error) { * alert('The element was not found, as expected'); * }); * * @extends {webdriver.promise.Deferred} */ class WebElement extends webdriver.promise.Deferred { //region Constructors /** * @param {!webdriver.WebDriver} driver The parent WebDriver instance for this * element. * @param {!(string|webdriver.promise.Promise)} id Either the opaque ID for the * underlying DOM element assigned by the server, or a promise that will * resolve to that ID or another WebElement. * @constructor */ constructor(driver: webdriver.WebDriver, id: webdriver.promise.Promise); constructor(driver: webdriver.WebDriver, id: string); //endregion //region Static Properties /** * The property key used in the wire protocol to indicate that a JSON object * contains the ID of a WebElement. * @type {string} * @const */ static ELEMENT_KEY: string; //endregion //region Methods /** * @return {!webdriver.WebDriver} The parent driver for this instance. */ getDriver(): webdriver.WebDriver; /** * @return {!webdriver.promise.Promise} A promise that resolves to this * element's JSON representation as defined by the WebDriver wire protocol. * @see http://code.google.com/p/selenium/wiki/JsonWireProtocol */ toWireValue(): webdriver.promise.Promise; /** * Schedule a command to find a descendant of this element. If the element * cannot be found, a {@code bot.ErrorCode.NO_SUCH_ELEMENT} result will * be returned by the driver. Unlike other commands, this error cannot be * suppressed. In other words, scheduling a command to find an element doubles * as an assert that the element is present on the page. To test whether an * element is present on the page, use {@code #isElementPresent} instead. *

* The search criteria for find an element may either be a * {@code webdriver.Locator} object, or a simple JSON object whose sole key * is one of the accepted locator strategies, as defined by * {@code webdriver.Locator.Strategy}. For example, the following two * statements are equivalent: * 

         * var e1 = element.findElement(By.id('foo'));
         * var e2 = element.findElement({id:'foo'});
         *
*

* Note that JS locator searches cannot be restricted to a subtree. All such * searches are delegated to this instance's parent WebDriver. * * @param {webdriver.Locator|Object.} locator The locator * strategy to use when searching for the element. * @param {...} var_args Arguments to pass to {@code WebDriver#executeScript} if * using a JavaScript locator. Otherwise ignored. * @return {webdriver.WebElement} A WebElement that can be used to issue * commands against the located element. If the element is not found, the * element will be invalidated and all scheduled commands aborted. */ findElement(locator: webdriver.Locator, ...var_args: any[]): WebElement; findElement(locator: any, ...var_args: any[]): WebElement; /** * Schedules a command to test if there is at least one descendant of this * element that matches the given search criteria. * *

Note that JS locator searches cannot be restricted to a subtree of the * DOM. All such searches are delegated to this instance's parent WebDriver. * * @param {webdriver.Locator|Object.} locator The locator * strategy to use when searching for the element. * @param {...} var_args Arguments to pass to {@code WebDriver#executeScript} if * using a JavaScript locator. Otherwise ignored. * @return {!webdriver.promise.Promise} A promise that will be resolved with * whether an element could be located on the page. */ isElementPresent(locator: webdriver.Locator, ...var_args: any[]): webdriver.promise.Promise; isElementPresent(locator: any, ...var_args: any[]): webdriver.promise.Promise; /** * Schedules a command to find all of the descendants of this element that match * the given search criteria. *

* Note that JS locator searches cannot be restricted to a subtree. All such * searches are delegated to this instance's parent WebDriver. * * @param {webdriver.Locator|Object.} locator The locator * strategy to use when searching for the elements. * @param {...} var_args Arguments to pass to {@code WebDriver#executeScript} if * using a JavaScript locator. Otherwise ignored. * @return {!webdriver.promise.Promise} A promise that will be resolved with an * array of located {@link webdriver.WebElement}s. */ findElements(locator: webdriver.Locator, ...var_args: any[]): webdriver.promise.Promise; findElements(locator: any, ...var_args: any[]): webdriver.promise.Promise; /** * Schedules a command to click on this element. * @return {!webdriver.promise.Promise} A promise that will be resolved when * the click command has completed. */ click(): webdriver.promise.Promise; /** * Schedules a command to type a sequence on the DOM element represented by this * instance. *

* Modifier keys (SHIFT, CONTROL, ALT, META) are stateful; once a modifier is * processed in the keysequence, that key state is toggled until one of the * following occurs: *

* Note: On browsers where native keyboard events are not yet * supported (e.g. Firefox on OS X), key events will be synthesized. Special * punctionation keys will be synthesized according to a standard QWERTY en-us * keyboard layout. * * @param {...string} var_args The sequence of keys to * type. All arguments will be joined into a single sequence (var_args is * permitted for convenience). * @return {!webdriver.promise.Promise} A promise that will be resolved when all * keys have been typed. */ sendKeys(...var_args: string[]): webdriver.promise.Promise; /** * Schedules a command to query for the tag/node name of this element. * @return {!webdriver.promise.Promise} A promise that will be resolved with the * element's tag name. */ getTagName(): webdriver.promise.Promise; /** * Schedules a command to query for the computed style of the element * represented by this instance. If the element inherits the named style from * its parent, the parent will be queried for its value. Where possible, color * values will be converted to their hex representation (e.g. #00ff00 instead of * rgb(0, 255, 0)). *

* Warning: the value returned will be as the browser interprets it, so * it may be tricky to form a proper assertion. * * @param {string} cssStyleProperty The name of the CSS style property to look * up. * @return {!webdriver.promise.Promise} A promise that will be resolved with the * requested CSS value. */ getCssValue(cssStyleProperty: string): webdriver.promise.Promise; /** * Schedules a command to query for the value of the given attribute of the * element. Will return the current value even if it has been modified after the * page has been loaded. More exactly, this method will return the value of the * given attribute, unless that attribute is not present, in which case the * value of the property with the same name is returned. If neither value is * set, null is returned. The "style" attribute is converted as best can be to a * text representation with a trailing semi-colon. The following are deemed to * be "boolean" attributes and will be returned as thus: * *

async, autofocus, autoplay, checked, compact, complete, controls, declare, * defaultchecked, defaultselected, defer, disabled, draggable, ended, * formnovalidate, hidden, indeterminate, iscontenteditable, ismap, itemscope, * loop, multiple, muted, nohref, noresize, noshade, novalidate, nowrap, open, * paused, pubdate, readonly, required, reversed, scoped, seamless, seeking, * selected, spellcheck, truespeed, willvalidate * *

Finally, the following commonly mis-capitalized attribute/property names * are evaluated as expected: *

* @param {string} attributeName The name of the attribute to query. * @return {!webdriver.promise.Promise} A promise that will be resolved with the * attribute's value. */ getAttribute(attributeName: string): webdriver.promise.Promise; /** * Get the visible (i.e. not hidden by CSS) innerText of this element, including * sub-elements, without any leading or trailing whitespace. * @return {!webdriver.promise.Promise} A promise that will be resolved with the * element's visible text. */ getText(): webdriver.promise.Promise; /** * Schedules a command to compute the size of this element's bounding box, in * pixels. * @return {!webdriver.promise.Promise} A promise that will be resolved with the * element's size as a {@code {width:number, height:number}} object. */ getSize(): webdriver.promise.Promise; /** * Schedules a command to compute the location of this element in page space. * @return {!webdriver.promise.Promise} A promise that will be resolved to the * element's location as a {@code {x:number, y:number}} object. */ getLocation(): webdriver.promise.Promise; /** * Schedules a command to query whether the DOM element represented by this * instance is enabled, as dicted by the {@code disabled} attribute. * @return {!webdriver.promise.Promise} A promise that will be resolved with * whether this element is currently enabled. */ isEnabled(): webdriver.promise.Promise; /** * Schedules a command to query whether this element is selected. * @return {!webdriver.promise.Promise} A promise that will be resolved with * whether this element is currently selected. */ isSelected(): webdriver.promise.Promise; /** * Schedules a command to submit the form containing this element (or this * element if it is a FORM element). This command is a no-op if the element is * not contained in a form. * @return {!webdriver.promise.Promise} A promise that will be resolved when * the form has been submitted. */ submit(): webdriver.promise.Promise; /** * Schedules a command to clear the {@code value} of this element. This command * has no effect if the underlying DOM element is neither a text INPUT element * nor a TEXTAREA element. * @return {!webdriver.promise.Promise} A promise that will be resolved when * the element has been cleared. */ clear(): webdriver.promise.Promise; /** * Schedules a command to test whether this element is currently displayed. * @return {!webdriver.promise.Promise} A promise that will be resolved with * whether this element is currently visible on the page. */ isDisplayed(): webdriver.promise.Promise; /** * Schedules a command to retrieve the outer HTML of this element. * @return {!webdriver.promise.Promise} A promise that will be resolved with * the element's outer HTML. */ getOuterHtml(): webdriver.promise.Promise; /** * Schedules a command to retrieve the inner HTML of this element. * @return {!webdriver.promise.Promise} A promise that will be resolved with the * element's inner HTML. */ getInnerHtml(): webdriver.promise.Promise; //endregion //region Static Methods /** * Compares to WebElements for equality. * @param {!webdriver.WebElement} a A WebElement. * @param {!webdriver.WebElement} b A WebElement. * @return {!webdriver.promise.Promise} A promise that will be resolved to * whether the two WebElements are equal. */ static equals(a: WebElement, b: WebElement): webdriver.promise.Promise; //endregion } interface ILocatorStrategy { className(value: string): Locator; 'class name'(value: string): Locator; css(value: string): Locator; id(value: string): Locator; js(value: string): Locator; linkText(value: string): Locator; 'link text'(value: string): Locator; name(value: string): Locator; partialLinkText(value: string): Locator; 'partial link text'(value: string): Locator; tagName(value: string): Locator; 'tag name'(value: string): Locator; xpath(value: string): Locator; } var By: ILocatorStrategy; /** * An element locator. */ class Locator { //region Constructors /** * An element locator. * @param {string} using The type of strategy to use for this locator. * @param {string} value The search target of this locator. * @constructor */ constructor(using: string, value: string); //endregion //region Properties /** * The search strategy to use when searching for an element. * @type {string} */ using: string; /** * The search target for this locator. * @type {string} */ value: string; //endregion //region Static Properties /** * Factory methods for the supported locator strategies. * @type {Object.} */ static Strategy: ILocatorStrategy; //endregion //region Methods /** @return {string} String representation of this locator. */ toString(): string; //endregion //region Static Methods /** * Creates a new Locator from an object whose only property is also a key in * the {@code webdriver.Locator.Strategy} map. * @param {Object.} obj The object to convert into a locator. * @return {webdriver.Locator} The new locator object. */ static createFromObj(obj: any): Locator /** * Verifies that a {@code locator} is a valid locator to use for searching for * elements on the page. * @param {webdriver.Locator|Object.} locator The locator * to verify, or a short-hand object that can be converted into a locator * to verify. * @return {!webdriver.Locator} The validated locator. */ static checkLocator(locator: Locator): Locator; static checkLocator(obj: any): Locator; //endregion } /** * Contains information about a WebDriver session. */ class Session { //region Constructors /** * @param {string} id The session ID. * @param {!(Object|webdriver.Capabilities)} capabilities The session * capabilities. * @constructor */ constructor(id: string, capabilities: webdriver.Capabilities); constructor(id: string, capabilities: any); //endregion //region Methods /** * @return {string} This session's ID. */ getId(): string; /** * @return {!webdriver.Capabilities} This session's capabilities. */ getCapabilities(): webdriver.Capabilities; /** * Retrieves the value of a specific capability. * @param {string} key The capability to retrieve. * @return {*} The capability value. */ getCapability(key: string): any; /** * Returns the JSON representation of this object, which is just the string * session ID. * @return {string} The JSON representation of this Session. */ toJSON(): string; //endregion } } declare module 'selenium-webdriver' { export = webdriver; }