declare var __registerDomainDispatcher;

export function DomainDispatcher(domain: string): ClassDecorator {

return klass => __registerDomainDispatcher(domain, klass);

}

// ApplicationCache

export namespace ApplicationCacheDomain {

export interface ApplicationCacheResource {

// Resource url.

url: string;

// Resource size.

size: number;

// Resource type.

type: string;

}

export interface ApplicationCache {

// Manifest URL.

manifestURL: string;

// Application cache size.

size: number;

// Application cache creation time.

creationTime: number;

// Application cache update time.

updateTime: number;

// Application cache resources.

resources: ApplicationCacheResource[];

}

export interface FrameWithManifest {

// Frame identifier.

frameId: NetworkDomain.FrameId;

// Manifest URL.

manifestURL: string;

// Application cache status.

status: number;

}

export interface GetManifestForFrameMethodArguments {

// Identifier of the frame containing document whose manifest is retrieved.

frameId: NetworkDomain.FrameId

}

export interface GetApplicationCacheForFrameMethodArguments {

// Identifier of the frame containing document whose application cache is retrieved.

frameId: NetworkDomain.FrameId

}

export interface ApplicationCacheDomainDispatcher {

// Returns array of frame identifiers with manifest urls for each frame containing a document associated with some application cache.

getFramesWithManifests(): { frameIds: FrameWithManifest[] };

// Enables application cache domain notifications.

enable(): void;

// Returns manifest URL for document in the given frame.

getManifestForFrame(params: GetManifestForFrameMethodArguments): { manifestURL: string };

// Returns relevant application cache data for the document in given frame.

getApplicationCacheForFrame(params: GetApplicationCacheForFrameMethodArguments): { applicationCache: ApplicationCache };

}

export class ApplicationCacheFrontend {

constructor(private dispatchMessage: (message: String) => void) {

}

applicationCacheStatusUpdated(frameId: NetworkDomain.FrameId, manifestURL: string, status: number): void {

this.dispatchMessage(JSON.stringify( { "method": "ApplicationCache.applicationCacheStatusUpdated", "params": { "frameId": frameId, "manifestURL": manifestURL, "status": status } } ));

}

networkStateUpdated(isNowOnline: boolean): void {

this.dispatchMessage(JSON.stringify( { "method": "ApplicationCache.networkStateUpdated", "params": { "isNowOnline": isNowOnline } } ));

}

}

}

// CSS

// This domain exposes CSS read/write operations. All CSS objects, like stylesheets, rules, and styles, have an associated <code>id</code> used in subsequent operations on the related object. Each object type has a specific <code>id</code> structure, and those are not interchangeable between objects of different kinds. CSS objects can be loaded using the <code>get*ForNode()</code> calls (which accept a DOM node id). Alternatively, a client can discover all the existing stylesheets with the <code>getAllStyleSheets()</code> method and subsequently load the required stylesheet contents using the <code>getStyleSheet[Text]()</code> methods.

