// Package dom provides the Chrome DevTools Protocol
// commands, types, and events for the DOM domain.
//
// This domain exposes DOM read/write operations. Each DOM Node is
// represented with its mirror object that has an id. This id 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. Note that iframe owner elements will return corresponding document
// elements as their child nodes.
//
// Generated by the cdproto-gen command.
package dom

// Code generated by cdproto-gen. DO NOT EDIT.

import (
	"context"

	"github.com/chromedp/cdproto/cdp"
	"github.com/chromedp/cdproto/runtime"
)

// CollectClassNamesFromSubtreeParams collects class names for the node with
// given id and all of it's child nodes.
type CollectClassNamesFromSubtreeParams struct {
	NodeID cdp.NodeID `json:"nodeId"` // Id of the node to collect class names.
}

// CollectClassNamesFromSubtree collects class names for the node with given
// id and all of it's child nodes.
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-collectClassNamesFromSubtree
//
// parameters:
//
//	nodeID - Id of the node to collect class names.
func CollectClassNamesFromSubtree(nodeID cdp.NodeID) *CollectClassNamesFromSubtreeParams {
	return &CollectClassNamesFromSubtreeParams{
		NodeID: nodeID,
	}
}

// CollectClassNamesFromSubtreeReturns return values.
type CollectClassNamesFromSubtreeReturns struct {
	ClassNames []string `json:"classNames,omitempty"` // Class name list.
}

// Do executes DOM.collectClassNamesFromSubtree against the provided context.
//
// returns:
//
//	classNames - Class name list.
func (p *CollectClassNamesFromSubtreeParams) Do(ctx context.Context) (classNames []string, err error) {
	// execute
	var res CollectClassNamesFromSubtreeReturns
	err = cdp.Execute(ctx, CommandCollectClassNamesFromSubtree, p, &res)
	if err != nil {
		return nil, err
	}

	return res.ClassNames, nil
}

// CopyToParams creates a deep copy of the specified node and places it into
// the target container before the given anchor.
type CopyToParams struct {
	NodeID             cdp.NodeID `json:"nodeId"`                       // Id of the node to copy.
	TargetNodeID       cdp.NodeID `json:"targetNodeId"`                 // Id of the element to drop the copy into.
	InsertBeforeNodeID cdp.NodeID `json:"insertBeforeNodeId,omitempty"` // Drop the copy before this node (if absent, the copy becomes the last child of targetNodeId).
}

// CopyTo creates a deep copy of the specified node and places it into the
// target container before the given anchor.
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-copyTo
//
// parameters:
//
//	nodeID - Id of the node to copy.
//	targetNodeID - Id of the element to drop the copy into.
func CopyTo(nodeID cdp.NodeID, targetNodeID cdp.NodeID) *CopyToParams {
	return &CopyToParams{
		NodeID:       nodeID,
		TargetNodeID: targetNodeID,
	}
}

// WithInsertBeforeNodeID drop the copy before this node (if absent, the copy
// becomes the last child of targetNodeId).
func (p CopyToParams) WithInsertBeforeNodeID(insertBeforeNodeID cdp.NodeID) *CopyToParams {
	p.InsertBeforeNodeID = insertBeforeNodeID
	return &p
}

// CopyToReturns return values.
type CopyToReturns struct {
	NodeID cdp.NodeID `json:"nodeId,omitempty"` // Id of the node clone.
}

// Do executes DOM.copyTo against the provided context.
//
// returns:
//
//	nodeID - Id of the node clone.
func (p *CopyToParams) Do(ctx context.Context) (nodeID cdp.NodeID, err error) {
	// execute
	var res CopyToReturns
	err = cdp.Execute(ctx, CommandCopyTo, p, &res)
	if err != nil {
		return 0, err
	}

	return res.NodeID, nil
}

// DescribeNodeParams describes node given its id, does not require domain to
// be enabled. Does not start tracking any objects, can be used for automation.
type DescribeNodeParams struct {
	NodeID        cdp.NodeID             `json:"nodeId,omitempty"`        // Identifier of the node.
	BackendNodeID cdp.BackendNodeID      `json:"backendNodeId,omitempty"` // Identifier of the backend node.
	ObjectID      runtime.RemoteObjectID `json:"objectId,omitempty"`      // JavaScript object id of the node wrapper.
	Depth         int64                  `json:"depth,omitempty"`         // 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.
	Pierce        bool                   `json:"pierce,omitempty"`        // Whether or not iframes and shadow roots should be traversed when returning the subtree (default is false).
}

// DescribeNode describes node given its id, does not require domain to be
// enabled. Does not start tracking any objects, can be used for automation.
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-describeNode
//
// parameters:
func DescribeNode() *DescribeNodeParams {
	return &DescribeNodeParams{}
}

// WithNodeID identifier of the node.
func (p DescribeNodeParams) WithNodeID(nodeID cdp.NodeID) *DescribeNodeParams {
	p.NodeID = nodeID
	return &p
}

// WithBackendNodeID identifier of the backend node.
func (p DescribeNodeParams) WithBackendNodeID(backendNodeID cdp.BackendNodeID) *DescribeNodeParams {
	p.BackendNodeID = backendNodeID
	return &p
}

// WithObjectID JavaScript object id of the node wrapper.
func (p DescribeNodeParams) WithObjectID(objectID runtime.RemoteObjectID) *DescribeNodeParams {
	p.ObjectID = objectID
	return &p
}

// WithDepth 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.
func (p DescribeNodeParams) WithDepth(depth int64) *DescribeNodeParams {
	p.Depth = depth
	return &p
}

// WithPierce whether or not iframes and shadow roots should be traversed
// when returning the subtree (default is false).
func (p DescribeNodeParams) WithPierce(pierce bool) *DescribeNodeParams {
	p.Pierce = pierce
	return &p
}

// DescribeNodeReturns return values.
type DescribeNodeReturns struct {
	Node *cdp.Node `json:"node,omitempty"` // Node description.
}

// Do executes DOM.describeNode against the provided context.
//
// returns:
//
//	node - Node description.
func (p *DescribeNodeParams) Do(ctx context.Context) (node *cdp.Node, err error) {
	// execute
	var res DescribeNodeReturns
	err = cdp.Execute(ctx, CommandDescribeNode, p, &res)
	if err != nil {
		return nil, err
	}

	return res.Node, nil
}

// ScrollIntoViewIfNeededParams scrolls the specified rect of the given node
// into view if not already visible. Note: exactly one between nodeId,
// backendNodeId and objectId should be passed to identify the node.
type ScrollIntoViewIfNeededParams struct {
	NodeID        cdp.NodeID             `json:"nodeId,omitempty"`        // Identifier of the node.
	BackendNodeID cdp.BackendNodeID      `json:"backendNodeId,omitempty"` // Identifier of the backend node.
	ObjectID      runtime.RemoteObjectID `json:"objectId,omitempty"`      // JavaScript object id of the node wrapper.
	Rect          *Rect                  `json:"rect,omitempty"`          // The rect to be scrolled into view, relative to the node's border box, in CSS pixels. When omitted, center of the node will be used, similar to Element.scrollIntoView.
}

// ScrollIntoViewIfNeeded scrolls the specified rect of the given node into
// view if not already visible. Note: exactly one between nodeId, backendNodeId
// and objectId should be passed to identify the node.
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-scrollIntoViewIfNeeded
//
// parameters:
func ScrollIntoViewIfNeeded() *ScrollIntoViewIfNeededParams {
	return &ScrollIntoViewIfNeededParams{}
}

// WithNodeID identifier of the node.
func (p ScrollIntoViewIfNeededParams) WithNodeID(nodeID cdp.NodeID) *ScrollIntoViewIfNeededParams {
	p.NodeID = nodeID
	return &p
}

// WithBackendNodeID identifier of the backend node.
func (p ScrollIntoViewIfNeededParams) WithBackendNodeID(backendNodeID cdp.BackendNodeID) *ScrollIntoViewIfNeededParams {
	p.BackendNodeID = backendNodeID
	return &p
}

// WithObjectID JavaScript object id of the node wrapper.
func (p ScrollIntoViewIfNeededParams) WithObjectID(objectID runtime.RemoteObjectID) *ScrollIntoViewIfNeededParams {
	p.ObjectID = objectID
	return &p
}

// WithRect the rect to be scrolled into view, relative to the node's border
// box, in CSS pixels. When omitted, center of the node will be used, similar to
// Element.scrollIntoView.
func (p ScrollIntoViewIfNeededParams) WithRect(rect *Rect) *ScrollIntoViewIfNeededParams {
	p.Rect = rect
	return &p
}

