func (d *domainClient) PushNodesByBackendIDsToFrontend(ctx context.Context, args *PushNodesByBackendIDsToFrontendArgs) (reply *PushNodesByBackendIDsToFrontendReply, err error) {
	reply = new(PushNodesByBackendIDsToFrontendReply)
	if args != nil {
		err = rpcc.Invoke(ctx, "DOM.pushNodesByBackendIdsToFrontend", args, reply, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "DOM.pushNodesByBackendIdsToFrontend", nil, reply, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "DOM", Op: "PushNodesByBackendIDsToFrontend", Err: err}
	}
	return
}
PushNodesByBackendIDsToFrontend invokes the DOM method. Requests that a
batch of nodes is sent to the caller given their backend node ids.
package dom
import (
	"context"
	"github.com/mafredri/cdp/protocol/internal"
	"github.com/mafredri/cdp/rpcc"
)
type domainClient struct{ conn *rpcc.Conn }
func NewClient(conn *rpcc.Conn) *domainClient {
	return &domainClient{conn: conn}
}
func (d *domainClient) CollectClassNamesFromSubtree(ctx context.Context, args *CollectClassNamesFromSubtreeArgs) (reply *CollectClassNamesFromSubtreeReply, err error) {
	reply = new(CollectClassNamesFromSubtreeReply)
	if args != nil {
		err = rpcc.Invoke(ctx, "DOM.collectClassNamesFromSubtree", args, reply, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "DOM.collectClassNamesFromSubtree", nil, reply, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "DOM", Op: "CollectClassNamesFromSubtree", Err: err}
	}
	return
}
func (d *domainClient) CopyTo(ctx context.Context, args *CopyToArgs) (reply *CopyToReply, err error) {
	reply = new(CopyToReply)
	if args != nil {
		err = rpcc.Invoke(ctx, "DOM.copyTo", args, reply, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "DOM.copyTo", nil, reply, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "DOM", Op: "CopyTo", Err: err}
	}
	return
}
func (d *domainClient) DescribeNode(ctx context.Context, args *DescribeNodeArgs) (reply *DescribeNodeReply, err error) {
	reply = new(DescribeNodeReply)
	if args != nil {
		err = rpcc.Invoke(ctx, "DOM.describeNode", args, reply, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "DOM.describeNode", nil, reply, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "DOM", Op: "DescribeNode", Err: err}
	}
	return
}
func (d *domainClient) Disable(ctx context.Context) (err error) {
	err = rpcc.Invoke(ctx, "DOM.disable", nil, nil, d.conn)
	if err != nil {
		err = &internal.OpError{Domain: "DOM", Op: "Disable", Err: err}
	}
	return
}
func (d *domainClient) DiscardSearchResults(ctx context.Context, args *DiscardSearchResultsArgs) (err error) {
	if args != nil {
		err = rpcc.Invoke(ctx, "DOM.discardSearchResults", args, nil, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "DOM.discardSearchResults", nil, nil, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "DOM", Op: "DiscardSearchResults", Err: err}
	}
	return
}
func (d *domainClient) Enable(ctx context.Context) (err error) {
	err = rpcc.Invoke(ctx, "DOM.enable", nil, nil, d.conn)
	if err != nil {
		err = &internal.OpError{Domain: "DOM", Op: "Enable", Err: err}
	}
	return
}
func (d *domainClient) Focus(ctx context.Context, args *FocusArgs) (err error) {
	if args != nil {
		err = rpcc.Invoke(ctx, "DOM.focus", args, nil, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "DOM.focus", nil, nil, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "DOM", Op: "Focus", Err: err}
	}
	return
}
func (d *domainClient) GetAttributes(ctx context.Context, args *GetAttributesArgs) (reply *GetAttributesReply, err error) {
	reply = new(GetAttributesReply)
	if args != nil {
		err = rpcc.Invoke(ctx, "DOM.getAttributes", args, reply, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "DOM.getAttributes", nil, reply, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "DOM", Op: "GetAttributes", Err: err}
	}
	return
}
func (d *domainClient) GetBoxModel(ctx context.Context, args *GetBoxModelArgs) (reply *GetBoxModelReply, err error) {
	reply = new(GetBoxModelReply)
	if args != nil {
		err = rpcc.Invoke(ctx, "DOM.getBoxModel", args, reply, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "DOM.getBoxModel", nil, reply, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "DOM", Op: "GetBoxModel", Err: err}
	}
	return
}
func (d *domainClient) GetContentQuads(ctx context.Context, args *GetContentQuadsArgs) (reply *GetContentQuadsReply, err error) {
	reply = new(GetContentQuadsReply)
	if args != nil {
		err = rpcc.Invoke(ctx, "DOM.getContentQuads", args, reply, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "DOM.getContentQuads", nil, reply, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "DOM", Op: "GetContentQuads", Err: err}
	}
	return
}
func (d *domainClient) GetDocument(ctx context.Context, args *GetDocumentArgs) (reply *GetDocumentReply, err error) {
	reply = new(GetDocumentReply)
	if args != nil {
		err = rpcc.Invoke(ctx, "DOM.getDocument", args, reply, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "DOM.getDocument", nil, reply, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "DOM", Op: "GetDocument", Err: err}
	}
	return
}
func (d *domainClient) GetFlattenedDocument(ctx context.Context, args *GetFlattenedDocumentArgs) (reply *GetFlattenedDocumentReply, err error) {
	reply = new(GetFlattenedDocumentReply)
	if args != nil {
		err = rpcc.Invoke(ctx, "DOM.getFlattenedDocument", args, reply, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "DOM.getFlattenedDocument", nil, reply, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "DOM", Op: "GetFlattenedDocument", Err: err}
	}
	return
}
func (d *domainClient) GetNodeForLocation(ctx context.Context, args *GetNodeForLocationArgs) (reply *GetNodeForLocationReply, err error) {
	reply = new(GetNodeForLocationReply)
	if args != nil {
		err = rpcc.Invoke(ctx, "DOM.getNodeForLocation", args, reply, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "DOM.getNodeForLocation", nil, reply, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "DOM", Op: "GetNodeForLocation", Err: err}
	}
	return
}
func (d *domainClient) GetOuterHTML(ctx context.Context, args *GetOuterHTMLArgs) (reply *GetOuterHTMLReply, err error) {
	reply = new(GetOuterHTMLReply)
	if args != nil {
		err = rpcc.Invoke(ctx, "DOM.getOuterHTML", args, reply, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "DOM.getOuterHTML", nil, reply, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "DOM", Op: "GetOuterHTML", Err: err}
	}
	return
}
func (d *domainClient) GetRelayoutBoundary(ctx context.Context, args *GetRelayoutBoundaryArgs) (reply *GetRelayoutBoundaryReply, err error) {
	reply = new(GetRelayoutBoundaryReply)
	if args != nil {
		err = rpcc.Invoke(ctx, "DOM.getRelayoutBoundary", args, reply, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "DOM.getRelayoutBoundary", nil, reply, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "DOM", Op: "GetRelayoutBoundary", Err: err}
	}
	return
}
func (d *domainClient) GetSearchResults(ctx context.Context, args *GetSearchResultsArgs) (reply *GetSearchResultsReply, err error) {
	reply = new(GetSearchResultsReply)
	if args != nil {
		err = rpcc.Invoke(ctx, "DOM.getSearchResults", args, reply, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "DOM.getSearchResults", nil, reply, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "DOM", Op: "GetSearchResults", Err: err}
	}
	return
}
func (d *domainClient) MarkUndoableState(ctx context.Context) (err error) {
	err = rpcc.Invoke(ctx, "DOM.markUndoableState", nil, nil, d.conn)
	if err != nil {
		err = &internal.OpError{Domain: "DOM", Op: "MarkUndoableState", Err: err}
	}
	return
}
func (d *domainClient) MoveTo(ctx context.Context, args *MoveToArgs) (reply *MoveToReply, err error) {
	reply = new(MoveToReply)
	if args != nil {
		err = rpcc.Invoke(ctx, "DOM.moveTo", args, reply, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "DOM.moveTo", nil, reply, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "DOM", Op: "MoveTo", Err: err}
	}
	return
}
func (d *domainClient) PerformSearch(ctx context.Context, args *PerformSearchArgs) (reply *PerformSearchReply, err error) {
	reply = new(PerformSearchReply)
	if args != nil {
		err = rpcc.Invoke(ctx, "DOM.performSearch", args, reply, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "DOM.performSearch", nil, reply, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "DOM", Op: "PerformSearch", Err: err}
	}
	return
}
func (d *domainClient) PushNodeByPathToFrontend(ctx context.Context, args *PushNodeByPathToFrontendArgs) (reply *PushNodeByPathToFrontendReply, err error) {
	reply = new(PushNodeByPathToFrontendReply)
	if args != nil {
		err = rpcc.Invoke(ctx, "DOM.pushNodeByPathToFrontend", args, reply, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "DOM.pushNodeByPathToFrontend", nil, reply, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "DOM", Op: "PushNodeByPathToFrontend", Err: err}
	}
	return
}