export namespace CSSDomain {

export type StyleSheetId = string

export interface CSSStyleId {

// Enclosing stylesheet identifier.

styleSheetId: StyleSheetId;

// The style ordinal within the stylesheet.

ordinal: number;

}

export interface CSSRuleId {

// Enclosing stylesheet identifier.

styleSheetId: StyleSheetId;

// The rule ordinal within the stylesheet.

ordinal: number;

}

export interface PseudoIdMatches {

// Pseudo style identifier (see <code>enum PseudoId</code> in <code>RenderStyleConstants.h</code>).

pseudoId: number;

// Matches of CSS rules applicable to the pseudo style.

matches: RuleMatch[];

}

export interface InheritedStyleEntry {

// The ancestor node's inline style, if any, in the style inheritance chain.

inlineStyle?: CSSStyle;

// Matches of CSS rules matching the ancestor node in the style inheritance chain.

matchedCSSRules: RuleMatch[];

}

export interface RuleMatch {

// CSS rule in the match.

rule: CSSRule;

// Matching selector indices in the rule's selectorList selectors (0-based).

matchingSelectors: number[];

}

export interface CSSSelector {

// Canonicalized selector text.

text: string;

// Specificity (a, b, c) tuple. Included if the selector is sent in response to CSS.getMatchedStylesForNode which provides a context element.

specificity?: number[];

// Whether or not the specificity can be dynamic. Included if the selector is sent in response to CSS.getMatchedStylesForNode which provides a context element.

dynamic?: boolean;

}

export interface SelectorList {

// Selectors in the list.

selectors: CSSSelector[];

// Rule selector text.

text: string;

// Rule selector range in the underlying resource (if available).

range?: SourceRange;

}

export interface CSSStyleAttribute {

// DOM attribute name (e.g. "width").

name: string;

// CSS style generated by the respective DOM attribute.

style: CSSStyle;

}

export interface CSSStyleSheetHeader {

// The stylesheet identifier.

styleSheetId: StyleSheetId;

// Owner frame identifier.

frameId: NetworkDomain.FrameId;

// Stylesheet resource URL.

sourceURL: string;

// Stylesheet origin.

origin: StyleSheetOrigin;

// Stylesheet title.

title: string;

// Denotes whether the stylesheet is disabled.

disabled: boolean;

}

export interface CSSStyleSheetBody {

// The stylesheet identifier.

styleSheetId: StyleSheetId;

// Stylesheet resource URL.

rules: CSSRule[];

// Stylesheet resource contents (if available).

text?: string;

}

export interface CSSRule {

// The CSS rule identifier (absent for user agent stylesheet and user-specified stylesheet rules).

ruleId?: CSSRuleId;

// Rule selector data.

selectorList: SelectorList;

// Parent stylesheet resource URL (for regular rules).

sourceURL?: string;

// Line ordinal of the rule selector start character in the resource.

sourceLine: number;

// Parent stylesheet's origin.

origin: StyleSheetOrigin;

// Associated style declaration.

style: CSSStyle;

// Media list array (for rules involving media queries). The array enumerates media queries starting with the innermost one, going outwards.

media?: CSSMedia[];

}

export interface SourceRange {

// Start line of range.

startLine: number;

// Start column of range (inclusive).

startColumn: number;

// End line of range

endLine: number;

// End column of range (exclusive).

endColumn: number;

}

export interface ShorthandEntry {

// Shorthand name.

name: string;

// Shorthand value.

value: string;

}

export interface CSSPropertyInfo {

// Property name.

name: string;

// Longhand property names.

longhands?: string[];

// Supported values for this property.

values?: string[];

}

export interface CSSComputedStyleProperty {

// Computed style property name.

name: string;

// Computed style property value.

value: string;

}

export interface CSSStyle {

// The CSS style identifier (absent for attribute styles).

styleId?: CSSStyleId;

// CSS properties in the style.

cssProperties: CSSProperty[];

// Computed values for all shorthands found in the style.

shorthandEntries: ShorthandEntry[];

// Style declaration text (if available).

cssText?: string;

// Style declaration range in the enclosing stylesheet (if available).

range?: SourceRange;

// The effective "width" property value from this style.

width?: string;

// The effective "height" property value from this style.

height?: string;

}

export interface CSSProperty {

// The property name.

name: string;

// The property value.

value: string;

// The property priority (implies "" if absent).

priority?: string;

// Whether the property is implicit (implies <code>false</code> if absent).

implicit?: boolean;

// The full property text as specified in the style.

text?: string;

// Whether the property is understood by the browser (implies <code>true</code> if absent).

parsedOk?: boolean;

// Whether the property is active or disabled.

status?: CSSPropertyStatus;

// The entire property range in the enclosing style declaration (if available).

range?: SourceRange;

}

export interface CSSMedia {

// Media query text.

text: string;

// Source of the media query: "mediaRule" if specified by a @media rule, "importRule" if specified by an @import rule, "linkedSheet" if specified by a "media" attribute in a linked stylesheet's LINK tag, "inlineSheet" if specified by a "media" attribute in an inline stylesheet's STYLE tag.

source: any /* mediaRule,importRule,linkedSheet,inlineSheet */;

// URL of the document containing the media query description.

sourceURL?: string;

// Line in the document containing the media query (not defined for the "stylesheet" source).

sourceLine?: number;

}

export interface Region {

// The "overset" attribute of a Named Flow.

regionOverset: any /* overset,fit,empty */;

// The corresponding DOM node id.

nodeId: DOMDomain.NodeId;

}

export interface NamedFlow {

// The document node id.

documentNodeId: DOMDomain.NodeId;

// Named Flow identifier.

name: string;

// The "overset" attribute of a Named Flow.

overset: boolean;

// An array of nodes that flow into the Named Flow.

content: DOMDomain.NodeId[];

// An array of regions associated with the Named Flow.

regions: Region[];

}

export const enum StyleSheetOrigin { User, UserAgent, Inspector, Regular };

export const enum CSSPropertyStatus { Active, Inactive, Disabled, Style };

export interface GetMatchedStylesForNodeMethodArguments {

nodeId: DOMDomain.NodeId,

// Whether to include pseudo styles (default: true).

includePseudo?: boolean,

// Whether to include inherited styles (default: true).

includeInherited?: boolean

}

export interface GetInlineStylesForNodeMethodArguments {

nodeId: DOMDomain.NodeId

}

export interface GetComputedStyleForNodeMethodArguments {

nodeId: DOMDomain.NodeId

}

export interface GetStyleSheetMethodArguments {

styleSheetId: StyleSheetId

}

export interface GetStyleSheetTextMethodArguments {

styleSheetId: StyleSheetId

}

export interface SetStyleSheetTextMethodArguments {

styleSheetId: StyleSheetId,

text: string

}

export interface SetStyleTextMethodArguments {

styleId: CSSStyleId,

text: string

}

export interface SetRuleSelectorMethodArguments {

ruleId: CSSRuleId,

selector: string

}

export interface AddRuleMethodArguments {

contextNodeId: DOMDomain.NodeId,

selector: string

}

export interface ForcePseudoStateMethodArguments {

// The element id for which to force the pseudo state.

nodeId: DOMDomain.NodeId,

// Element pseudo classes to force when computing the element's style.

forcedPseudoClasses: any /* active,focus,hover,visited */[]

}

export interface GetNamedFlowCollectionMethodArguments {

// The document node id for which to get the Named Flow Collection.

documentNodeId: DOMDomain.NodeId

}

export interface CSSDomainDispatcher {

// Enables the CSS agent for the given page. Clients should not assume that the CSS agent has been enabled until the result of this command is received.

enable(): void;

// Disables the CSS agent for the given page.

disable(): void;

// Returns requested styles for a DOM node identified by <code>nodeId</code>.

getMatchedStylesForNode(params: GetMatchedStylesForNodeMethodArguments): { matchedCSSRules?: RuleMatch[], pseudoElements?: PseudoIdMatches[], inherited?: InheritedStyleEntry[] };

// Returns the styles defined inline (explicitly in the "style" attribute and implicitly, using DOM attributes) for a DOM node identified by <code>nodeId</code>.

getInlineStylesForNode(params: GetInlineStylesForNodeMethodArguments): { inlineStyle?: CSSStyle, attributesStyle?: CSSStyle };

// Returns the computed style for a DOM node identified by <code>nodeId</code>.

getComputedStyleForNode(params: GetComputedStyleForNodeMethodArguments): { computedStyle: CSSComputedStyleProperty[] };

// Returns metainfo entries for all known stylesheets.

getAllStyleSheets(): { headers: CSSStyleSheetHeader[] };

// Returns stylesheet data for the specified <code>styleSheetId</code>.

getStyleSheet(params: GetStyleSheetMethodArguments): { styleSheet: CSSStyleSheetBody };

// Returns the current textual content and the URL for a stylesheet.

getStyleSheetText(params: GetStyleSheetTextMethodArguments): { text: string };

// Sets the new stylesheet text, thereby invalidating all existing <code>CSSStyleId</code>'s and <code>CSSRuleId</code>'s contained by this stylesheet.

setStyleSheetText(params: SetStyleSheetTextMethodArguments): void;

// Sets the new <code>text</code> for the respective style.

setStyleText(params: SetStyleTextMethodArguments): { style: CSSStyle };

// Modifies the rule selector.

setRuleSelector(params: SetRuleSelectorMethodArguments): { rule: CSSRule };

// Creates a new empty rule with the given <code>selector</code> in a special "inspector" stylesheet in the owner document of the context node.

addRule(params: AddRuleMethodArguments): { rule: CSSRule };

// Returns all supported CSS property names.

getSupportedCSSProperties(): { cssProperties: CSSPropertyInfo[] };

// Ensures that the given node will have specified pseudo-classes whenever its style is computed by the browser.

forcePseudoState(params: ForcePseudoStateMethodArguments): void;

// Returns the Named Flows from the document.

getNamedFlowCollection(params: GetNamedFlowCollectionMethodArguments): { namedFlows: NamedFlow[] };

}

export class CSSFrontend {

constructor(private dispatchMessage: (message: String) => void) {

}

// Fires whenever a MediaQuery result changes (for example, after a browser window has been resized.) The current implementation considers only viewport-dependent media features.

mediaQueryResultChanged(): void {

this.dispatchMessage(JSON.stringify( { "method": "CSS.mediaQueryResultChanged", "params": { } } ));

}

// Fired whenever a stylesheet is changed as a result of the client operation.

styleSheetChanged(styleSheetId: StyleSheetId): void {

this.dispatchMessage(JSON.stringify( { "method": "CSS.styleSheetChanged", "params": { "styleSheetId": styleSheetId } } ));

}

// Fires when a Named Flow is created.

namedFlowCreated(namedFlow: NamedFlow): void {

this.dispatchMessage(JSON.stringify( { "method": "CSS.namedFlowCreated", "params": { "namedFlow": namedFlow } } ));

}

// Fires when a Named Flow is removed: has no associated content nodes and regions.

namedFlowRemoved(documentNodeId: DOMDomain.NodeId, flowName: string): void {

this.dispatchMessage(JSON.stringify( { "method": "CSS.namedFlowRemoved", "params": { "documentNodeId": documentNodeId, "flowName": flowName } } ));

}

// Fires if any of the regionOverset values changed in a Named Flow's region chain.

regionOversetChanged(namedFlow: NamedFlow): void {

this.dispatchMessage(JSON.stringify( { "method": "CSS.regionOversetChanged", "params": { "namedFlow": namedFlow } } ));

}

// Fires when a Named Flow's has been registered with a new content node.

registeredNamedFlowContentElement(documentNodeId: DOMDomain.NodeId, flowName: string, contentNodeId: DOMDomain.NodeId, nextContentNodeId: DOMDomain.NodeId): void {

this.dispatchMessage(JSON.stringify( { "method": "CSS.registeredNamedFlowContentElement", "params": { "documentNodeId": documentNodeId, "flowName": flowName, "contentNodeId": contentNodeId, "nextContentNodeId": nextContentNodeId } } ));

}

// Fires when a Named Flow's has been registered with a new content node.

unregisteredNamedFlowContentElement(documentNodeId: DOMDomain.NodeId, flowName: string, contentNodeId: DOMDomain.NodeId): void {

this.dispatchMessage(JSON.stringify( { "method": "CSS.unregisteredNamedFlowContentElement", "params": { "documentNodeId": documentNodeId, "flowName": flowName, "contentNodeId": contentNodeId } } ));

}

}

}