// Do executes DOM.scrollIntoViewIfNeeded against the provided context.
func (p *ScrollIntoViewIfNeededParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandScrollIntoViewIfNeeded, p, nil)
}

// DisableParams disables DOM agent for the given page.
type DisableParams struct{}

// Disable disables DOM agent for the given page.
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-disable
func Disable() *DisableParams {
	return &DisableParams{}
}

// Do executes DOM.disable against the provided context.
func (p *DisableParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandDisable, nil, nil)
}

// DiscardSearchResultsParams discards search results from the session with
// the given id. getSearchResults should no longer be called for that search.
type DiscardSearchResultsParams struct {
	SearchID string `json:"searchId"` // Unique search session identifier.
}

// DiscardSearchResults discards search results from the session with the
// given id. getSearchResults should no longer be called for that search.
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-discardSearchResults
//
// parameters:
//
//	searchID - Unique search session identifier.
func DiscardSearchResults(searchID string) *DiscardSearchResultsParams {
	return &DiscardSearchResultsParams{
		SearchID: searchID,
	}
}

// Do executes DOM.discardSearchResults against the provided context.
func (p *DiscardSearchResultsParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandDiscardSearchResults, p, nil)
}

// EnableParams enables DOM agent for the given page.
type EnableParams struct {
	IncludeWhitespace EnableIncludeWhitespace `json:"includeWhitespace,omitempty"` // Whether to include whitespaces in the children array of returned Nodes.
}

// Enable enables DOM agent for the given page.
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-enable
//
// parameters:
func Enable() *EnableParams {
	return &EnableParams{}
}

// WithIncludeWhitespace whether to include whitespaces in the children array
// of returned Nodes.
func (p EnableParams) WithIncludeWhitespace(includeWhitespace EnableIncludeWhitespace) *EnableParams {
	p.IncludeWhitespace = includeWhitespace
	return &p
}

// Do executes DOM.enable against the provided context.
func (p *EnableParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandEnable, p, nil)
}

// FocusParams focuses the given element.
type FocusParams struct {
	NodeID        cdp.NodeID             `json:"nodeId,omitempty"`        // Identifier of the node.
	BackendNodeID cdp.BackendNodeID      `json:"backendNodeId,omitempty"` // Identifier of the backend node.
	ObjectID      runtime.RemoteObjectID `json:"objectId,omitempty"`      // JavaScript object id of the node wrapper.
}

// Focus focuses the given element.
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-focus
//
// parameters:
func Focus() *FocusParams {
	return &FocusParams{}
}

// WithNodeID identifier of the node.
func (p FocusParams) WithNodeID(nodeID cdp.NodeID) *FocusParams {
	p.NodeID = nodeID
	return &p
}

// WithBackendNodeID identifier of the backend node.
func (p FocusParams) WithBackendNodeID(backendNodeID cdp.BackendNodeID) *FocusParams {
	p.BackendNodeID = backendNodeID
	return &p
}

// WithObjectID JavaScript object id of the node wrapper.
func (p FocusParams) WithObjectID(objectID runtime.RemoteObjectID) *FocusParams {
	p.ObjectID = objectID
	return &p
}

// Do executes DOM.focus against the provided context.
func (p *FocusParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandFocus, p, nil)
}

// GetAttributesParams returns attributes for the specified node.
type GetAttributesParams struct {
	NodeID cdp.NodeID `json:"nodeId"` // Id of the node to retrieve attributes for.
}

// GetAttributes returns attributes for the specified node.
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-getAttributes
//
// parameters:
//
//	nodeID - Id of the node to retrieve attributes for.
func GetAttributes(nodeID cdp.NodeID) *GetAttributesParams {
	return &GetAttributesParams{
		NodeID: nodeID,
	}
}

// GetAttributesReturns return values.
type GetAttributesReturns struct {
	Attributes []string `json:"attributes,omitempty"` // An interleaved array of node attribute names and values.
}

// Do executes DOM.getAttributes against the provided context.
//
// returns:
//
//	attributes - An interleaved array of node attribute names and values.
func (p *GetAttributesParams) Do(ctx context.Context) (attributes []string, err error) {
	// execute
	var res GetAttributesReturns
	err = cdp.Execute(ctx, CommandGetAttributes, p, &res)
	if err != nil {
		return nil, err
	}

	return res.Attributes, nil
}

// GetBoxModelParams returns boxes for the given node.
type GetBoxModelParams struct {
	NodeID        cdp.NodeID             `json:"nodeId,omitempty"`        // Identifier of the node.
	BackendNodeID cdp.BackendNodeID      `json:"backendNodeId,omitempty"` // Identifier of the backend node.
	ObjectID      runtime.RemoteObjectID `json:"objectId,omitempty"`      // JavaScript object id of the node wrapper.
}

// GetBoxModel returns boxes for the given node.
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-getBoxModel
//
// parameters:
func GetBoxModel() *GetBoxModelParams {
	return &GetBoxModelParams{}
}

// WithNodeID identifier of the node.
func (p GetBoxModelParams) WithNodeID(nodeID cdp.NodeID) *GetBoxModelParams {
	p.NodeID = nodeID
	return &p
}

// WithBackendNodeID identifier of the backend node.
func (p GetBoxModelParams) WithBackendNodeID(backendNodeID cdp.BackendNodeID) *GetBoxModelParams {
	p.BackendNodeID = backendNodeID
	return &p
}

// WithObjectID JavaScript object id of the node wrapper.
func (p GetBoxModelParams) WithObjectID(objectID runtime.RemoteObjectID) *GetBoxModelParams {
	p.ObjectID = objectID
	return &p
}

// GetBoxModelReturns return values.
type GetBoxModelReturns struct {
	Model *BoxModel `json:"model,omitempty"` // Box model for the node.
}

// Do executes DOM.getBoxModel against the provided context.
//
// returns:
//
//	model - Box model for the node.
func (p *GetBoxModelParams) Do(ctx context.Context) (model *BoxModel, err error) {
	// execute
	var res GetBoxModelReturns
	err = cdp.Execute(ctx, CommandGetBoxModel, p, &res)
	if err != nil {
		return nil, err
	}

	return res.Model, nil
}

// GetContentQuadsParams returns quads that describe node position on the
// page. This method might return multiple quads for inline nodes.
type GetContentQuadsParams struct {
	NodeID        cdp.NodeID             `json:"nodeId,omitempty"`        // Identifier of the node.
	BackendNodeID cdp.BackendNodeID      `json:"backendNodeId,omitempty"` // Identifier of the backend node.
	ObjectID      runtime.RemoteObjectID `json:"objectId,omitempty"`      // JavaScript object id of the node wrapper.
}

// GetContentQuads returns quads that describe node position on the page.
// This method might return multiple quads for inline nodes.
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-getContentQuads
//
// parameters:
func GetContentQuads() *GetContentQuadsParams {
	return &GetContentQuadsParams{}
}

// WithNodeID identifier of the node.
func (p GetContentQuadsParams) WithNodeID(nodeID cdp.NodeID) *GetContentQuadsParams {
	p.NodeID = nodeID
	return &p
}

// WithBackendNodeID identifier of the backend node.
func (p GetContentQuadsParams) WithBackendNodeID(backendNodeID cdp.BackendNodeID) *GetContentQuadsParams {
	p.BackendNodeID = backendNodeID
	return &p
}

// WithObjectID JavaScript object id of the node wrapper.
func (p GetContentQuadsParams) WithObjectID(objectID runtime.RemoteObjectID) *GetContentQuadsParams {
	p.ObjectID = objectID
	return &p
}

// GetContentQuadsReturns return values.
type GetContentQuadsReturns struct {
	Quads []Quad `json:"quads,omitempty"` // Quads that describe node layout relative to viewport.
}

// Do executes DOM.getContentQuads against the provided context.
//
// returns:
//
//	quads - Quads that describe node layout relative to viewport.
func (p *GetContentQuadsParams) Do(ctx context.Context) (quads []Quad, err error) {
	// execute
	var res GetContentQuadsReturns
	err = cdp.Execute(ctx, CommandGetContentQuads, p, &res)
	if err != nil {
		return nil, err
	}

	return res.Quads, nil
}

// GetDocumentParams returns the root DOM node (and optionally the subtree)
// to the caller. Implicitly enables the DOM domain events for the current
// target.
type GetDocumentParams struct {
	Depth  int64 `json:"depth,omitempty"`  // 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.
	Pierce bool  `json:"pierce,omitempty"` // Whether or not iframes and shadow roots should be traversed when returning the subtree (default is false).
}

// GetDocument returns the root DOM node (and optionally the subtree) to the
// caller. Implicitly enables the DOM domain events for the current target.
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-getDocument
//
// parameters:
func GetDocument() *GetDocumentParams {
	return &GetDocumentParams{}
}

