func (d *domainClient) SetBlackboxedRanges(ctx context.Context, args *SetBlackboxedRangesArgs) (err error) {
	if args != nil {
		err = rpcc.Invoke(ctx, "Debugger.setBlackboxedRanges", args, nil, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Debugger.setBlackboxedRanges", nil, nil, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Debugger", Op: "SetBlackboxedRanges", Err: err}
	}
	return
}
SetBlackboxedRanges invokes the Debugger method. Makes backend skip steps
in the script in blackboxed ranges. VM will try leave blacklisted scripts by
performing 'step in' several times, finally resorting to 'step out' if
unsuccessful. Positions array contains positions where blackbox state is
changed. First interval isn't blackboxed. Array should be sorted.
package debugger
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) ContinueToLocation(ctx context.Context, args *ContinueToLocationArgs) (err error) {
	if args != nil {
		err = rpcc.Invoke(ctx, "Debugger.continueToLocation", args, nil, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Debugger.continueToLocation", nil, nil, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Debugger", Op: "ContinueToLocation", Err: err}
	}
	return
}
func (d *domainClient) Disable(ctx context.Context) (err error) {
	err = rpcc.Invoke(ctx, "Debugger.disable", nil, nil, d.conn)
	if err != nil {
		err = &internal.OpError{Domain: "Debugger", Op: "Disable", Err: err}
	}
	return
}
func (d *domainClient) Enable(ctx context.Context, args *EnableArgs) (reply *EnableReply, err error) {
	reply = new(EnableReply)
	if args != nil {
		err = rpcc.Invoke(ctx, "Debugger.enable", args, reply, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Debugger.enable", nil, reply, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Debugger", Op: "Enable", Err: err}
	}
	return
}
func (d *domainClient) EvaluateOnCallFrame(ctx context.Context, args *EvaluateOnCallFrameArgs) (reply *EvaluateOnCallFrameReply, err error) {
	reply = new(EvaluateOnCallFrameReply)
	if args != nil {
		err = rpcc.Invoke(ctx, "Debugger.evaluateOnCallFrame", args, reply, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Debugger.evaluateOnCallFrame", nil, reply, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Debugger", Op: "EvaluateOnCallFrame", Err: err}
	}
	return
}
func (d *domainClient) GetPossibleBreakpoints(ctx context.Context, args *GetPossibleBreakpointsArgs) (reply *GetPossibleBreakpointsReply, err error) {
	reply = new(GetPossibleBreakpointsReply)
	if args != nil {
		err = rpcc.Invoke(ctx, "Debugger.getPossibleBreakpoints", args, reply, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Debugger.getPossibleBreakpoints", nil, reply, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Debugger", Op: "GetPossibleBreakpoints", Err: err}
	}
	return
}
func (d *domainClient) GetScriptSource(ctx context.Context, args *GetScriptSourceArgs) (reply *GetScriptSourceReply, err error) {
	reply = new(GetScriptSourceReply)
	if args != nil {
		err = rpcc.Invoke(ctx, "Debugger.getScriptSource", args, reply, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Debugger.getScriptSource", nil, reply, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Debugger", Op: "GetScriptSource", Err: err}
	}
	return
}
func (d *domainClient) GetStackTrace(ctx context.Context, args *GetStackTraceArgs) (reply *GetStackTraceReply, err error) {
	reply = new(GetStackTraceReply)
	if args != nil {
		err = rpcc.Invoke(ctx, "Debugger.getStackTrace", args, reply, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Debugger.getStackTrace", nil, reply, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Debugger", Op: "GetStackTrace", Err: err}
	}
	return
}
func (d *domainClient) Pause(ctx context.Context) (err error) {
	err = rpcc.Invoke(ctx, "Debugger.pause", nil, nil, d.conn)
	if err != nil {
		err = &internal.OpError{Domain: "Debugger", Op: "Pause", Err: err}
	}
	return
}
func (d *domainClient) PauseOnAsyncCall(ctx context.Context, args *PauseOnAsyncCallArgs) (err error) {
	if args != nil {
		err = rpcc.Invoke(ctx, "Debugger.pauseOnAsyncCall", args, nil, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Debugger.pauseOnAsyncCall", nil, nil, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Debugger", Op: "PauseOnAsyncCall", Err: err}
	}
	return
}
func (d *domainClient) RemoveBreakpoint(ctx context.Context, args *RemoveBreakpointArgs) (err error) {
	if args != nil {
		err = rpcc.Invoke(ctx, "Debugger.removeBreakpoint", args, nil, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Debugger.removeBreakpoint", nil, nil, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Debugger", Op: "RemoveBreakpoint", Err: err}
	}
	return
}
func (d *domainClient) RestartFrame(ctx context.Context, args *RestartFrameArgs) (reply *RestartFrameReply, err error) {
	reply = new(RestartFrameReply)
	if args != nil {
		err = rpcc.Invoke(ctx, "Debugger.restartFrame", args, reply, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Debugger.restartFrame", nil, reply, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Debugger", Op: "RestartFrame", Err: err}
	}
	return
}
func (d *domainClient) Resume(ctx context.Context) (err error) {
	err = rpcc.Invoke(ctx, "Debugger.resume", nil, nil, d.conn)
	if err != nil {
		err = &internal.OpError{Domain: "Debugger", Op: "Resume", Err: err}
	}
	return
}
func (d *domainClient) SearchInContent(ctx context.Context, args *SearchInContentArgs) (reply *SearchInContentReply, err error) {
	reply = new(SearchInContentReply)
	if args != nil {
		err = rpcc.Invoke(ctx, "Debugger.searchInContent", args, reply, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Debugger.searchInContent", nil, reply, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Debugger", Op: "SearchInContent", Err: err}
	}
	return
}
func (d *domainClient) SetAsyncCallStackDepth(ctx context.Context, args *SetAsyncCallStackDepthArgs) (err error) {
	if args != nil {
		err = rpcc.Invoke(ctx, "Debugger.setAsyncCallStackDepth", args, nil, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Debugger.setAsyncCallStackDepth", nil, nil, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Debugger", Op: "SetAsyncCallStackDepth", Err: err}
	}
	return
}
func (d *domainClient) SetBlackboxPatterns(ctx context.Context, args *SetBlackboxPatternsArgs) (err error) {
	if args != nil {
		err = rpcc.Invoke(ctx, "Debugger.setBlackboxPatterns", args, nil, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Debugger.setBlackboxPatterns", nil, nil, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Debugger", Op: "SetBlackboxPatterns", Err: err}
	}
	return
}