// Console

// Console domain defines methods and events for interaction with the JavaScript console. Console collects messages created by means of the <a href='http://getfirebug.com/wiki/index.php/Console_API'>JavaScript Console API</a>. One needs to enable this domain using <code>enable</code> command in order to start receiving the console messages. Browser collects messages issued while console domain is not enabled as well and reports them using <code>messageAdded</code> notification upon enabling.

export namespace ConsoleDomain {

export interface ConsoleMessage {

// Message source.

source: any /* xml,javascript,network,console-api,storage,appcache,rendering,css,security,content-blocker,other */;

// Message severity.

level: any /* log,info,warning,error,debug */;

// Message text.

text: string;

// Console message type.

type?: any /* log,dir,dirxml,table,trace,clear,startGroup,startGroupCollapsed,endGroup,assert,timing,profile,profileEnd */;

// URL of the message origin.

url?: string;

// Line number in the resource that generated this message.

line?: number;

// Column number on the line in the resource that generated this message.

column?: number;

// Repeat count for repeated messages.

repeatCount?: number;

// Message parameters in case of the formatted message.

parameters?: RuntimeDomain.RemoteObject[];

// JavaScript stack trace for assertions and error messages.

stackTrace?: CallFrame[];

// Identifier of the network request associated with this message.

networkRequestId?: NetworkDomain.RequestId;

}

export interface CallFrame {

// JavaScript function name.

functionName: string;

// JavaScript script name or url.

url: string;

// JavaScript script line number.

lineNumber: number;

// JavaScript script column number.

columnNumber: number;

}

export interface SetMonitoringXHREnabledMethodArguments {

// Monitoring enabled state.

enabled: boolean

}

export interface AddInspectedNodeMethodArguments {

// DOM node id to be accessible by means of $x command line API.

nodeId: DOMDomain.NodeId

}

export interface ConsoleDomainDispatcher {

// Enables console domain, sends the messages collected so far to the client by means of the <code>messageAdded</code> notification.

enable(): void;

// Disables console domain, prevents further console messages from being reported to the client.

disable(): void;

// Clears console messages collected in the browser.

clearMessages(): void;

// Toggles monitoring of XMLHttpRequest. If <code>true</code>, console will receive messages upon each XHR issued.

setMonitoringXHREnabled(params: SetMonitoringXHREnabledMethodArguments): void;

// Enables console to refer to the node with given id via $x (see Command Line API for more details $x functions).

addInspectedNode(params: AddInspectedNodeMethodArguments): void;

}

export class ConsoleFrontend {

constructor(private dispatchMessage: (message: String) => void) {

}

// Issued when new console message is added.

messageAdded(message: ConsoleMessage): void {

this.dispatchMessage(JSON.stringify( { "method": "Console.messageAdded", "params": { "message": message } } ));

}

// Issued when subsequent message(s) are equal to the previous one(s).

messageRepeatCountUpdated(count: number): void {

this.dispatchMessage(JSON.stringify( { "method": "Console.messageRepeatCountUpdated", "params": { "count": count } } ));

}

// Issued when console is cleared. This happens either upon <code>clearMessages</code> command or after page navigation.

messagesCleared(): void {

this.dispatchMessage(JSON.stringify( { "method": "Console.messagesCleared", "params": { } } ));

}

}

}