// WithDepth 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.
func (p GetDocumentParams) WithDepth(depth int64) *GetDocumentParams {
	p.Depth = depth
	return &p
}

// WithPierce whether or not iframes and shadow roots should be traversed
// when returning the subtree (default is false).
func (p GetDocumentParams) WithPierce(pierce bool) *GetDocumentParams {
	p.Pierce = pierce
	return &p
}

// GetDocumentReturns return values.
type GetDocumentReturns struct {
	Root *cdp.Node `json:"root,omitempty"` // Resulting node.
}

// Do executes DOM.getDocument against the provided context.
//
// returns:
//
//	root - Resulting node.
func (p *GetDocumentParams) Do(ctx context.Context) (root *cdp.Node, err error) {
	// execute
	var res GetDocumentReturns
	err = cdp.Execute(ctx, CommandGetDocument, p, &res)
	if err != nil {
		return nil, err
	}

	return res.Root, nil
}

// GetNodesForSubtreeByStyleParams finds nodes with a given computed style in
// a subtree.
type GetNodesForSubtreeByStyleParams struct {
	NodeID         cdp.NodeID                  `json:"nodeId"`           // Node ID pointing to the root of a subtree.
	ComputedStyles []*CSSComputedStyleProperty `json:"computedStyles"`   // The style to filter nodes by (includes nodes if any of properties matches).
	Pierce         bool                        `json:"pierce,omitempty"` // Whether or not iframes and shadow roots in the same target should be traversed when returning the results (default is false).
}

// GetNodesForSubtreeByStyle finds nodes with a given computed style in a
// subtree.
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-getNodesForSubtreeByStyle
//
// parameters:
//
//	nodeID - Node ID pointing to the root of a subtree.
//	computedStyles - The style to filter nodes by (includes nodes if any of properties matches).
func GetNodesForSubtreeByStyle(nodeID cdp.NodeID, computedStyles []*CSSComputedStyleProperty) *GetNodesForSubtreeByStyleParams {
	return &GetNodesForSubtreeByStyleParams{
		NodeID:         nodeID,
		ComputedStyles: computedStyles,
	}
}

// WithPierce whether or not iframes and shadow roots in the same target
// should be traversed when returning the results (default is false).
func (p GetNodesForSubtreeByStyleParams) WithPierce(pierce bool) *GetNodesForSubtreeByStyleParams {
	p.Pierce = pierce
	return &p
}

// GetNodesForSubtreeByStyleReturns return values.
type GetNodesForSubtreeByStyleReturns struct {
	NodeIDs []cdp.NodeID `json:"nodeIds,omitempty"` // Resulting nodes.
}

// Do executes DOM.getNodesForSubtreeByStyle against the provided context.
//
// returns:
//
//	nodeIDs - Resulting nodes.
func (p *GetNodesForSubtreeByStyleParams) Do(ctx context.Context) (nodeIDs []cdp.NodeID, err error) {
	// execute
	var res GetNodesForSubtreeByStyleReturns
	err = cdp.Execute(ctx, CommandGetNodesForSubtreeByStyle, p, &res)
	if err != nil {
		return nil, err
	}

	return res.NodeIDs, nil
}

// GetNodeForLocationParams returns node id at given location. Depending on
// whether DOM domain is enabled, nodeId is either returned or not.
type GetNodeForLocationParams struct {
	X                         int64 `json:"x"`                                   // X coordinate.
	Y                         int64 `json:"y"`                                   // Y coordinate.
	IncludeUserAgentShadowDOM bool  `json:"includeUserAgentShadowDOM,omitempty"` // False to skip to the nearest non-UA shadow root ancestor (default: false).
	IgnorePointerEventsNone   bool  `json:"ignorePointerEventsNone,omitempty"`   // Whether to ignore pointer-events: none on elements and hit test them.
}

// GetNodeForLocation returns node id at given location. Depending on whether
// DOM domain is enabled, nodeId is either returned or not.
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-getNodeForLocation
//
// parameters:
//
//	x - X coordinate.
//	y - Y coordinate.
func GetNodeForLocation(x int64, y int64) *GetNodeForLocationParams {
	return &GetNodeForLocationParams{
		X: x,
		Y: y,
	}
}

// WithIncludeUserAgentShadowDOM false to skip to the nearest non-UA shadow
// root ancestor (default: false).
func (p GetNodeForLocationParams) WithIncludeUserAgentShadowDOM(includeUserAgentShadowDOM bool) *GetNodeForLocationParams {
	p.IncludeUserAgentShadowDOM = includeUserAgentShadowDOM
	return &p
}

// WithIgnorePointerEventsNone whether to ignore pointer-events: none on
// elements and hit test them.
func (p GetNodeForLocationParams) WithIgnorePointerEventsNone(ignorePointerEventsNone bool) *GetNodeForLocationParams {
	p.IgnorePointerEventsNone = ignorePointerEventsNone
	return &p
}

// GetNodeForLocationReturns return values.
type GetNodeForLocationReturns struct {
	BackendNodeID cdp.BackendNodeID `json:"backendNodeId,omitempty"` // Resulting node.
	FrameID       cdp.FrameID       `json:"frameId,omitempty"`       // Frame this node belongs to.
	NodeID        cdp.NodeID        `json:"nodeId,omitempty"`        // Id of the node at given coordinates, only when enabled and requested document.
}

// Do executes DOM.getNodeForLocation against the provided context.
//
// returns:
//
//	backendNodeID - Resulting node.
//	frameID - Frame this node belongs to.
//	nodeID - Id of the node at given coordinates, only when enabled and requested document.
func (p *GetNodeForLocationParams) Do(ctx context.Context) (backendNodeID cdp.BackendNodeID, frameID cdp.FrameID, nodeID cdp.NodeID, err error) {
	// execute
	var res GetNodeForLocationReturns
	err = cdp.Execute(ctx, CommandGetNodeForLocation, p, &res)
	if err != nil {
		return 0, "", 0, err
	}

	return res.BackendNodeID, res.FrameID, res.NodeID, nil
}

// GetOuterHTMLParams returns node's HTML markup.
type GetOuterHTMLParams struct {
	NodeID        cdp.NodeID             `json:"nodeId,omitempty"`        // Identifier of the node.
	BackendNodeID cdp.BackendNodeID      `json:"backendNodeId,omitempty"` // Identifier of the backend node.
	ObjectID      runtime.RemoteObjectID `json:"objectId,omitempty"`      // JavaScript object id of the node wrapper.
}

// GetOuterHTML returns node's HTML markup.
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-getOuterHTML
//
// parameters:
func GetOuterHTML() *GetOuterHTMLParams {
	return &GetOuterHTMLParams{}
}

// WithNodeID identifier of the node.
func (p GetOuterHTMLParams) WithNodeID(nodeID cdp.NodeID) *GetOuterHTMLParams {
	p.NodeID = nodeID
	return &p
}

// WithBackendNodeID identifier of the backend node.
func (p GetOuterHTMLParams) WithBackendNodeID(backendNodeID cdp.BackendNodeID) *GetOuterHTMLParams {
	p.BackendNodeID = backendNodeID
	return &p
}

// WithObjectID JavaScript object id of the node wrapper.
func (p GetOuterHTMLParams) WithObjectID(objectID runtime.RemoteObjectID) *GetOuterHTMLParams {
	p.ObjectID = objectID
	return &p
}

// GetOuterHTMLReturns return values.
type GetOuterHTMLReturns struct {
	OuterHTML string `json:"outerHTML,omitempty"` // Outer HTML markup.
}

// Do executes DOM.getOuterHTML against the provided context.
//
// returns:
//
//	outerHTML - Outer HTML markup.
func (p *GetOuterHTMLParams) Do(ctx context.Context) (outerHTML string, err error) {
	// execute
	var res GetOuterHTMLReturns
	err = cdp.Execute(ctx, CommandGetOuterHTML, p, &res)
	if err != nil {
		return "", err
	}

	return res.OuterHTML, nil
}

// GetRelayoutBoundaryParams returns the id of the nearest ancestor that is a
// relayout boundary.
type GetRelayoutBoundaryParams struct {
	NodeID cdp.NodeID `json:"nodeId"` // Id of the node.
}

// GetRelayoutBoundary returns the id of the nearest ancestor that is a
// relayout boundary.
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-getRelayoutBoundary
//
// parameters:
//
//	nodeID - Id of the node.
func GetRelayoutBoundary(nodeID cdp.NodeID) *GetRelayoutBoundaryParams {
	return &GetRelayoutBoundaryParams{
		NodeID: nodeID,
	}
}

