func (c *Debugger) SetBlackboxedRangesWithParams(ctx context.Context, v *DebuggerSetBlackboxedRangesParams) (*gcdmessage.ChromeResponse, error) {
	return c.target.SendDefaultRequest(ctx, &gcdmessage.ParamRequest{Id: c.target.GetId(), Method: "Debugger.setBlackboxedRanges", Params: v})
}
SetBlackboxedRangesWithParams - 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 gcdapi
import (
	"context"
	"github.com/wirepair/gcd/v2/gcdmessage"
)
type DebuggerLocation struct {
	ScriptId     string `json:"scriptId"`                
	LineNumber   int    `json:"lineNumber"`              
	ColumnNumber int    `json:"columnNumber,omitempty"`  
}
type DebuggerScriptPosition struct {
	LineNumber   int `json:"lineNumber"`    
	ColumnNumber int `json:"columnNumber"`  
}
type DebuggerLocationRange struct {
	ScriptId string                  `json:"scriptId"`  
	Start    *DebuggerScriptPosition `json:"start"`     
	End      *DebuggerScriptPosition `json:"end"`       
}
type DebuggerCallFrame struct {
	CallFrameId      string               `json:"callFrameId"`                 
	FunctionName     string               `json:"functionName"`                
	FunctionLocation *DebuggerLocation    `json:"functionLocation,omitempty"`  
	Location         *DebuggerLocation    `json:"location"`                    
	Url              string               `json:"url"`                         
	ScopeChain       []*DebuggerScope     `json:"scopeChain"`                  
	This             *RuntimeRemoteObject `json:"this"`                        
	ReturnValue      *RuntimeRemoteObject `json:"returnValue,omitempty"`       
}
type DebuggerScope struct {
	Type          string               `json:"type"`                     
	Object        *RuntimeRemoteObject `json:"object"`                   
	Name          string               `json:"name,omitempty"`           
	StartLocation *DebuggerLocation    `json:"startLocation,omitempty"`  
	EndLocation   *DebuggerLocation    `json:"endLocation,omitempty"`    
}
type DebuggerSearchMatch struct {
	LineNumber  float64 `json:"lineNumber"`   
	LineContent string  `json:"lineContent"`  
}
type DebuggerBreakLocation struct {
	ScriptId     string `json:"scriptId"`                
	LineNumber   int    `json:"lineNumber"`              
	ColumnNumber int    `json:"columnNumber,omitempty"`  
	Type         string `json:"type,omitempty"`          
}
type DebuggerDebugSymbols struct {
	Type        string `json:"type"`                   
	ExternalURL string `json:"externalURL,omitempty"`  
}
type DebuggerBreakpointResolvedEvent struct {
	Method string `json:"method"`
	Params struct {
		BreakpointId string            `json:"breakpointId"`  
		Location     *DebuggerLocation `json:"location"`      
	} `json:"Params,omitempty"`
}
type DebuggerPausedEvent struct {
	Method string `json:"method"`
	Params struct {
		CallFrames            []*DebuggerCallFrame   `json:"callFrames"`                       
		Reason                string                 `json:"reason"`                           
		Data                  map[string]interface{} `json:"data,omitempty"`                   
		HitBreakpoints        []string               `json:"hitBreakpoints,omitempty"`         
		AsyncStackTrace       *RuntimeStackTrace     `json:"asyncStackTrace,omitempty"`        
		AsyncStackTraceId     *RuntimeStackTraceId   `json:"asyncStackTraceId,omitempty"`      
		AsyncCallStackTraceId *RuntimeStackTraceId   `json:"asyncCallStackTraceId,omitempty"`  
	} `json:"Params,omitempty"`
}
type DebuggerScriptFailedToParseEvent struct {
	Method string `json:"method"`
	Params struct {
		ScriptId                string                 `json:"scriptId"`                           
		Url                     string                 `json:"url"`                                
		StartLine               int                    `json:"startLine"`                          
		StartColumn             int                    `json:"startColumn"`                        
		EndLine                 int                    `json:"endLine"`                            
		EndColumn               int                    `json:"endColumn"`                          
		ExecutionContextId      int                    `json:"executionContextId"`                 
		Hash                    string                 `json:"hash"`                               
		ExecutionContextAuxData map[string]interface{} `json:"executionContextAuxData,omitempty"`  
		SourceMapURL            string                 `json:"sourceMapURL,omitempty"`             
		HasSourceURL            bool                   `json:"hasSourceURL,omitempty"`             
		IsModule                bool                   `json:"isModule,omitempty"`                 
		Length                  int                    `json:"length,omitempty"`                   
		StackTrace              *RuntimeStackTrace     `json:"stackTrace,omitempty"`               
		CodeOffset              int                    `json:"codeOffset,omitempty"`               
		ScriptLanguage          string                 `json:"scriptLanguage,omitempty"`           
		EmbedderName            string                 `json:"embedderName,omitempty"`             
	} `json:"Params,omitempty"`
}
type DebuggerScriptParsedEvent struct {
	Method string `json:"method"`
	Params struct {
		ScriptId                string                 `json:"scriptId"`                           
		Url                     string                 `json:"url"`                                
		StartLine               int                    `json:"startLine"`                          
		StartColumn             int                    `json:"startColumn"`                        
		EndLine                 int                    `json:"endLine"`                            
		EndColumn               int                    `json:"endColumn"`                          
		ExecutionContextId      int                    `json:"executionContextId"`                 
		Hash                    string                 `json:"hash"`                               
		ExecutionContextAuxData map[string]interface{} `json:"executionContextAuxData,omitempty"`  
		IsLiveEdit              bool                   `json:"isLiveEdit,omitempty"`               
		SourceMapURL            string                 `json:"sourceMapURL,omitempty"`             
		HasSourceURL            bool                   `json:"hasSourceURL,omitempty"`             
		IsModule                bool                   `json:"isModule,omitempty"`                 
		Length                  int                    `json:"length,omitempty"`                   
		StackTrace              *RuntimeStackTrace     `json:"stackTrace,omitempty"`               
		CodeOffset              int                    `json:"codeOffset,omitempty"`               
		ScriptLanguage          string                 `json:"scriptLanguage,omitempty"`           
		DebugSymbols            *DebuggerDebugSymbols  `json:"debugSymbols,omitempty"`             
		EmbedderName            string                 `json:"embedderName,omitempty"`             
	} `json:"Params,omitempty"`
}
type Debugger struct {
	target gcdmessage.ChromeTargeter
}
func NewDebugger(target gcdmessage.ChromeTargeter) *Debugger {
	c := &Debugger{target: target}
	return c
}
type DebuggerContinueToLocationParams struct {
	Location *DebuggerLocation `json:"location"`
	TargetCallFrames string `json:"targetCallFrames,omitempty"`
}
func (c *Debugger) ContinueToLocationWithParams(ctx context.Context, v *DebuggerContinueToLocationParams) (*gcdmessage.ChromeResponse, error) {
	return c.target.SendDefaultRequest(ctx, &gcdmessage.ParamRequest{Id: c.target.GetId(), Method: "Debugger.continueToLocation", Params: v})
}
func (c *Debugger) ContinueToLocation(ctx context.Context, location *DebuggerLocation, targetCallFrames string) (*gcdmessage.ChromeResponse, error) {
	var v DebuggerContinueToLocationParams
	v.Location = location
	v.TargetCallFrames = targetCallFrames
	return c.ContinueToLocationWithParams(ctx, &v)
}
func (c *Debugger) Disable(ctx context.Context) (*gcdmessage.ChromeResponse, error) {
	return c.target.SendDefaultRequest(ctx, &gcdmessage.ParamRequest{Id: c.target.GetId(), Method: "Debugger.disable"})
}
type DebuggerEnableParams struct {
	MaxScriptsCacheSize float64 `json:"maxScriptsCacheSize,omitempty"`
}
func (c *Debugger) EnableWithParams(ctx context.Context, v *DebuggerEnableParams) (string, error) {
	resp, err := c.target.SendCustomReturn(ctx, &gcdmessage.ParamRequest{Id: c.target.GetId(), Method: "Debugger.enable", Params: v})
	if err != nil {
		return "", err
	}
	var chromeData struct {
		Result struct {
			DebuggerId string
		}
	}
	if resp == nil {
		return "", &gcdmessage.ChromeEmptyResponseErr{}
	}
	cerr := &gcdmessage.ChromeErrorResponse{}
	json.Unmarshal(resp.Data, cerr)
	if cerr != nil && cerr.Error != nil {
		return "", &gcdmessage.ChromeRequestErr{Resp: cerr}
	}
	if err := json.Unmarshal(resp.Data, &chromeData); err != nil {
		return "", err
	}
	return chromeData.Result.DebuggerId, nil
}
func (c *Debugger) Enable(ctx context.Context, maxScriptsCacheSize float64) (string, error) {
	var v DebuggerEnableParams
	v.MaxScriptsCacheSize = maxScriptsCacheSize
	return c.EnableWithParams(ctx, &v)
}
type DebuggerEvaluateOnCallFrameParams struct {
	CallFrameId string `json:"callFrameId"`
	Expression string `json:"expression"`
	ObjectGroup string `json:"objectGroup,omitempty"`
	IncludeCommandLineAPI bool `json:"includeCommandLineAPI,omitempty"`
	Silent bool `json:"silent,omitempty"`
	ReturnByValue bool `json:"returnByValue,omitempty"`
	GeneratePreview bool `json:"generatePreview,omitempty"`
	ThrowOnSideEffect bool `json:"throwOnSideEffect,omitempty"`
	Timeout float64 `json:"timeout,omitempty"`
}
func (c *Debugger) EvaluateOnCallFrameWithParams(ctx context.Context, v *DebuggerEvaluateOnCallFrameParams) (*RuntimeRemoteObject, *RuntimeExceptionDetails, error) {
	resp, err := c.target.SendCustomReturn(ctx, &gcdmessage.ParamRequest{Id: c.target.GetId(), Method: "Debugger.evaluateOnCallFrame", Params: v})
	if err != nil {
		return nil, nil, err
	}
	var chromeData struct {
		Result struct {
			Result           *RuntimeRemoteObject
			ExceptionDetails *RuntimeExceptionDetails
		}
	}
	if resp == nil {
		return nil, nil, &gcdmessage.ChromeEmptyResponseErr{}
	}
	cerr := &gcdmessage.ChromeErrorResponse{}
	json.Unmarshal(resp.Data, cerr)
	if cerr != nil && cerr.Error != nil {
		return nil, nil, &gcdmessage.ChromeRequestErr{Resp: cerr}
	}
	if err := json.Unmarshal(resp.Data, &chromeData); err != nil {
		return nil, nil, err
	}
	return chromeData.Result.Result, chromeData.Result.ExceptionDetails, nil
}
func (c *Debugger) EvaluateOnCallFrame(ctx context.Context, callFrameId string, expression string, objectGroup string, includeCommandLineAPI bool, silent bool, returnByValue bool, generatePreview bool, throwOnSideEffect bool, timeout float64) (*RuntimeRemoteObject, *RuntimeExceptionDetails, error) {
	var v DebuggerEvaluateOnCallFrameParams
	v.CallFrameId = callFrameId
	v.Expression = expression
	v.ObjectGroup = objectGroup
	v.IncludeCommandLineAPI = includeCommandLineAPI
	v.Silent = silent
	v.ReturnByValue = returnByValue
	v.GeneratePreview = generatePreview
	v.ThrowOnSideEffect = throwOnSideEffect
	v.Timeout = timeout
	return c.EvaluateOnCallFrameWithParams(ctx, &v)
}
type DebuggerGetPossibleBreakpointsParams struct {
	Start *DebuggerLocation `json:"start"`
	End *DebuggerLocation `json:"end,omitempty"`
	RestrictToFunction bool `json:"restrictToFunction,omitempty"`
}
func (c *Debugger) GetPossibleBreakpointsWithParams(ctx context.Context, v *DebuggerGetPossibleBreakpointsParams) ([]*DebuggerBreakLocation, error) {
	resp, err := c.target.SendCustomReturn(ctx, &gcdmessage.ParamRequest{Id: c.target.GetId(), Method: "Debugger.getPossibleBreakpoints", Params: v})
	if err != nil {
		return nil, err
	}
	var chromeData struct {
		Result struct {
			Locations []*DebuggerBreakLocation
		}
	}
	if resp == nil {
		return nil, &gcdmessage.ChromeEmptyResponseErr{}
	}
	cerr := &gcdmessage.ChromeErrorResponse{}
	json.Unmarshal(resp.Data, cerr)
	if cerr != nil && cerr.Error != nil {
		return nil, &gcdmessage.ChromeRequestErr{Resp: cerr}
	}
	if err := json.Unmarshal(resp.Data, &chromeData); err != nil {
		return nil, err
	}
	return chromeData.Result.Locations, nil
}
func (c *Debugger) GetPossibleBreakpoints(ctx context.Context, start *DebuggerLocation, end *DebuggerLocation, restrictToFunction bool) ([]*DebuggerBreakLocation, error) {
	var v DebuggerGetPossibleBreakpointsParams
	v.Start = start
	v.End = end
	v.RestrictToFunction = restrictToFunction
	return c.GetPossibleBreakpointsWithParams(ctx, &v)
}
type DebuggerGetScriptSourceParams struct {
	ScriptId string `json:"scriptId"`
}
func (c *Debugger) GetScriptSourceWithParams(ctx context.Context, v *DebuggerGetScriptSourceParams) (string, string, error) {
	resp, err := c.target.SendCustomReturn(ctx, &gcdmessage.ParamRequest{Id: c.target.GetId(), Method: "Debugger.getScriptSource", Params: v})
	if err != nil {
		return "", "", err
	}
	var chromeData struct {
		Result struct {
			ScriptSource string
			Bytecode     string
		}
	}
	if resp == nil {
		return "", "", &gcdmessage.ChromeEmptyResponseErr{}
	}
	cerr := &gcdmessage.ChromeErrorResponse{}
	json.Unmarshal(resp.Data, cerr)
	if cerr != nil && cerr.Error != nil {
		return "", "", &gcdmessage.ChromeRequestErr{Resp: cerr}
	}
	if err := json.Unmarshal(resp.Data, &chromeData); err != nil {
		return "", "", err
	}
	return chromeData.Result.ScriptSource, chromeData.Result.Bytecode, nil
}
func (c *Debugger) GetScriptSource(ctx context.Context, scriptId string) (string, string, error) {
	var v DebuggerGetScriptSourceParams
	v.ScriptId = scriptId
	return c.GetScriptSourceWithParams(ctx, &v)
}
type DebuggerGetWasmBytecodeParams struct {
	ScriptId string `json:"scriptId"`
}
func (c *Debugger) GetWasmBytecodeWithParams(ctx context.Context, v *DebuggerGetWasmBytecodeParams) (string, error) {
	resp, err := c.target.SendCustomReturn(ctx, &gcdmessage.ParamRequest{Id: c.target.GetId(), Method: "Debugger.getWasmBytecode", Params: v})
	if err != nil {
		return "", err
	}
	var chromeData struct {
		Result struct {
			Bytecode string
		}
	}
	if resp == nil {
		return "", &gcdmessage.ChromeEmptyResponseErr{}
	}
	cerr := &gcdmessage.ChromeErrorResponse{}
	json.Unmarshal(resp.Data, cerr)
	if cerr != nil && cerr.Error != nil {
		return "", &gcdmessage.ChromeRequestErr{Resp: cerr}
	}
	if err := json.Unmarshal(resp.Data, &chromeData); err != nil {
		return "", err
	}
	return chromeData.Result.Bytecode, nil
}
func (c *Debugger) GetWasmBytecode(ctx context.Context, scriptId string) (string, error) {
	var v DebuggerGetWasmBytecodeParams
	v.ScriptId = scriptId
	return c.GetWasmBytecodeWithParams(ctx, &v)
}
type DebuggerGetStackTraceParams struct {
	StackTraceId *RuntimeStackTraceId `json:"stackTraceId"`
}
func (c *Debugger) GetStackTraceWithParams(ctx context.Context, v *DebuggerGetStackTraceParams) (*RuntimeStackTrace, error) {
	resp, err := c.target.SendCustomReturn(ctx, &gcdmessage.ParamRequest{Id: c.target.GetId(), Method: "Debugger.getStackTrace", Params: v})
	if err != nil {
		return nil, err
	}
	var chromeData struct {
		Result struct {
			StackTrace *RuntimeStackTrace
		}
	}
	if resp == nil {
		return nil, &gcdmessage.ChromeEmptyResponseErr{}
	}
	cerr := &gcdmessage.ChromeErrorResponse{}
	json.Unmarshal(resp.Data, cerr)
	if cerr != nil && cerr.Error != nil {
		return nil, &gcdmessage.ChromeRequestErr{Resp: cerr}
	}
	if err := json.Unmarshal(resp.Data, &chromeData); err != nil {
		return nil, err
	}
	return chromeData.Result.StackTrace, nil
}
func (c *Debugger) GetStackTrace(ctx context.Context, stackTraceId *RuntimeStackTraceId) (*RuntimeStackTrace, error) {
	var v DebuggerGetStackTraceParams
	v.StackTraceId = stackTraceId
	return c.GetStackTraceWithParams(ctx, &v)
}
func (c *Debugger) Pause(ctx context.Context) (*gcdmessage.ChromeResponse, error) {
	return c.target.SendDefaultRequest(ctx, &gcdmessage.ParamRequest{Id: c.target.GetId(), Method: "Debugger.pause"})
}
type DebuggerPauseOnAsyncCallParams struct {
	ParentStackTraceId *RuntimeStackTraceId `json:"parentStackTraceId"`
}
func (c *Debugger) PauseOnAsyncCallWithParams(ctx context.Context, v *DebuggerPauseOnAsyncCallParams) (*gcdmessage.ChromeResponse, error) {
	return c.target.SendDefaultRequest(ctx, &gcdmessage.ParamRequest{Id: c.target.GetId(), Method: "Debugger.pauseOnAsyncCall", Params: v})
}
func (c *Debugger) PauseOnAsyncCall(ctx context.Context, parentStackTraceId *RuntimeStackTraceId) (*gcdmessage.ChromeResponse, error) {
	var v DebuggerPauseOnAsyncCallParams
	v.ParentStackTraceId = parentStackTraceId
	return c.PauseOnAsyncCallWithParams(ctx, &v)
}
type DebuggerRemoveBreakpointParams struct {
	BreakpointId string `json:"breakpointId"`
}
func (c *Debugger) RemoveBreakpointWithParams(ctx context.Context, v *DebuggerRemoveBreakpointParams) (*gcdmessage.ChromeResponse, error) {
	return c.target.SendDefaultRequest(ctx, &gcdmessage.ParamRequest{Id: c.target.GetId(), Method: "Debugger.removeBreakpoint", Params: v})
}
func (c *Debugger) RemoveBreakpoint(ctx context.Context, breakpointId string) (*gcdmessage.ChromeResponse, error) {
	var v DebuggerRemoveBreakpointParams
	v.BreakpointId = breakpointId
	return c.RemoveBreakpointWithParams(ctx, &v)
}
type DebuggerRestartFrameParams struct {
	CallFrameId string `json:"callFrameId"`
}
func (c *Debugger) RestartFrameWithParams(ctx context.Context, v *DebuggerRestartFrameParams) ([]*DebuggerCallFrame, *RuntimeStackTrace, *RuntimeStackTraceId, error) {
	resp, err := c.target.SendCustomReturn(ctx, &gcdmessage.ParamRequest{Id: c.target.GetId(), Method: "Debugger.restartFrame", Params: v})
	if err != nil {
		return nil, nil, nil, err
	}
	var chromeData struct {
		Result struct {
			CallFrames        []*DebuggerCallFrame
			AsyncStackTrace   *RuntimeStackTrace
			AsyncStackTraceId *RuntimeStackTraceId
		}
	}
	if resp == nil {
		return nil, nil, nil, &gcdmessage.ChromeEmptyResponseErr{}
	}
	cerr := &gcdmessage.ChromeErrorResponse{}
	json.Unmarshal(resp.Data, cerr)
	if cerr != nil && cerr.Error != nil {
		return nil, nil, nil, &gcdmessage.ChromeRequestErr{Resp: cerr}
	}
	if err := json.Unmarshal(resp.Data, &chromeData); err != nil {
		return nil, nil, nil, err
	}
	return chromeData.Result.CallFrames, chromeData.Result.AsyncStackTrace, chromeData.Result.AsyncStackTraceId, nil
}
func (c *Debugger) RestartFrame(ctx context.Context, callFrameId string) ([]*DebuggerCallFrame, *RuntimeStackTrace, *RuntimeStackTraceId, error) {
	var v DebuggerRestartFrameParams
	v.CallFrameId = callFrameId
	return c.RestartFrameWithParams(ctx, &v)
}
type DebuggerResumeParams struct {
	TerminateOnResume bool `json:"terminateOnResume,omitempty"`
}
func (c *Debugger) ResumeWithParams(ctx context.Context, v *DebuggerResumeParams) (*gcdmessage.ChromeResponse, error) {
	return c.target.SendDefaultRequest(ctx, &gcdmessage.ParamRequest{Id: c.target.GetId(), Method: "Debugger.resume", Params: v})
}
func (c *Debugger) Resume(ctx context.Context, terminateOnResume bool) (*gcdmessage.ChromeResponse, error) {
	var v DebuggerResumeParams
	v.TerminateOnResume = terminateOnResume
	return c.ResumeWithParams(ctx, &v)
}
type DebuggerSearchInContentParams struct {
	ScriptId string `json:"scriptId"`
	Query string `json:"query"`
	CaseSensitive bool `json:"caseSensitive,omitempty"`
	IsRegex bool `json:"isRegex,omitempty"`
}
func (c *Debugger) SearchInContentWithParams(ctx context.Context, v *DebuggerSearchInContentParams) ([]*DebuggerSearchMatch, error) {
	resp, err := c.target.SendCustomReturn(ctx, &gcdmessage.ParamRequest{Id: c.target.GetId(), Method: "Debugger.searchInContent", Params: v})
	if err != nil {
		return nil, err
	}
	var chromeData struct {
		Result struct {
			Result []*DebuggerSearchMatch
		}
	}
	if resp == nil {
		return nil, &gcdmessage.ChromeEmptyResponseErr{}
	}
	cerr := &gcdmessage.ChromeErrorResponse{}
	json.Unmarshal(resp.Data, cerr)
	if cerr != nil && cerr.Error != nil {
		return nil, &gcdmessage.ChromeRequestErr{Resp: cerr}
	}
	if err := json.Unmarshal(resp.Data, &chromeData); err != nil {
		return nil, err
	}
	return chromeData.Result.Result, nil
}
func (c *Debugger) SearchInContent(ctx context.Context, scriptId string, query string, caseSensitive bool, isRegex bool) ([]*DebuggerSearchMatch, error) {
	var v DebuggerSearchInContentParams
	v.ScriptId = scriptId
	v.Query = query
	v.CaseSensitive = caseSensitive
	v.IsRegex = isRegex
	return c.SearchInContentWithParams(ctx, &v)
}
type DebuggerSetAsyncCallStackDepthParams struct {
	MaxDepth int `json:"maxDepth"`
}
func (c *Debugger) SetAsyncCallStackDepthWithParams(ctx context.Context, v *DebuggerSetAsyncCallStackDepthParams) (*gcdmessage.ChromeResponse, error) {
	return c.target.SendDefaultRequest(ctx, &gcdmessage.ParamRequest{Id: c.target.GetId(), Method: "Debugger.setAsyncCallStackDepth", Params: v})
}
func (c *Debugger) SetAsyncCallStackDepth(ctx context.Context, maxDepth int) (*gcdmessage.ChromeResponse, error) {
	var v DebuggerSetAsyncCallStackDepthParams
	v.MaxDepth = maxDepth
	return c.SetAsyncCallStackDepthWithParams(ctx, &v)
}
type DebuggerSetBlackboxPatternsParams struct {
	Patterns []string `json:"patterns"`
}
func (c *Debugger) SetBlackboxPatternsWithParams(ctx context.Context, v *DebuggerSetBlackboxPatternsParams) (*gcdmessage.ChromeResponse, error) {
	return c.target.SendDefaultRequest(ctx, &gcdmessage.ParamRequest{Id: c.target.GetId(), Method: "Debugger.setBlackboxPatterns", Params: v})
}
func (c *Debugger) SetBlackboxPatterns(ctx context.Context, patterns []string) (*gcdmessage.ChromeResponse, error) {
	var v DebuggerSetBlackboxPatternsParams
	v.Patterns = patterns
	return c.SetBlackboxPatternsWithParams(ctx, &v)
}
type DebuggerSetBlackboxedRangesParams struct {
	ScriptId string `json:"scriptId"`
	Positions []*DebuggerScriptPosition `json:"positions"`
}