// DOM

// This domain exposes DOM read/write operations. Each DOM Node is represented with its mirror object that has an <code>id</code>. This <code>id</code> can be used to get additional information on the Node, resolve it into the JavaScript object wrapper, etc. It is important that client receives DOM events only for the nodes that are known to the client. Backend keeps track of the nodes that were sent to the client and never sends the same node twice. It is client's responsibility to collect information about the nodes that were sent to the client.<p>Note that <code>iframe</code> owner elements will return corresponding document elements as their child nodes.</p>

export namespace DOMDomain {

// Unique DOM node identifier.

export type NodeId = number

// Unique DOM node identifier used to reference a node that may not have been pushed to the front-end.

export type BackendNodeId = number

export interface Node {

// Node identifier that is passed into the rest of the DOM messages as the <code>nodeId</code>. Backend will only push node with given <code>id</code> once. It is aware of all requested nodes and will only fire DOM events for nodes known to the client.

nodeId: NodeId;

// <code>Node</code>'s nodeType.

nodeType: number;

// <code>Node</code>'s nodeName.

nodeName: string;

// <code>Node</code>'s localName.

localName: string;

// <code>Node</code>'s nodeValue.

nodeValue: string;

// Child count for <code>Container</code> nodes.

childNodeCount?: number;

// Child nodes of this node when requested with children.

children?: Node[];

// Attributes of the <code>Element</code> node in the form of flat array <code>[name1, value1, name2, value2]</code>.

attributes?: string[];

// Document URL that <code>Document</code> or <code>FrameOwner</code> node points to.

documentURL?: string;

// Base URL that <code>Document</code> or <code>FrameOwner</code> node uses for URL completion.

baseURL?: string;

// <code>DocumentType</code>'s publicId.

publicId?: string;

// <code>DocumentType</code>'s systemId.

systemId?: string;

// <code>DocumentType</code>'s internalSubset.

internalSubset?: string;

// <code>Document</code>'s XML version in case of XML documents.

xmlVersion?: string;

// <code>Attr</code>'s name.

name?: string;

// <code>Attr</code>'s value.

value?: string;

// Frame ID for frame owner elements.

frameId?: NetworkDomain.FrameId;

// Content document for frame owner elements.

contentDocument?: Node;

// Shadow root list for given element host.

shadowRoots?: Node[];

// Content document fragment for template elements

templateContent?: Node;

// Computed value for first recognized role token, default role per element, or overridden role.

role?: string;

}

export interface EventListener {

// <code>EventListener</code>'s type.

type: string;

// <code>EventListener</code>'s useCapture.

useCapture: boolean;

// <code>EventListener</code>'s isAttribute.

isAttribute: boolean;

// Target <code>DOMNode</code> id.

nodeId: NodeId;

// Event handler function body.

handlerBody: string;

// Handler code location.

location?: DebuggerDomain.Location;

// Source script URL.

sourceName?: string;

// Event handler function value.

handler?: RuntimeDomain.RemoteObject;

}

export interface AccessibilityProperties {

// <code>DOMNode</code> id of the accessibility object referenced by aria-activedescendant.

activeDescendantNodeId?: NodeId;

// Value of @aria-busy on current or ancestor node.

busy?: boolean;

// Checked state of certain form controls.

checked?: any /* true,false,mixed */;

// Array of <code>DOMNode</code> ids of the accessibility tree children if available.

childNodeIds?: NodeId[];

// Array of <code>DOMNode</code> ids of any nodes referenced via @aria-controls.

controlledNodeIds?: NodeId[];

// Disabled state of form controls.

disabled?: boolean;

// Indicates whether there is an existing AX object for the DOM node. If this is false, all the other properties will be default values.

exists: boolean;

// Expanded state.

expanded?: boolean;

// Array of <code>DOMNode</code> ids of any nodes referenced via @aria-flowto.

flowedNodeIds?: NodeId[];

// Focused state. Only defined on focusable elements.

focused?: boolean;

// Indicates whether the accessibility of the associated AX object node is ignored, whether heuristically or explicitly.

ignored?: boolean;

// State indicating whether the accessibility of the associated AX object node is ignored by default for node type.

ignoredByDefault?: boolean;

// Invalid status of form controls.

invalid?: any /* true,false,grammar,spelling */;

// Hidden state. True if node or an ancestor is hidden via CSS or explicit @aria-hidden, to clarify why the element is ignored.

hidden?: boolean;

// Computed label value for the node, sometimes calculated by referencing other nodes.

label: string;

// Value of @aria-atomic.

liveRegionAtomic?: boolean;

// Token value(s) of element's @aria-relevant attribute. Array of string values matching $ref LiveRegionRelevant. FIXME: Enum values blocked by http://webkit.org/b/133711

liveRegionRelevant?: string[];

// Value of element's @aria-live attribute.

liveRegionStatus?: any /* assertive,polite,off */;

// <code>DOMNode</code> id of node or closest ancestor node that has a mousedown, mouseup, or click event handler.

mouseEventNodeId?: NodeId;

// Target <code>DOMNode</code> id.

nodeId: NodeId;

// Array of <code>DOMNode</code> ids of any nodes referenced via @aria-owns.

ownedNodeIds?: NodeId[];

// <code>DOMNode</code> id of the accessibility tree parent object if available.

parentNodeId?: NodeId;

// Pressed state for toggle buttons.

pressed?: boolean;

// Readonly state of text controls.

readonly?: boolean;

// Required state of form controls.

required?: boolean;

// Computed value for first recognized role token, default role per element, or overridden role.

role: string;

// Selected state of certain form controls.

selected?: boolean;

// Array of <code>DOMNode</code> ids of any children marked as selected.

selectedChildNodeIds?: NodeId[];

}

export interface RGBAColor {

// The red component, in the [0-255] range.

r: number;

// The green component, in the [0-255] range.

g: number;

// The blue component, in the [0-255] range.

b: number;

// The alpha component, in the [0-1] range (default: 1).

a?: number;

}

export interface HighlightConfig {

// Whether the node info tooltip should be shown (default: false).

showInfo?: boolean;

// The content box highlight fill color (default: transparent).

contentColor?: RGBAColor;

// The padding highlight fill color (default: transparent).

paddingColor?: RGBAColor;

// The border highlight fill color (default: transparent).

borderColor?: RGBAColor;

// The margin highlight fill color (default: transparent).

marginColor?: RGBAColor;

}

export const enum LiveRegionRelevant { Additions, Removals, Text };

export interface RequestChildNodesMethodArguments {

// Id of the node to get children for.

nodeId: NodeId,

// The maximum depth at which children should be retrieved, defaults to 1. Use -1 for the entire subtree or provide an integer larger than 0.

depth?: number

}

export interface QuerySelectorMethodArguments {

// Id of the node to query upon.

nodeId: NodeId,

// Selector string.

selector: string

}

export interface QuerySelectorAllMethodArguments {

// Id of the node to query upon.

nodeId: NodeId,

// Selector string.

selector: string

}

export interface SetNodeNameMethodArguments {

// Id of the node to set name for.

nodeId: NodeId,

// New node's name.

name: string

}

export interface SetNodeValueMethodArguments {

// Id of the node to set value for.

nodeId: NodeId,

// New node's value.

value: string

}

export interface RemoveNodeMethodArguments {

// Id of the node to remove.

nodeId: NodeId

}

export interface SetAttributeValueMethodArguments {

// Id of the element to set attribute for.

nodeId: NodeId,

// Attribute name.

name: string,

// Attribute value.

value: string

}

export interface SetAttributesAsTextMethodArguments {

// Id of the element to set attributes for.

nodeId: NodeId,

// Text with a number of attributes. Will parse this text using HTML parser.

text: string,

// Attribute name to replace with new attributes derived from text in case text parsed successfully.

name?: string

}

export interface RemoveAttributeMethodArguments {

// Id of the element to remove attribute from.

nodeId: NodeId,

// Name of the attribute to remove.

name: string

}

export interface GetEventListenersForNodeMethodArguments {

// Id of the node to get listeners for.

nodeId: NodeId,

// Symbolic group name for handler value. Handler value is not returned without this parameter specified.

objectGroup?: string

}

export interface GetAccessibilityPropertiesForNodeMethodArguments {

// Id of the node for which to get accessibility properties.

nodeId: NodeId

}

export interface GetOuterHTMLMethodArguments {

// Id of the node to get markup for.

nodeId: NodeId

}

export interface SetOuterHTMLMethodArguments {

// Id of the node to set markup for.

nodeId: NodeId,

// Outer HTML markup to set.

outerHTML: string

}

export interface PerformSearchMethodArguments {

// Plain text or query selector or XPath search query.

query: string,

// Ids of nodes to use as starting points for the search.

nodeIds?: NodeId[]

}

export interface GetSearchResultsMethodArguments {

// Unique search session identifier.

searchId: string,

// Start index of the search result to be returned.

fromIndex: number,

// End index of the search result to be returned.

toIndex: number

}

export interface DiscardSearchResultsMethodArguments {

// Unique search session identifier.

searchId: string

}

export interface RequestNodeMethodArguments {

// JavaScript object id to convert into node.

objectId: RuntimeDomain.RemoteObjectId

}

export interface SetInspectModeEnabledMethodArguments {

// True to enable inspection mode, false to disable it.

enabled: boolean,

// A descriptor for the highlight appearance of hovered-over nodes. May be omitted if <code>enabled == false</code>.

highlightConfig?: HighlightConfig

}

export interface HighlightRectMethodArguments {

// X coordinate

x: number,

// Y coordinate

y: number,

// Rectangle width

width: number,

// Rectangle height

height: number,

// The highlight fill color (default: transparent).

color?: RGBAColor,

// The highlight outline color (default: transparent).

outlineColor?: RGBAColor,

// Indicates whether the provided parameters are in page coordinates or in viewport coordinates (the default).

usePageCoordinates?: boolean

}

export interface HighlightQuadMethodArguments {

// Quad to highlight

quad: number[],

// The highlight fill color (default: transparent).

color?: RGBAColor,

// The highlight outline color (default: transparent).

outlineColor?: RGBAColor,

// Indicates whether the provided parameters are in page coordinates or in viewport coordinates (the default).

usePageCoordinates?: boolean

}

export interface HighlightSelectorMethodArguments {

// A descriptor for the highlight appearance.

highlightConfig: HighlightConfig,

// A CSS selector for finding matching nodes to highlight.

selectorString: string,

// Identifier of the frame which will be searched using the selector. If not provided, the main frame will be used.

frameId?: string

}

export interface HighlightNodeMethodArguments {

// A descriptor for the highlight appearance.

highlightConfig: HighlightConfig,

// Identifier of the node to highlight.

nodeId?: NodeId,

// JavaScript object id of the node to be highlighted.

objectId?: RuntimeDomain.RemoteObjectId

}

export interface HighlightFrameMethodArguments {

// Identifier of the frame to highlight.

frameId: NetworkDomain.FrameId,

// The content box highlight fill color (default: transparent).

contentColor?: RGBAColor,

// The content box highlight outline color (default: transparent).

contentOutlineColor?: RGBAColor

}

export interface PushNodeByPathToFrontendMethodArguments {

// Path to node in the proprietary format.

path: string

}

export interface PushNodeByBackendIdToFrontendMethodArguments {

// The backend node id of the node.

backendNodeId: BackendNodeId

}

export interface ReleaseBackendNodeIdsMethodArguments {

// The backend node ids group name.

nodeGroup: string

}

export interface ResolveNodeMethodArguments {

// Id of the node to resolve.

nodeId: NodeId,

// Symbolic group name that can be used to release multiple objects.

objectGroup?: string

}

export interface GetAttributesMethodArguments {

// Id of the node to retrieve attibutes for.

nodeId: NodeId

}

export interface MoveToMethodArguments {

// Id of the node to drop.

nodeId: NodeId,

// Id of the element to drop into.

targetNodeId: NodeId,

// Drop node before given one.

insertBeforeNodeId?: NodeId

}

export interface FocusMethodArguments {

// Id of the node to focus.

nodeId: NodeId

}

export interface DOMDomainDispatcher {

// Returns the root DOM node to the caller.

getDocument(): { root: Node };

// Requests that children of the node with given id are returned to the caller in form of <code>setChildNodes</code> events where not only immediate children are retrieved, but all children down to the specified depth.

requestChildNodes(params: RequestChildNodesMethodArguments): void;

// Executes <code>querySelector</code> on a given node.

querySelector(params: QuerySelectorMethodArguments): { nodeId: NodeId };

// Executes <code>querySelectorAll</code> on a given node.

querySelectorAll(params: QuerySelectorAllMethodArguments): { nodeIds: NodeId[] };

// Sets node name for a node with given id.

setNodeName(params: SetNodeNameMethodArguments): { nodeId: NodeId };

// Sets node value for a node with given id.

setNodeValue(params: SetNodeValueMethodArguments): void;

// Removes node with given id.

removeNode(params: RemoveNodeMethodArguments): void;

// Sets attribute for an element with given id.

setAttributeValue(params: SetAttributeValueMethodArguments): void;

// Sets attributes on element with given id. This method is useful when user edits some existing attribute value and types in several attribute name/value pairs.

setAttributesAsText(params: SetAttributesAsTextMethodArguments): void;

// Removes attribute with given name from an element with given id.

removeAttribute(params: RemoveAttributeMethodArguments): void;

// Returns event listeners relevant to the node.

getEventListenersForNode(params: GetEventListenersForNodeMethodArguments): { listeners: EventListener[] };

// Returns a dictionary of accessibility properties for the node.

getAccessibilityPropertiesForNode(params: GetAccessibilityPropertiesForNodeMethodArguments): { properties: AccessibilityProperties };

// Returns node's HTML markup.

getOuterHTML(params: GetOuterHTMLMethodArguments): { outerHTML: string };

// Sets node HTML markup, returns new node id.

setOuterHTML(params: SetOuterHTMLMethodArguments): void;

// Searches for a given string in the DOM tree. Use <code>getSearchResults</code> to access search results or <code>cancelSearch</code> to end this search session.

performSearch(params: PerformSearchMethodArguments): { searchId: string, resultCount: number };

// Returns search results from given <code>fromIndex</code> to given <code>toIndex</code> from the sarch with the given identifier.

getSearchResults(params: GetSearchResultsMethodArguments): { nodeIds: NodeId[] };

// Discards search results from the session with the given id. <code>getSearchResults</code> should no longer be called for that search.

discardSearchResults(params: DiscardSearchResultsMethodArguments): void;

// Requests that the node is sent to the caller given the JavaScript node object reference. All nodes that form the path from the node to the root are also sent to the client as a series of <code>setChildNodes</code> notifications.

requestNode(params: RequestNodeMethodArguments): { nodeId: NodeId };

// Enters the 'inspect' mode. In this mode, elements that user is hovering over are highlighted. Backend then generates 'inspect' command upon element selection.

setInspectModeEnabled(params: SetInspectModeEnabledMethodArguments): void;

// Highlights given rectangle. Coordinates are absolute with respect to the main frame viewport.

highlightRect(params: HighlightRectMethodArguments): void;

// Highlights given quad. Coordinates are absolute with respect to the main frame viewport.

highlightQuad(params: HighlightQuadMethodArguments): void;

// Highlights all DOM nodes that match a given selector. A string containing a CSS selector must be specified.

highlightSelector(params: HighlightSelectorMethodArguments): void;

// Highlights DOM node with given id or with the given JavaScript object wrapper. Either nodeId or objectId must be specified.

highlightNode(params: HighlightNodeMethodArguments): void;

// Hides DOM node highlight.

hideHighlight(): void;

// Highlights owner element of the frame with given id.

highlightFrame(params: HighlightFrameMethodArguments): void;

// Requests that the node is sent to the caller given its path. // FIXME, use XPath

pushNodeByPathToFrontend(params: PushNodeByPathToFrontendMethodArguments): { nodeId: NodeId };

// Requests that the node is sent to the caller given its backend node id.

pushNodeByBackendIdToFrontend(params: PushNodeByBackendIdToFrontendMethodArguments): { nodeId: NodeId };

// Requests that group of <code>BackendNodeIds</code> is released.

releaseBackendNodeIds(params: ReleaseBackendNodeIdsMethodArguments): void;

// Resolves JavaScript node object for given node id.

resolveNode(params: ResolveNodeMethodArguments): { object: RuntimeDomain.RemoteObject };

// Returns attributes for the specified node.

getAttributes(params: GetAttributesMethodArguments): { attributes: string[] };

// Moves node into the new container, places it before the given anchor.

moveTo(params: MoveToMethodArguments): { nodeId: NodeId };

// Undoes the last performed action.

undo(): void;

// Re-does the last undone action.

redo(): void;

// Marks last undoable state.

markUndoableState(): void;

// Focuses the given element.

focus(params: FocusMethodArguments): void;

}

export class DOMFrontend {

constructor(private dispatchMessage: (message: String) => void) {

}

// Fired when <code>Document</code> has been totally updated. Node ids are no longer valid.

documentUpdated(): void {

this.dispatchMessage(JSON.stringify( { "method": "DOM.documentUpdated", "params": { } } ));

}

// Fired when backend wants to provide client with the missing DOM structure. This happens upon most of the calls requesting node ids.

setChildNodes(parentId: NodeId, nodes: Node[]): void {

this.dispatchMessage(JSON.stringify( { "method": "DOM.setChildNodes", "params": { "parentId": parentId, "nodes": nodes } } ));

}

// Fired when <code>Element</code>'s attribute is modified.

attributeModified(nodeId: NodeId, name: string, value: string): void {

this.dispatchMessage(JSON.stringify( { "method": "DOM.attributeModified", "params": { "nodeId": nodeId, "name": name, "value": value } } ));

}

// Fired when <code>Element</code>'s attribute is removed.

attributeRemoved(nodeId: NodeId, name: string): void {

this.dispatchMessage(JSON.stringify( { "method": "DOM.attributeRemoved", "params": { "nodeId": nodeId, "name": name } } ));

}

// Fired when <code>Element</code>'s inline style is modified via a CSS property modification.

inlineStyleInvalidated(nodeIds: NodeId[]): void {

this.dispatchMessage(JSON.stringify( { "method": "DOM.inlineStyleInvalidated", "params": { "nodeIds": nodeIds } } ));

}

// Mirrors <code>DOMCharacterDataModified</code> event.

characterDataModified(nodeId: NodeId, characterData: string): void {

this.dispatchMessage(JSON.stringify( { "method": "DOM.characterDataModified", "params": { "nodeId": nodeId, "characterData": characterData } } ));

}

// Fired when <code>Container</code>'s child node count has changed.

childNodeCountUpdated(nodeId: NodeId, childNodeCount: number): void {

this.dispatchMessage(JSON.stringify( { "method": "DOM.childNodeCountUpdated", "params": { "nodeId": nodeId, "childNodeCount": childNodeCount } } ));

}

// Mirrors <code>DOMNodeInserted</code> event.

childNodeInserted(parentNodeId: NodeId, previousNodeId: NodeId, node: Node): void {

this.dispatchMessage(JSON.stringify( { "method": "DOM.childNodeInserted", "params": { "parentNodeId": parentNodeId, "previousNodeId": previousNodeId, "node": node } } ));

}

// Mirrors <code>DOMNodeRemoved</code> event.

childNodeRemoved(parentNodeId: NodeId, nodeId: NodeId): void {

this.dispatchMessage(JSON.stringify( { "method": "DOM.childNodeRemoved", "params": { "parentNodeId": parentNodeId, "nodeId": nodeId } } ));

}

// Called when shadow root is pushed into the element.

shadowRootPushed(hostId: NodeId, root: Node): void {

this.dispatchMessage(JSON.stringify( { "method": "DOM.shadowRootPushed", "params": { "hostId": hostId, "root": root } } ));

}

// Called when shadow root is popped from the element.

shadowRootPopped(hostId: NodeId, rootId: NodeId): void {

this.dispatchMessage(JSON.stringify( { "method": "DOM.shadowRootPopped", "params": { "hostId": hostId, "rootId": rootId } } ));

}

}

}