// GetRelayoutBoundaryReturns return values.
type GetRelayoutBoundaryReturns struct {
	NodeID cdp.NodeID `json:"nodeId,omitempty"` // Relayout boundary node id for the given node.
}

// Do executes DOM.getRelayoutBoundary against the provided context.
//
// returns:
//
//	nodeID - Relayout boundary node id for the given node.
func (p *GetRelayoutBoundaryParams) Do(ctx context.Context) (nodeID cdp.NodeID, err error) {
	// execute
	var res GetRelayoutBoundaryReturns
	err = cdp.Execute(ctx, CommandGetRelayoutBoundary, p, &res)
	if err != nil {
		return 0, err
	}

	return res.NodeID, nil
}

// GetSearchResultsParams returns search results from given fromIndex to
// given toIndex from the search with the given identifier.
type GetSearchResultsParams struct {
	SearchID  string `json:"searchId"`  // Unique search session identifier.
	FromIndex int64  `json:"fromIndex"` // Start index of the search result to be returned.
	ToIndex   int64  `json:"toIndex"`   // End index of the search result to be returned.
}

// GetSearchResults returns search results from given fromIndex to given
// toIndex from the search with the given identifier.
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-getSearchResults
//
// parameters:
//
//	searchID - Unique search session identifier.
//	fromIndex - Start index of the search result to be returned.
//	toIndex - End index of the search result to be returned.
func GetSearchResults(searchID string, fromIndex int64, toIndex int64) *GetSearchResultsParams {
	return &GetSearchResultsParams{
		SearchID:  searchID,
		FromIndex: fromIndex,
		ToIndex:   toIndex,
	}
}

// GetSearchResultsReturns return values.
type GetSearchResultsReturns struct {
	NodeIDs []cdp.NodeID `json:"nodeIds,omitempty"` // Ids of the search result nodes.
}

// Do executes DOM.getSearchResults against the provided context.
//
// returns:
//
//	nodeIDs - Ids of the search result nodes.
func (p *GetSearchResultsParams) Do(ctx context.Context) (nodeIDs []cdp.NodeID, err error) {
	// execute
	var res GetSearchResultsReturns
	err = cdp.Execute(ctx, CommandGetSearchResults, p, &res)
	if err != nil {
		return nil, err
	}

	return res.NodeIDs, nil
}

// MarkUndoableStateParams marks last undoable state.
type MarkUndoableStateParams struct{}

// MarkUndoableState marks last undoable state.
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-markUndoableState
func MarkUndoableState() *MarkUndoableStateParams {
	return &MarkUndoableStateParams{}
}

// Do executes DOM.markUndoableState against the provided context.
func (p *MarkUndoableStateParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandMarkUndoableState, nil, nil)
}

// MoveToParams moves node into the new container, places it before the given
// anchor.
type MoveToParams struct {
	NodeID             cdp.NodeID `json:"nodeId"`                       // Id of the node to move.
	TargetNodeID       cdp.NodeID `json:"targetNodeId"`                 // Id of the element to drop the moved node into.
	InsertBeforeNodeID cdp.NodeID `json:"insertBeforeNodeId,omitempty"` // Drop node before this one (if absent, the moved node becomes the last child of targetNodeId).
}

// MoveTo moves node into the new container, places it before the given
// anchor.
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-moveTo
//
// parameters:
//
//	nodeID - Id of the node to move.
//	targetNodeID - Id of the element to drop the moved node into.
func MoveTo(nodeID cdp.NodeID, targetNodeID cdp.NodeID) *MoveToParams {
	return &MoveToParams{
		NodeID:       nodeID,
		TargetNodeID: targetNodeID,
	}
}

// WithInsertBeforeNodeID drop node before this one (if absent, the moved
// node becomes the last child of targetNodeId).
func (p MoveToParams) WithInsertBeforeNodeID(insertBeforeNodeID cdp.NodeID) *MoveToParams {
	p.InsertBeforeNodeID = insertBeforeNodeID
	return &p
}

// MoveToReturns return values.
type MoveToReturns struct {
	NodeID cdp.NodeID `json:"nodeId,omitempty"` // New id of the moved node.
}

// Do executes DOM.moveTo against the provided context.
//
// returns:
//
//	nodeID - New id of the moved node.
func (p *MoveToParams) Do(ctx context.Context) (nodeID cdp.NodeID, err error) {
	// execute
	var res MoveToReturns
	err = cdp.Execute(ctx, CommandMoveTo, p, &res)
	if err != nil {
		return 0, err
	}

	return res.NodeID, nil
}

// PerformSearchParams searches for a given string in the DOM tree. Use
// getSearchResults to access search results or cancelSearch to end this search
// session.
type PerformSearchParams struct {
	Query                     string `json:"query"`                               // Plain text or query selector or XPath search query.
	IncludeUserAgentShadowDOM bool   `json:"includeUserAgentShadowDOM,omitempty"` // True to search in user agent shadow DOM.
}

// PerformSearch searches for a given string in the DOM tree. Use
// getSearchResults to access search results or cancelSearch to end this search
// session.
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-performSearch
//
// parameters:
//
//	query - Plain text or query selector or XPath search query.
func PerformSearch(query string) *PerformSearchParams {
	return &PerformSearchParams{
		Query: query,
	}
}

// WithIncludeUserAgentShadowDOM true to search in user agent shadow DOM.
func (p PerformSearchParams) WithIncludeUserAgentShadowDOM(includeUserAgentShadowDOM bool) *PerformSearchParams {
	p.IncludeUserAgentShadowDOM = includeUserAgentShadowDOM
	return &p
}

// PerformSearchReturns return values.
type PerformSearchReturns struct {
	SearchID    string `json:"searchId,omitempty"`    // Unique search session identifier.
	ResultCount int64  `json:"resultCount,omitempty"` // Number of search results.
}

// Do executes DOM.performSearch against the provided context.
//
// returns:
//
//	searchID - Unique search session identifier.
//	resultCount - Number of search results.
func (p *PerformSearchParams) Do(ctx context.Context) (searchID string, resultCount int64, err error) {
	// execute
	var res PerformSearchReturns
	err = cdp.Execute(ctx, CommandPerformSearch, p, &res)
	if err != nil {
		return "", 0, err
	}

	return res.SearchID, res.ResultCount, nil
}

// PushNodeByPathToFrontendParams requests that the node is sent to the
// caller given its path. // FIXME, use XPath.
type PushNodeByPathToFrontendParams struct {
	Path string `json:"path"` // Path to node in the proprietary format.
}

// PushNodeByPathToFrontend requests that the node is sent to the caller
// given its path. // FIXME, use XPath.
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-pushNodeByPathToFrontend
//
// parameters:
//
//	path - Path to node in the proprietary format.
func PushNodeByPathToFrontend(path string) *PushNodeByPathToFrontendParams {
	return &PushNodeByPathToFrontendParams{
		Path: path,
	}
}

// PushNodeByPathToFrontendReturns return values.
type PushNodeByPathToFrontendReturns struct {
	NodeID cdp.NodeID `json:"nodeId,omitempty"` // Id of the node for given path.
}

// Do executes DOM.pushNodeByPathToFrontend against the provided context.
//
// returns:
//
//	nodeID - Id of the node for given path.
func (p *PushNodeByPathToFrontendParams) Do(ctx context.Context) (nodeID cdp.NodeID, err error) {
	// execute
	var res PushNodeByPathToFrontendReturns
	err = cdp.Execute(ctx, CommandPushNodeByPathToFrontend, p, &res)
	if err != nil {
		return 0, err
	}

	return res.NodeID, nil
}

// PushNodesByBackendIDsToFrontendParams requests that a batch of nodes is
// sent to the caller given their backend node ids.
type PushNodesByBackendIDsToFrontendParams struct {
	BackendNodeIDs []cdp.BackendNodeID `json:"backendNodeIds"` // The array of backend node ids.
}

// PushNodesByBackendIDsToFrontend requests that a batch of nodes is sent to
// the caller given their backend node ids.
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-pushNodesByBackendIdsToFrontend
//
// parameters:
//
//	backendNodeIDs - The array of backend node ids.
func PushNodesByBackendIDsToFrontend(backendNodeIDs []cdp.BackendNodeID) *PushNodesByBackendIDsToFrontendParams {
	return &PushNodesByBackendIDsToFrontendParams{
		BackendNodeIDs: backendNodeIDs,
	}
}

// PushNodesByBackendIDsToFrontendReturns return values.
type PushNodesByBackendIDsToFrontendReturns struct {
	NodeIDs []cdp.NodeID `json:"nodeIds,omitempty"` // The array of ids of pushed nodes that correspond to the backend ids specified in backendNodeIds.
}