// DOMDebugger

// DOM debugging allows setting breakpoints on particular DOM operations and events. JavaScript execution will stop on these operations as if there was a regular breakpoint set.

export namespace DOMDebuggerDomain {

export const enum DOMBreakpointType { SubtreeModified, AttributeModified, NodeRemoved };

export interface SetDOMBreakpointMethodArguments {

// Identifier of the node to set breakpoint on.

nodeId: DOMDomain.NodeId,

// Type of the operation to stop upon.

type: DOMBreakpointType

}

export interface RemoveDOMBreakpointMethodArguments {

// Identifier of the node to remove breakpoint from.

nodeId: DOMDomain.NodeId,

// Type of the breakpoint to remove.

type: DOMBreakpointType

}

export interface SetEventListenerBreakpointMethodArguments {

// DOM Event name to stop on (any DOM event will do).

eventName: string

}

export interface RemoveEventListenerBreakpointMethodArguments {

// Event name.

eventName: string

}

export interface SetInstrumentationBreakpointMethodArguments {

// Instrumentation name to stop on.

eventName: string

}

export interface RemoveInstrumentationBreakpointMethodArguments {

// Instrumentation name to stop on.

eventName: string

}

export interface SetXHRBreakpointMethodArguments {

// Resource URL substring. All XHRs having this substring in the URL will get stopped upon.

url: string

}

export interface RemoveXHRBreakpointMethodArguments {

// Resource URL substring.

url: string

}

export interface DOMDebuggerDomainDispatcher {

// Sets breakpoint on particular operation with DOM.

setDOMBreakpoint(params: SetDOMBreakpointMethodArguments): void;

// Removes DOM breakpoint that was set using <code>setDOMBreakpoint</code>.

removeDOMBreakpoint(params: RemoveDOMBreakpointMethodArguments): void;

// Sets breakpoint on particular DOM event.

setEventListenerBreakpoint(params: SetEventListenerBreakpointMethodArguments): void;

// Removes breakpoint on particular DOM event.

removeEventListenerBreakpoint(params: RemoveEventListenerBreakpointMethodArguments): void;

// Sets breakpoint on particular native event.

setInstrumentationBreakpoint(params: SetInstrumentationBreakpointMethodArguments): void;

// Sets breakpoint on particular native event.

removeInstrumentationBreakpoint(params: RemoveInstrumentationBreakpointMethodArguments): void;

// Sets breakpoint on XMLHttpRequest.

setXHRBreakpoint(params: SetXHRBreakpointMethodArguments): void;

// Removes breakpoint from XMLHttpRequest.

removeXHRBreakpoint(params: RemoveXHRBreakpointMethodArguments): void;

}

}

// DOMStorage

// Query and modify DOM storage.

export namespace DOMStorageDomain {