// Do executes DOM.pushNodesByBackendIdsToFrontend against the provided context.
//
// returns:
//
//	nodeIDs - The array of ids of pushed nodes that correspond to the backend ids specified in backendNodeIds.
func (p *PushNodesByBackendIDsToFrontendParams) Do(ctx context.Context) (nodeIDs []cdp.NodeID, err error) {
	// execute
	var res PushNodesByBackendIDsToFrontendReturns
	err = cdp.Execute(ctx, CommandPushNodesByBackendIDsToFrontend, p, &res)
	if err != nil {
		return nil, err
	}

	return res.NodeIDs, nil
}

// QuerySelectorParams executes querySelector on a given node.
type QuerySelectorParams struct {
	NodeID   cdp.NodeID `json:"nodeId"`   // Id of the node to query upon.
	Selector string     `json:"selector"` // Selector string.
}

// QuerySelector executes querySelector on a given node.
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-querySelector
//
// parameters:
//
//	nodeID - Id of the node to query upon.
//	selector - Selector string.
func QuerySelector(nodeID cdp.NodeID, selector string) *QuerySelectorParams {
	return &QuerySelectorParams{
		NodeID:   nodeID,
		Selector: selector,
	}
}

// QuerySelectorReturns return values.
type QuerySelectorReturns struct {
	NodeID cdp.NodeID `json:"nodeId,omitempty"` // Query selector result.
}

// Do executes DOM.querySelector against the provided context.
//
// returns:
//
//	nodeID - Query selector result.
func (p *QuerySelectorParams) Do(ctx context.Context) (nodeID cdp.NodeID, err error) {
	// execute
	var res QuerySelectorReturns
	err = cdp.Execute(ctx, CommandQuerySelector, p, &res)
	if err != nil {
		return 0, err
	}

	return res.NodeID, nil
}

// QuerySelectorAllParams executes querySelectorAll on a given node.
type QuerySelectorAllParams struct {
	NodeID   cdp.NodeID `json:"nodeId"`   // Id of the node to query upon.
	Selector string     `json:"selector"` // Selector string.
}

// QuerySelectorAll executes querySelectorAll on a given node.
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-querySelectorAll
//
// parameters:
//
//	nodeID - Id of the node to query upon.
//	selector - Selector string.
func QuerySelectorAll(nodeID cdp.NodeID, selector string) *QuerySelectorAllParams {
	return &QuerySelectorAllParams{
		NodeID:   nodeID,
		Selector: selector,
	}
}

// QuerySelectorAllReturns return values.
type QuerySelectorAllReturns struct {
	NodeIDs []cdp.NodeID `json:"nodeIds,omitempty"` // Query selector result.
}

// Do executes DOM.querySelectorAll against the provided context.
//
// returns:
//
//	nodeIDs - Query selector result.
func (p *QuerySelectorAllParams) Do(ctx context.Context) (nodeIDs []cdp.NodeID, err error) {
	// execute
	var res QuerySelectorAllReturns
	err = cdp.Execute(ctx, CommandQuerySelectorAll, p, &res)
	if err != nil {
		return nil, err
	}

	return res.NodeIDs, nil
}

// GetTopLayerElementsParams returns NodeIds of current top layer elements.
// Top layer is rendered closest to the user within a viewport, therefore its
// elements always appear on top of all other content.
type GetTopLayerElementsParams struct{}

// GetTopLayerElements returns NodeIds of current top layer elements. Top
// layer is rendered closest to the user within a viewport, therefore its
// elements always appear on top of all other content.
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-getTopLayerElements
func GetTopLayerElements() *GetTopLayerElementsParams {
	return &GetTopLayerElementsParams{}
}

// GetTopLayerElementsReturns return values.
type GetTopLayerElementsReturns struct {
	NodeIDs []cdp.NodeID `json:"nodeIds,omitempty"` // NodeIds of top layer elements
}

// Do executes DOM.getTopLayerElements against the provided context.
//
// returns:
//
//	nodeIDs - NodeIds of top layer elements
func (p *GetTopLayerElementsParams) Do(ctx context.Context) (nodeIDs []cdp.NodeID, err error) {
	// execute
	var res GetTopLayerElementsReturns
	err = cdp.Execute(ctx, CommandGetTopLayerElements, nil, &res)
	if err != nil {
		return nil, err
	}

	return res.NodeIDs, nil
}

// GetElementByRelationParams returns the NodeId of the matched element
// according to certain relations.
type GetElementByRelationParams struct {
	NodeID   cdp.NodeID                   `json:"nodeId"`   // Id of the node from which to query the relation.
	Relation GetElementByRelationRelation `json:"relation"` // Type of relation to get.
}

// GetElementByRelation returns the NodeId of the matched element according
// to certain relations.
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-getElementByRelation
//
// parameters:
//
//	nodeID - Id of the node from which to query the relation.
//	relation - Type of relation to get.
func GetElementByRelation(nodeID cdp.NodeID, relation GetElementByRelationRelation) *GetElementByRelationParams {
	return &GetElementByRelationParams{
		NodeID:   nodeID,
		Relation: relation,
	}
}

// GetElementByRelationReturns return values.
type GetElementByRelationReturns struct {
	NodeID cdp.NodeID `json:"nodeId,omitempty"` // NodeId of the element matching the queried relation.
}

// Do executes DOM.getElementByRelation against the provided context.
//
// returns:
//
//	nodeID - NodeId of the element matching the queried relation.
func (p *GetElementByRelationParams) Do(ctx context.Context) (nodeID cdp.NodeID, err error) {
	// execute
	var res GetElementByRelationReturns
	err = cdp.Execute(ctx, CommandGetElementByRelation, p, &res)
	if err != nil {
		return 0, err
	}

	return res.NodeID, nil
}

// RedoParams re-does the last undone action.
type RedoParams struct{}

// Redo re-does the last undone action.
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-redo
func Redo() *RedoParams {
	return &RedoParams{}
}

// Do executes DOM.redo against the provided context.
func (p *RedoParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandRedo, nil, nil)
}

// RemoveAttributeParams removes attribute with given name from an element
// with given id.
type RemoveAttributeParams struct {
	NodeID cdp.NodeID `json:"nodeId"` // Id of the element to remove attribute from.
	Name   string     `json:"name"`   // Name of the attribute to remove.
}

// RemoveAttribute removes attribute with given name from an element with
// given id.
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-removeAttribute
//
// parameters:
//
//	nodeID - Id of the element to remove attribute from.
//	name - Name of the attribute to remove.
func RemoveAttribute(nodeID cdp.NodeID, name string) *RemoveAttributeParams {
	return &RemoveAttributeParams{
		NodeID: nodeID,
		Name:   name,
	}
}

// Do executes DOM.removeAttribute against the provided context.
func (p *RemoveAttributeParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandRemoveAttribute, p, nil)
}

// RemoveNodeParams removes node with given id.
type RemoveNodeParams struct {
	NodeID cdp.NodeID `json:"nodeId"` // Id of the node to remove.
}

// RemoveNode removes node with given id.
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-removeNode
//
// parameters:
//
//	nodeID - Id of the node to remove.
func RemoveNode(nodeID cdp.NodeID) *RemoveNodeParams {
	return &RemoveNodeParams{
		NodeID: nodeID,
	}
}

// Do executes DOM.removeNode against the provided context.
func (p *RemoveNodeParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandRemoveNode, p, nil)
}

// RequestChildNodesParams requests that children of the node with given id
// are returned to the caller in form of setChildNodes events where not only
// immediate children are retrieved, but all children down to the specified
// depth.
type RequestChildNodesParams struct {
	NodeID cdp.NodeID `json:"nodeId"`           // Id of the node to get children for.
	Depth  int64      `json:"depth,omitempty"`  // 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.
	Pierce bool       `json:"pierce,omitempty"` // Whether or not iframes and shadow roots should be traversed when returning the sub-tree (default is false).
}

// RequestChildNodes requests that children of the node with given id are
// returned to the caller in form of setChildNodes events where not only
// immediate children are retrieved, but all children down to the specified
// depth.
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-requestChildNodes
//
// parameters:
//
//	nodeID - Id of the node to get children for.
func RequestChildNodes(nodeID cdp.NodeID) *RequestChildNodesParams {
	return &RequestChildNodesParams{
		NodeID: nodeID,
	}
}

// WithDepth 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.
func (p RequestChildNodesParams) WithDepth(depth int64) *RequestChildNodesParams {
	p.Depth = depth
	return &p
}

// WithPierce whether or not iframes and shadow roots should be traversed
// when returning the sub-tree (default is false).
func (p RequestChildNodesParams) WithPierce(pierce bool) *RequestChildNodesParams {
	p.Pierce = pierce
	return &p
}

// Do executes DOM.requestChildNodes against the provided context.
func (p *RequestChildNodesParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandRequestChildNodes, p, nil)
}

// RequestNodeParams 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 setChildNodes
// notifications.
type RequestNodeParams struct {
	ObjectID runtime.RemoteObjectID `json:"objectId"` // JavaScript object id to convert into node.
}

// RequestNode 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 setChildNodes
// notifications.
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-requestNode
//
// parameters:
//
//	objectID - JavaScript object id to convert into node.
func RequestNode(objectID runtime.RemoteObjectID) *RequestNodeParams {
	return &RequestNodeParams{
		ObjectID: objectID,
	}
}

// RequestNodeReturns return values.
type RequestNodeReturns struct {
	NodeID cdp.NodeID `json:"nodeId,omitempty"` // Node id for given object.
}

// Do executes DOM.requestNode against the provided context.
//
// returns:
//
//	nodeID - Node id for given object.
func (p *RequestNodeParams) Do(ctx context.Context) (nodeID cdp.NodeID, err error) {
	// execute
	var res RequestNodeReturns
	err = cdp.Execute(ctx, CommandRequestNode, p, &res)
	if err != nil {
		return 0, err
	}

	return res.NodeID, nil
}

// ResolveNodeParams resolves the JavaScript node object for a given NodeId
// or BackendNodeId.
type ResolveNodeParams struct {
	NodeID             cdp.NodeID                 `json:"nodeId,omitempty"`             // Id of the node to resolve.
	BackendNodeID      cdp.BackendNodeID          `json:"backendNodeId,omitempty"`      // Backend identifier of the node to resolve.
	ObjectGroup        string                     `json:"objectGroup,omitempty"`        // Symbolic group name that can be used to release multiple objects.
	ExecutionContextID runtime.ExecutionContextID `json:"executionContextId,omitempty"` // Execution context in which to resolve the node.
}

// ResolveNode resolves the JavaScript node object for a given NodeId or
// BackendNodeId.
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-resolveNode
//
// parameters:
func ResolveNode() *ResolveNodeParams {
	return &ResolveNodeParams{}
}

// WithNodeID ID of the node to resolve.
func (p ResolveNodeParams) WithNodeID(nodeID cdp.NodeID) *ResolveNodeParams {
	p.NodeID = nodeID
	return &p
}

// WithBackendNodeID backend identifier of the node to resolve.
func (p ResolveNodeParams) WithBackendNodeID(backendNodeID cdp.BackendNodeID) *ResolveNodeParams {
	p.BackendNodeID = backendNodeID
	return &p
}

// WithObjectGroup symbolic group name that can be used to release multiple
// objects.
func (p ResolveNodeParams) WithObjectGroup(objectGroup string) *ResolveNodeParams {
	p.ObjectGroup = objectGroup
	return &p
}

// WithExecutionContextID execution context in which to resolve the node.
func (p ResolveNodeParams) WithExecutionContextID(executionContextID runtime.ExecutionContextID) *ResolveNodeParams {
	p.ExecutionContextID = executionContextID
	return &p
}

// ResolveNodeReturns return values.
type ResolveNodeReturns struct {
	Object *runtime.RemoteObject `json:"object,omitempty"` // JavaScript object wrapper for given node.
}

// Do executes DOM.resolveNode against the provided context.
//
// returns:
//
//	object - JavaScript object wrapper for given node.
func (p *ResolveNodeParams) Do(ctx context.Context) (object *runtime.RemoteObject, err error) {
	// execute
	var res ResolveNodeReturns
	err = cdp.Execute(ctx, CommandResolveNode, p, &res)
	if err != nil {
		return nil, err
	}

	return res.Object, nil
}

// SetAttributeValueParams sets attribute for an element with given id.
type SetAttributeValueParams struct {
	NodeID cdp.NodeID `json:"nodeId"` // Id of the element to set attribute for.
	Name   string     `json:"name"`   // Attribute name.
	Value  string     `json:"value"`  // Attribute value.
}

// SetAttributeValue sets attribute for an element with given id.
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-setAttributeValue
//
// parameters:
//
//	nodeID - Id of the element to set attribute for.
//	name - Attribute name.
//	value - Attribute value.
func SetAttributeValue(nodeID cdp.NodeID, name string, value string) *SetAttributeValueParams {
	return &SetAttributeValueParams{
		NodeID: nodeID,
		Name:   name,
		Value:  value,
	}
}

// Do executes DOM.setAttributeValue against the provided context.
func (p *SetAttributeValueParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetAttributeValue, p, nil)
}

// SetAttributesAsTextParams 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.
type SetAttributesAsTextParams struct {
	NodeID cdp.NodeID `json:"nodeId"`         // Id of the element to set attributes for.
	Text   string     `json:"text"`           // Text with a number of attributes. Will parse this text using HTML parser.
	Name   string     `json:"name,omitempty"` // Attribute name to replace with new attributes derived from text in case text parsed successfully.
}

// SetAttributesAsText 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.
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-setAttributesAsText
//
// parameters:
//
//	nodeID - Id of the element to set attributes for.
//	text - Text with a number of attributes. Will parse this text using HTML parser.
func SetAttributesAsText(nodeID cdp.NodeID, text string) *SetAttributesAsTextParams {
	return &SetAttributesAsTextParams{
		NodeID: nodeID,
		Text:   text,
	}
}

// WithName attribute name to replace with new attributes derived from text
// in case text parsed successfully.
func (p SetAttributesAsTextParams) WithName(name string) *SetAttributesAsTextParams {
	p.Name = name
	return &p
}

// Do executes DOM.setAttributesAsText against the provided context.
func (p *SetAttributesAsTextParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetAttributesAsText, p, nil)
}

// SetFileInputFilesParams sets files for the given file input element.
type SetFileInputFilesParams struct {
	Files         []string               `json:"files"`                   // Array of file paths to set.
	NodeID        cdp.NodeID             `json:"nodeId,omitempty"`        // Identifier of the node.
	BackendNodeID cdp.BackendNodeID      `json:"backendNodeId,omitempty"` // Identifier of the backend node.
	ObjectID      runtime.RemoteObjectID `json:"objectId,omitempty"`      // JavaScript object id of the node wrapper.
}

// SetFileInputFiles sets files for the given file input element.
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-setFileInputFiles
//
// parameters:
//
//	files - Array of file paths to set.
func SetFileInputFiles(files []string) *SetFileInputFilesParams {
	return &SetFileInputFilesParams{
		Files: files,
	}
}

// WithNodeID identifier of the node.
func (p SetFileInputFilesParams) WithNodeID(nodeID cdp.NodeID) *SetFileInputFilesParams {
	p.NodeID = nodeID
	return &p
}

// WithBackendNodeID identifier of the backend node.
func (p SetFileInputFilesParams) WithBackendNodeID(backendNodeID cdp.BackendNodeID) *SetFileInputFilesParams {
	p.BackendNodeID = backendNodeID
	return &p
}

// WithObjectID JavaScript object id of the node wrapper.
func (p SetFileInputFilesParams) WithObjectID(objectID runtime.RemoteObjectID) *SetFileInputFilesParams {
	p.ObjectID = objectID
	return &p
}

// Do executes DOM.setFileInputFiles against the provided context.
func (p *SetFileInputFilesParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetFileInputFiles, p, nil)
}

// SetNodeStackTracesEnabledParams sets if stack traces should be captured
// for Nodes. See Node.getNodeStackTraces. Default is disabled.
type SetNodeStackTracesEnabledParams struct {
	Enable bool `json:"enable"` // Enable or disable.
}

// SetNodeStackTracesEnabled sets if stack traces should be captured for
// Nodes. See Node.getNodeStackTraces. Default is disabled.
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-setNodeStackTracesEnabled
//
// parameters:
//
//	enable - Enable or disable.
func SetNodeStackTracesEnabled(enable bool) *SetNodeStackTracesEnabledParams {
	return &SetNodeStackTracesEnabledParams{
		Enable: enable,
	}
}

// Do executes DOM.setNodeStackTracesEnabled against the provided context.
func (p *SetNodeStackTracesEnabledParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetNodeStackTracesEnabled, p, nil)
}

// GetNodeStackTracesParams gets stack traces associated with a Node. As of
// now, only provides stack trace for Node creation.
type GetNodeStackTracesParams struct {
	NodeID cdp.NodeID `json:"nodeId"` // Id of the node to get stack traces for.
}

// GetNodeStackTraces gets stack traces associated with a Node. As of now,
// only provides stack trace for Node creation.
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-getNodeStackTraces
//
// parameters:
//
//	nodeID - Id of the node to get stack traces for.
func GetNodeStackTraces(nodeID cdp.NodeID) *GetNodeStackTracesParams {
	return &GetNodeStackTracesParams{
		NodeID: nodeID,
	}
}

// GetNodeStackTracesReturns return values.
type GetNodeStackTracesReturns struct {
	Creation *runtime.StackTrace `json:"creation,omitempty"` // Creation stack trace, if available.
}

// Do executes DOM.getNodeStackTraces against the provided context.
//
// returns:
//
//	creation - Creation stack trace, if available.
func (p *GetNodeStackTracesParams) Do(ctx context.Context) (creation *runtime.StackTrace, err error) {
	// execute
	var res GetNodeStackTracesReturns
	err = cdp.Execute(ctx, CommandGetNodeStackTraces, p, &res)
	if err != nil {
		return nil, err
	}

	return res.Creation, nil
}

// GetFileInfoParams returns file information for the given File wrapper.
type GetFileInfoParams struct {
	ObjectID runtime.RemoteObjectID `json:"objectId"` // JavaScript object id of the node wrapper.
}

// GetFileInfo returns file information for the given File wrapper.
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-getFileInfo
//
// parameters:
//
//	objectID - JavaScript object id of the node wrapper.
func GetFileInfo(objectID runtime.RemoteObjectID) *GetFileInfoParams {
	return &GetFileInfoParams{
		ObjectID: objectID,
	}
}

// GetFileInfoReturns return values.
type GetFileInfoReturns struct {
	Path string `json:"path,omitempty"`
}

// Do executes DOM.getFileInfo against the provided context.
//
// returns:
//
//	path
func (p *GetFileInfoParams) Do(ctx context.Context) (path string, err error) {
	// execute
	var res GetFileInfoReturns
	err = cdp.Execute(ctx, CommandGetFileInfo, p, &res)
	if err != nil {
		return "", err
	}

	return res.Path, nil
}

// GetDetachedDomNodesParams returns list of detached nodes.
type GetDetachedDomNodesParams struct{}

// GetDetachedDomNodes returns list of detached nodes.
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-getDetachedDomNodes
func GetDetachedDomNodes() *GetDetachedDomNodesParams {
	return &GetDetachedDomNodesParams{}
}

// GetDetachedDomNodesReturns return values.
type GetDetachedDomNodesReturns struct {
	DetachedNodes []*DetachedElementInfo `json:"detachedNodes,omitempty"` // The list of detached nodes
}

// Do executes DOM.getDetachedDomNodes against the provided context.
//
// returns:
//
//	detachedNodes - The list of detached nodes
func (p *GetDetachedDomNodesParams) Do(ctx context.Context) (detachedNodes []*DetachedElementInfo, err error) {
	// execute
	var res GetDetachedDomNodesReturns
	err = cdp.Execute(ctx, CommandGetDetachedDomNodes, nil, &res)
	if err != nil {
		return nil, err
	}

	return res.DetachedNodes, nil
}

// SetInspectedNodeParams enables console to refer to the node with given id
// via $x (see Command Line API for more details $x functions).
type SetInspectedNodeParams struct {
	NodeID cdp.NodeID `json:"nodeId"` // DOM node id to be accessible by means of $x command line API.
}

// SetInspectedNode enables console to refer to the node with given id via $x
// (see Command Line API for more details $x functions).
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-setInspectedNode
//
// parameters:
//
//	nodeID - DOM node id to be accessible by means of $x command line API.
func SetInspectedNode(nodeID cdp.NodeID) *SetInspectedNodeParams {
	return &SetInspectedNodeParams{
		NodeID: nodeID,
	}
}

// Do executes DOM.setInspectedNode against the provided context.
func (p *SetInspectedNodeParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetInspectedNode, p, nil)
}

// SetNodeNameParams sets node name for a node with given id.
type SetNodeNameParams struct {
	NodeID cdp.NodeID `json:"nodeId"` // Id of the node to set name for.
	Name   string     `json:"name"`   // New node's name.
}

// SetNodeName sets node name for a node with given id.
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-setNodeName
//
// parameters:
//
//	nodeID - Id of the node to set name for.
//	name - New node's name.
func SetNodeName(nodeID cdp.NodeID, name string) *SetNodeNameParams {
	return &SetNodeNameParams{
		NodeID: nodeID,
		Name:   name,
	}
}

// SetNodeNameReturns return values.
type SetNodeNameReturns struct {
	NodeID cdp.NodeID `json:"nodeId,omitempty"` // New node's id.
}

// Do executes DOM.setNodeName against the provided context.
//
// returns:
//
//	nodeID - New node's id.
func (p *SetNodeNameParams) Do(ctx context.Context) (nodeID cdp.NodeID, err error) {
	// execute
	var res SetNodeNameReturns
	err = cdp.Execute(ctx, CommandSetNodeName, p, &res)
	if err != nil {
		return 0, err
	}

	return res.NodeID, nil
}

// SetNodeValueParams sets node value for a node with given id.
type SetNodeValueParams struct {
	NodeID cdp.NodeID `json:"nodeId"` // Id of the node to set value for.
	Value  string     `json:"value"`  // New node's value.
}

// SetNodeValue sets node value for a node with given id.
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-setNodeValue
//
// parameters:
//
//	nodeID - Id of the node to set value for.
//	value - New node's value.
func SetNodeValue(nodeID cdp.NodeID, value string) *SetNodeValueParams {
	return &SetNodeValueParams{
		NodeID: nodeID,
		Value:  value,
	}
}

// Do executes DOM.setNodeValue against the provided context.
func (p *SetNodeValueParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetNodeValue, p, nil)
}

// SetOuterHTMLParams sets node HTML markup, returns new node id.
type SetOuterHTMLParams struct {
	NodeID    cdp.NodeID `json:"nodeId"`    // Id of the node to set markup for.
	OuterHTML string     `json:"outerHTML"` // Outer HTML markup to set.
}

// SetOuterHTML sets node HTML markup, returns new node id.
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-setOuterHTML
//
// parameters:
//
//	nodeID - Id of the node to set markup for.
//	outerHTML - Outer HTML markup to set.
func SetOuterHTML(nodeID cdp.NodeID, outerHTML string) *SetOuterHTMLParams {
	return &SetOuterHTMLParams{
		NodeID:    nodeID,
		OuterHTML: outerHTML,
	}
}

// Do executes DOM.setOuterHTML against the provided context.
func (p *SetOuterHTMLParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetOuterHTML, p, nil)
}

// UndoParams undoes the last performed action.
type UndoParams struct{}

// Undo undoes the last performed action.
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-undo
func Undo() *UndoParams {
	return &UndoParams{}
}

// Do executes DOM.undo against the provided context.
func (p *UndoParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandUndo, nil, nil)
}

// GetFrameOwnerParams returns iframe node that owns iframe with the given
// domain.
type GetFrameOwnerParams struct {
	FrameID cdp.FrameID `json:"frameId"`
}

// GetFrameOwner returns iframe node that owns iframe with the given domain.
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-getFrameOwner
//
// parameters:
//
//	frameID
func GetFrameOwner(frameID cdp.FrameID) *GetFrameOwnerParams {
	return &GetFrameOwnerParams{
		FrameID: frameID,
	}
}

// GetFrameOwnerReturns return values.
type GetFrameOwnerReturns struct {
	BackendNodeID cdp.BackendNodeID `json:"backendNodeId,omitempty"` // Resulting node.
	NodeID        cdp.NodeID        `json:"nodeId,omitempty"`        // Id of the node at given coordinates, only when enabled and requested document.
}

// Do executes DOM.getFrameOwner against the provided context.
//
// returns:
//
//	backendNodeID - Resulting node.
//	nodeID - Id of the node at given coordinates, only when enabled and requested document.
func (p *GetFrameOwnerParams) Do(ctx context.Context) (backendNodeID cdp.BackendNodeID, nodeID cdp.NodeID, err error) {
	// execute
	var res GetFrameOwnerReturns
	err = cdp.Execute(ctx, CommandGetFrameOwner, p, &res)
	if err != nil {
		return 0, 0, err
	}

	return res.BackendNodeID, res.NodeID, nil
}

// GetContainerForNodeParams returns the query container of the given node
// based on container query conditions: containerName, physical, and logical
// axes. If no axes are provided, the style container is returned, which is the
// direct parent or the closest element with a matching container-name.
type GetContainerForNodeParams struct {
	NodeID        cdp.NodeID   `json:"nodeId"`
	ContainerName string       `json:"containerName,omitempty"`
	PhysicalAxes  PhysicalAxes `json:"physicalAxes,omitempty"`
	LogicalAxes   LogicalAxes  `json:"logicalAxes,omitempty"`
}

// GetContainerForNode returns the query container of the given node based on
// container query conditions: containerName, physical, and logical axes. If no
// axes are provided, the style container is returned, which is the direct
// parent or the closest element with a matching container-name.
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-getContainerForNode
//
// parameters:
//
//	nodeID
func GetContainerForNode(nodeID cdp.NodeID) *GetContainerForNodeParams {
	return &GetContainerForNodeParams{
		NodeID: nodeID,
	}
}

// WithContainerName [no description].
func (p GetContainerForNodeParams) WithContainerName(containerName string) *GetContainerForNodeParams {
	p.ContainerName = containerName
	return &p
}

// WithPhysicalAxes [no description].
func (p GetContainerForNodeParams) WithPhysicalAxes(physicalAxes PhysicalAxes) *GetContainerForNodeParams {
	p.PhysicalAxes = physicalAxes
	return &p
}

// WithLogicalAxes [no description].
func (p GetContainerForNodeParams) WithLogicalAxes(logicalAxes LogicalAxes) *GetContainerForNodeParams {
	p.LogicalAxes = logicalAxes
	return &p
}

// GetContainerForNodeReturns return values.
type GetContainerForNodeReturns struct {
	NodeID cdp.NodeID `json:"nodeId,omitempty"` // The container node for the given node, or null if not found.
}

// Do executes DOM.getContainerForNode against the provided context.
//
// returns:
//
//	nodeID - The container node for the given node, or null if not found.
func (p *GetContainerForNodeParams) Do(ctx context.Context) (nodeID cdp.NodeID, err error) {
	// execute
	var res GetContainerForNodeReturns
	err = cdp.Execute(ctx, CommandGetContainerForNode, p, &res)
	if err != nil {
		return 0, err
	}

	return res.NodeID, nil
}

// GetQueryingDescendantsForContainerParams returns the descendants of a
// container query container that have container queries against this container.
type GetQueryingDescendantsForContainerParams struct {
	NodeID cdp.NodeID `json:"nodeId"` // Id of the container node to find querying descendants from.
}

// GetQueryingDescendantsForContainer returns the descendants of a container
// query container that have container queries against this container.
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-getQueryingDescendantsForContainer
//
// parameters:
//
//	nodeID - Id of the container node to find querying descendants from.
func GetQueryingDescendantsForContainer(nodeID cdp.NodeID) *GetQueryingDescendantsForContainerParams {
	return &GetQueryingDescendantsForContainerParams{
		NodeID: nodeID,
	}
}

// GetQueryingDescendantsForContainerReturns return values.
type GetQueryingDescendantsForContainerReturns struct {
	NodeIDs []cdp.NodeID `json:"nodeIds,omitempty"` // Descendant nodes with container queries against the given container.
}

// Do executes DOM.getQueryingDescendantsForContainer against the provided context.
//
// returns:
//
//	nodeIDs - Descendant nodes with container queries against the given container.
func (p *GetQueryingDescendantsForContainerParams) Do(ctx context.Context) (nodeIDs []cdp.NodeID, err error) {
	// execute
	var res GetQueryingDescendantsForContainerReturns
	err = cdp.Execute(ctx, CommandGetQueryingDescendantsForContainer, p, &res)
	if err != nil {
		return nil, err
	}

	return res.NodeIDs, nil
}

// GetAnchorElementParams returns the target anchor element of the given
// anchor query according to
// https://www.w3.org/TR/css-anchor-position-1/#target.
type GetAnchorElementParams struct {
	NodeID          cdp.NodeID `json:"nodeId"`                    // Id of the positioned element from which to find the anchor.
	AnchorSpecifier string     `json:"anchorSpecifier,omitempty"` // An optional anchor specifier, as defined in https://www.w3.org/TR/css-anchor-position-1/#anchor-specifier. If not provided, it will return the implicit anchor element for the given positioned element.
}

// GetAnchorElement returns the target anchor element of the given anchor
// query according to https://www.w3.org/TR/css-anchor-position-1/#target.
//
// See: https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-getAnchorElement
//
// parameters:
//
//	nodeID - Id of the positioned element from which to find the anchor.
func GetAnchorElement(nodeID cdp.NodeID) *GetAnchorElementParams {
	return &GetAnchorElementParams{
		NodeID: nodeID,
	}
}

// WithAnchorSpecifier an optional anchor specifier, as defined in
// https://www.w3.org/TR/css-anchor-position-1/#anchor-specifier. If not
// provided, it will return the implicit anchor element for the given positioned
// element.
func (p GetAnchorElementParams) WithAnchorSpecifier(anchorSpecifier string) *GetAnchorElementParams {
	p.AnchorSpecifier = anchorSpecifier
	return &p
}

// GetAnchorElementReturns return values.
type GetAnchorElementReturns struct {
	NodeID cdp.NodeID `json:"nodeId,omitempty"` // The anchor element of the given anchor query.
}

// Do executes DOM.getAnchorElement against the provided context.
//
// returns:
//
//	nodeID - The anchor element of the given anchor query.
func (p *GetAnchorElementParams) Do(ctx context.Context) (nodeID cdp.NodeID, err error) {
	// execute
	var res GetAnchorElementReturns
	err = cdp.Execute(ctx, CommandGetAnchorElement, p, &res)
	if err != nil {
		return 0, err
	}

	return res.NodeID, nil
}

// Command names.
const (
	CommandCollectClassNamesFromSubtree       = "DOM.collectClassNamesFromSubtree"
	CommandCopyTo                             = "DOM.copyTo"
	CommandDescribeNode                       = "DOM.describeNode"
	CommandScrollIntoViewIfNeeded             = "DOM.scrollIntoViewIfNeeded"
	CommandDisable                            = "DOM.disable"
	CommandDiscardSearchResults               = "DOM.discardSearchResults"
	CommandEnable                             = "DOM.enable"
	CommandFocus                              = "DOM.focus"
	CommandGetAttributes                      = "DOM.getAttributes"
	CommandGetBoxModel                        = "DOM.getBoxModel"
	CommandGetContentQuads                    = "DOM.getContentQuads"
	CommandGetDocument                        = "DOM.getDocument"
	CommandGetNodesForSubtreeByStyle          = "DOM.getNodesForSubtreeByStyle"
	CommandGetNodeForLocation                 = "DOM.getNodeForLocation"
	CommandGetOuterHTML                       = "DOM.getOuterHTML"
	CommandGetRelayoutBoundary                = "DOM.getRelayoutBoundary"
	CommandGetSearchResults                   = "DOM.getSearchResults"
	CommandMarkUndoableState                  = "DOM.markUndoableState"
	CommandMoveTo                             = "DOM.moveTo"
	CommandPerformSearch                      = "DOM.performSearch"
	CommandPushNodeByPathToFrontend           = "DOM.pushNodeByPathToFrontend"
	CommandPushNodesByBackendIDsToFrontend    = "DOM.pushNodesByBackendIdsToFrontend"
	CommandQuerySelector                      = "DOM.querySelector"
	CommandQuerySelectorAll                   = "DOM.querySelectorAll"
	CommandGetTopLayerElements                = "DOM.getTopLayerElements"
	CommandGetElementByRelation               = "DOM.getElementByRelation"
	CommandRedo                               = "DOM.redo"
	CommandRemoveAttribute                    = "DOM.removeAttribute"
	CommandRemoveNode                         = "DOM.removeNode"
	CommandRequestChildNodes                  = "DOM.requestChildNodes"
	CommandRequestNode                        = "DOM.requestNode"
	CommandResolveNode                        = "DOM.resolveNode"
	CommandSetAttributeValue                  = "DOM.setAttributeValue"
	CommandSetAttributesAsText                = "DOM.setAttributesAsText"
	CommandSetFileInputFiles                  = "DOM.setFileInputFiles"
	CommandSetNodeStackTracesEnabled          = "DOM.setNodeStackTracesEnabled"
	CommandGetNodeStackTraces                 = "DOM.getNodeStackTraces"
	CommandGetFileInfo                        = "DOM.getFileInfo"
	CommandGetDetachedDomNodes                = "DOM.getDetachedDomNodes"
	CommandSetInspectedNode                   = "DOM.setInspectedNode"
	CommandSetNodeName                        = "DOM.setNodeName"
	CommandSetNodeValue                       = "DOM.setNodeValue"
	CommandSetOuterHTML                       = "DOM.setOuterHTML"
	CommandUndo                               = "DOM.undo"
	CommandGetFrameOwner                      = "DOM.getFrameOwner"
	CommandGetContainerForNode                = "DOM.getContainerForNode"
	CommandGetQueryingDescendantsForContainer = "DOM.getQueryingDescendantsForContainer"
	CommandGetAnchorElement                   = "DOM.getAnchorElement"
)
