func (p *SetShowDebugBordersParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetShowDebugBorders, p, nil)
}

func ( p * SetShowDebugBordersParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetShowDebugBorders , p , nil ) }

// Do executes Overlay.setShowDebugBorders against the provided context.

Do executes Overlay . setShowDebugBorders against the provided context .


func (p *SetShowFPSCounterParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetShowFPSCounter, p, nil)
}

func ( p * SetShowFPSCounterParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetShowFPSCounter , p , nil ) }

// Do executes Overlay.setShowFPSCounter against the provided context.

Do executes Overlay . setShowFPSCounter against the provided context .


func (p *SetShowPaintRectsParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetShowPaintRects, p, nil)
}

func ( p * SetShowPaintRectsParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetShowPaintRects , p , nil ) }

// Do executes Overlay.setShowPaintRects against the provided context.

Do executes Overlay . setShowPaintRects against the provided context .


func (p *SetShowScrollBottleneckRectsParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetShowScrollBottleneckRects, p, nil)
}

func ( p * SetShowScrollBottleneckRectsParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetShowScrollBottleneckRects , p , nil ) }

// Do executes Overlay.setShowScrollBottleneckRects against the provided context.

Do executes Overlay . setShowScrollBottleneckRects against the provided context .


func (p *SetShowHitTestBordersParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetShowHitTestBorders, p, nil)
}

func ( p * SetShowHitTestBordersParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetShowHitTestBorders , p , nil ) }

// Do executes Overlay.setShowHitTestBorders against the provided context.

Do executes Overlay . setShowHitTestBorders against the provided context .


func (p *SetShowViewportSizeOnResizeParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetShowViewportSizeOnResize, p, nil)
}

func ( p * SetShowViewportSizeOnResizeParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetShowViewportSizeOnResize , p , nil ) }

// Do executes Overlay.setShowViewportSizeOnResize against the provided context.

Do executes Overlay . setShowViewportSizeOnResize against the provided context .


func (p *ClearBrowserCacheParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandClearBrowserCache, nil, nil)
}

func ( p * ClearBrowserCacheParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandClearBrowserCache , nil , nil ) }

// Do executes Network.clearBrowserCache against the provided context.

Do executes Network . clearBrowserCache against the provided context .


func (p *ClearBrowserCookiesParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandClearBrowserCookies, nil, nil)
}

func ( p * ClearBrowserCookiesParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandClearBrowserCookies , nil , nil ) }

// Do executes Network.clearBrowserCookies against the provided context.

Do executes Network . clearBrowserCookies against the provided context .


func (p ContinueInterceptedRequestParams) WithErrorReason(errorReason ErrorReason) *ContinueInterceptedRequestParams {
	p.ErrorReason = errorReason
	return &p
}

func ( p ContinueInterceptedRequestParams ) WithErrorReason ( errorReason ErrorReason ) * ContinueInterceptedRequestParams { p . ErrorReason = errorReason return & p }

// WithErrorReason if set this causes the request to fail with the given
// reason. Passing Aborted for requests marked with isNavigationRequest also
// cancels the navigation. Must not be set in response to an authChallenge.

WithErrorReason if set this causes the request to fail with the given reason . Passing Aborted for requests marked with isNavigationRequest also cancels the navigation . Must not be set in response to an authChallenge .


func (p ContinueInterceptedRequestParams) WithRawResponse(rawResponse string) *ContinueInterceptedRequestParams {
	p.RawResponse = rawResponse
	return &p
}

func ( p ContinueInterceptedRequestParams ) WithRawResponse ( rawResponse string ) * ContinueInterceptedRequestParams { p . RawResponse = rawResponse return & p }

// WithRawResponse if set the requests completes using with the provided
// base64 encoded raw response, including HTTP status line and headers etc...
// Must not be set in response to an authChallenge.

WithRawResponse if set the requests completes using with the provided base64 encoded raw response including HTTP status line and headers etc ... Must not be set in response to an authChallenge .


func (p ContinueInterceptedRequestParams) WithURL(url string) *ContinueInterceptedRequestParams {
	p.URL = url
	return &p
}

func ( p ContinueInterceptedRequestParams ) WithURL ( url string ) * ContinueInterceptedRequestParams { p . URL = url return & p }

// WithURL if set the request url will be modified in a way that's not
// observable by page. Must not be set in response to an authChallenge.

WithURL if set the request url will be modified in a way that s not observable by page . Must not be set in response to an authChallenge .


func (p ContinueInterceptedRequestParams) WithMethod(method string) *ContinueInterceptedRequestParams {
	p.Method = method
	return &p
}

func ( p ContinueInterceptedRequestParams ) WithMethod ( method string ) * ContinueInterceptedRequestParams { p . Method = method return & p }

// WithMethod if set this allows the request method to be overridden. Must
// not be set in response to an authChallenge.

WithMethod if set this allows the request method to be overridden . Must not be set in response to an authChallenge .


func (p ContinueInterceptedRequestParams) WithPostData(postData string) *ContinueInterceptedRequestParams {
	p.PostData = postData
	return &p
}

func ( p ContinueInterceptedRequestParams ) WithPostData ( postData string ) * ContinueInterceptedRequestParams { p . PostData = postData return & p }

// WithPostData if set this allows postData to be set. Must not be set in
// response to an authChallenge.

WithPostData if set this allows postData to be set . Must not be set in response to an authChallenge .


func (p ContinueInterceptedRequestParams) WithHeaders(headers Headers) *ContinueInterceptedRequestParams {
	p.Headers = headers
	return &p
}

func ( p ContinueInterceptedRequestParams ) WithHeaders ( headers Headers ) * ContinueInterceptedRequestParams { p . Headers = headers return & p }

// WithHeaders if set this allows the request headers to be changed. Must not
// be set in response to an authChallenge.

WithHeaders if set this allows the request headers to be changed . Must not be set in response to an authChallenge .


func (p ContinueInterceptedRequestParams) WithAuthChallengeResponse(authChallengeResponse *AuthChallengeResponse) *ContinueInterceptedRequestParams {
	p.AuthChallengeResponse = authChallengeResponse
	return &p
}

func ( p ContinueInterceptedRequestParams ) WithAuthChallengeResponse ( authChallengeResponse * AuthChallengeResponse ) * ContinueInterceptedRequestParams { p . AuthChallengeResponse = authChallengeResponse return & p }

// WithAuthChallengeResponse response to a requestIntercepted with an
// authChallenge. Must not be set otherwise.

WithAuthChallengeResponse response to a requestIntercepted with an authChallenge . Must not be set otherwise .


func (p *ContinueInterceptedRequestParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandContinueInterceptedRequest, p, nil)
}

func ( p * ContinueInterceptedRequestParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandContinueInterceptedRequest , p , nil ) }

// Do executes Network.continueInterceptedRequest against the provided context.

Do executes Network . continueInterceptedRequest against the provided context .


func (p DeleteCookiesParams) WithURL(url string) *DeleteCookiesParams {
	p.URL = url
	return &p
}

func ( p DeleteCookiesParams ) WithURL ( url string ) * DeleteCookiesParams { p . URL = url return & p }

// WithURL if specified, deletes all the cookies with the given name where
// domain and path match provided URL.

WithURL if specified deletes all the cookies with the given name where domain and path match provided URL .


func (p DeleteCookiesParams) WithDomain(domain string) *DeleteCookiesParams {
	p.Domain = domain
	return &p
}

func ( p DeleteCookiesParams ) WithDomain ( domain string ) * DeleteCookiesParams { p . Domain = domain return & p }

// WithDomain if specified, deletes only cookies with the exact domain.

WithDomain if specified deletes only cookies with the exact domain .


func (p DeleteCookiesParams) WithPath(path string) *DeleteCookiesParams {
	p.Path = path
	return &p
}

func ( p DeleteCookiesParams ) WithPath ( path string ) * DeleteCookiesParams { p . Path = path return & p }

// WithPath if specified, deletes only cookies with the exact path.

WithPath if specified deletes only cookies with the exact path .


func (p *DeleteCookiesParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandDeleteCookies, p, nil)
}

func ( p * DeleteCookiesParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandDeleteCookies , p , nil ) }

// Do executes Network.deleteCookies against the provided context.

Do executes Network . deleteCookies against the provided context .


func (p EmulateNetworkConditionsParams) WithConnectionType(connectionType ConnectionType) *EmulateNetworkConditionsParams {
	p.ConnectionType = connectionType
	return &p
}

func ( p EmulateNetworkConditionsParams ) WithConnectionType ( connectionType ConnectionType ) * EmulateNetworkConditionsParams { p . ConnectionType = connectionType return & p }

// WithConnectionType connection type if known.

WithConnectionType connection type if known .


func (p *EmulateNetworkConditionsParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandEmulateNetworkConditions, p, nil)
}

func ( p * EmulateNetworkConditionsParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandEmulateNetworkConditions , p , nil ) }

// Do executes Network.emulateNetworkConditions against the provided context.

Do executes Network . emulateNetworkConditions against the provided context .


func (p *EnableParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandEnable, p, nil)
}

func ( p * EnableParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandEnable , p , nil ) }

// Do executes Network.enable against the provided context.

Do executes Network . enable against the provided context .


func (p GetCookiesParams) WithUrls(urls []string) *GetCookiesParams {
	p.Urls = urls
	return &p
}

func ( p GetCookiesParams ) WithUrls ( urls [ ] string ) * GetCookiesParams { p . Urls = urls return & p }

// WithUrls the list of URLs for which applicable cookies will be fetched.

WithUrls the list of URLs for which applicable cookies will be fetched .


func (p *ReplayXHRParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandReplayXHR, p, nil)
}

func ( p * ReplayXHRParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandReplayXHR , p , nil ) }

// Do executes Network.replayXHR against the provided context.

Do executes Network . replayXHR against the provided context .


func (p *SetBlockedURLSParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetBlockedURLS, p, nil)
}

func ( p * SetBlockedURLSParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetBlockedURLS , p , nil ) }

// Do executes Network.setBlockedURLs against the provided context.

Do executes Network . setBlockedURLs against the provided context .


func (p *SetBypassServiceWorkerParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetBypassServiceWorker, p, nil)
}

func ( p * SetBypassServiceWorkerParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetBypassServiceWorker , p , nil ) }

// Do executes Network.setBypassServiceWorker against the provided context.

Do executes Network . setBypassServiceWorker against the provided context .


func (p *SetCacheDisabledParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetCacheDisabled, p, nil)
}

func ( p * SetCacheDisabledParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetCacheDisabled , p , nil ) }

// Do executes Network.setCacheDisabled against the provided context.

Do executes Network . setCacheDisabled against the provided context .


func (p SetCookieParams) WithURL(url string) *SetCookieParams {
	p.URL = url
	return &p
}

func ( p SetCookieParams ) WithURL ( url string ) * SetCookieParams { p . URL = url return & p }

// WithURL the request-URI to associate with the setting of the cookie. This
// value can affect the default domain and path values of the created cookie.

WithURL the request - URI to associate with the setting of the cookie . This value can affect the default domain and path values of the created cookie .


func (p SetCookieParams) WithDomain(domain string) *SetCookieParams {
	p.Domain = domain
	return &p
}

func ( p SetCookieParams ) WithDomain ( domain string ) * SetCookieParams { p . Domain = domain return & p }


func (p SetCookieParams) WithPath(path string) *SetCookieParams {
	p.Path = path
	return &p
}

func ( p SetCookieParams ) WithPath ( path string ) * SetCookieParams { p . Path = path return & p }


func (p SetCookieParams) WithSecure(secure bool) *SetCookieParams {
	p.Secure = secure
	return &p
}

func ( p SetCookieParams ) WithSecure ( secure bool ) * SetCookieParams { p . Secure = secure return & p }


func (p SetCookieParams) WithHTTPOnly(httpOnly bool) *SetCookieParams {
	p.HTTPOnly = httpOnly
	return &p
}

func ( p SetCookieParams ) WithHTTPOnly ( httpOnly bool ) * SetCookieParams { p . HTTPOnly = httpOnly return & p }

// WithHTTPOnly true if cookie is http-only.

WithHTTPOnly true if cookie is http - only .


func (p SetCookieParams) WithSameSite(sameSite CookieSameSite) *SetCookieParams {
	p.SameSite = sameSite
	return &p
}

func ( p SetCookieParams ) WithSameSite ( sameSite CookieSameSite ) * SetCookieParams { p . SameSite = sameSite return & p }


func (p SetCookieParams) WithExpires(expires *cdp.TimeSinceEpoch) *SetCookieParams {
	p.Expires = expires
	return &p
}

func ( p SetCookieParams ) WithExpires ( expires * cdp . TimeSinceEpoch ) * SetCookieParams { p . Expires = expires return & p }

// WithExpires cookie expiration date, session cookie if not set.

WithExpires cookie expiration date session cookie if not set .


func (p *SetCookiesParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetCookies, p, nil)
}

func ( p * SetCookiesParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetCookies , p , nil ) }

// Do executes Network.setCookies against the provided context.

Do executes Network . setCookies against the provided context .


func (p *SetDataSizeLimitsForTestParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetDataSizeLimitsForTest, p, nil)
}

func ( p * SetDataSizeLimitsForTestParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetDataSizeLimitsForTest , p , nil ) }

// Do executes Network.setDataSizeLimitsForTest against the provided context.

Do executes Network . setDataSizeLimitsForTest against the provided context .


func (p *SetExtraHTTPHeadersParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetExtraHTTPHeaders, p, nil)
}

func ( p * SetExtraHTTPHeadersParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetExtraHTTPHeaders , p , nil ) }

// Do executes Network.setExtraHTTPHeaders against the provided context.

Do executes Network . setExtraHTTPHeaders against the provided context .


func (p *SetRequestInterceptionParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetRequestInterception, p, nil)
}

func ( p * SetRequestInterceptionParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetRequestInterception , p , nil ) }

// Do executes Network.setRequestInterception against the provided context.

Do executes Network . setRequestInterception against the provided context .


func (p *ClearDeviceMetricsOverrideParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandClearDeviceMetricsOverride, nil, nil)
}

func ( p * ClearDeviceMetricsOverrideParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandClearDeviceMetricsOverride , nil , nil ) }

// Do executes Emulation.clearDeviceMetricsOverride against the provided context.

Do executes Emulation . clearDeviceMetricsOverride against the provided context .


func (p *ClearGeolocationOverrideParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandClearGeolocationOverride, nil, nil)
}

func ( p * ClearGeolocationOverrideParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandClearGeolocationOverride , nil , nil ) }

// Do executes Emulation.clearGeolocationOverride against the provided context.

Do executes Emulation . clearGeolocationOverride against the provided context .


func (p *ResetPageScaleFactorParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandResetPageScaleFactor, nil, nil)
}

func ( p * ResetPageScaleFactorParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandResetPageScaleFactor , nil , nil ) }

// Do executes Emulation.resetPageScaleFactor against the provided context.

Do executes Emulation . resetPageScaleFactor against the provided context .


func (p *SetFocusEmulationEnabledParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetFocusEmulationEnabled, p, nil)
}

func ( p * SetFocusEmulationEnabledParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetFocusEmulationEnabled , p , nil ) }

// Do executes Emulation.setFocusEmulationEnabled against the provided context.

Do executes Emulation . setFocusEmulationEnabled against the provided context .


func (p *SetCPUThrottlingRateParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetCPUThrottlingRate, p, nil)
}

func ( p * SetCPUThrottlingRateParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetCPUThrottlingRate , p , nil ) }

// Do executes Emulation.setCPUThrottlingRate against the provided context.

Do executes Emulation . setCPUThrottlingRate against the provided context .


func (p SetDefaultBackgroundColorOverrideParams) WithColor(color *cdp.RGBA) *SetDefaultBackgroundColorOverrideParams {
	p.Color = color
	return &p
}

func ( p SetDefaultBackgroundColorOverrideParams ) WithColor ( color * cdp . RGBA ) * SetDefaultBackgroundColorOverrideParams { p . Color = color return & p }

// WithColor rGBA of the default background color. If not specified, any
// existing override will be cleared.

WithColor rGBA of the default background color . If not specified any existing override will be cleared .


func (p *SetDefaultBackgroundColorOverrideParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetDefaultBackgroundColorOverride, p, nil)
}

// Do executes Emulation.setDefaultBackgroundColorOverride against the provided context.

Do executes Emulation . setDefaultBackgroundColorOverride against the provided context .


func (p SetDeviceMetricsOverrideParams) WithScale(scale float64) *SetDeviceMetricsOverrideParams {
	p.Scale = scale
	return &p
}

func ( p SetDeviceMetricsOverrideParams ) WithScale ( scale float64 ) * SetDeviceMetricsOverrideParams { p . Scale = scale return & p }

// WithScale scale to apply to resulting view image.

WithScale scale to apply to resulting view image .


func (p SetDeviceMetricsOverrideParams) WithDontSetVisibleSize(dontSetVisibleSize bool) *SetDeviceMetricsOverrideParams {
	p.DontSetVisibleSize = dontSetVisibleSize
	return &p
}

func ( p SetDeviceMetricsOverrideParams ) WithDontSetVisibleSize ( dontSetVisibleSize bool ) * SetDeviceMetricsOverrideParams { p . DontSetVisibleSize = dontSetVisibleSize return & p }

// WithDontSetVisibleSize do not set visible view size, rely upon explicit
// setVisibleSize call.

WithDontSetVisibleSize do not set visible view size rely upon explicit setVisibleSize call .


func (p SetDeviceMetricsOverrideParams) WithScreenOrientation(screenOrientation *ScreenOrientation) *SetDeviceMetricsOverrideParams {
	p.ScreenOrientation = screenOrientation
	return &p
}

func ( p SetDeviceMetricsOverrideParams ) WithScreenOrientation ( screenOrientation * ScreenOrientation ) * SetDeviceMetricsOverrideParams { p . ScreenOrientation = screenOrientation return & p }

// WithScreenOrientation screen orientation override.

WithScreenOrientation screen orientation override .


func (p *SetDeviceMetricsOverrideParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetDeviceMetricsOverride, p, nil)
}

func ( p * SetDeviceMetricsOverrideParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetDeviceMetricsOverride , p , nil ) }

// Do executes Emulation.setDeviceMetricsOverride against the provided context.

Do executes Emulation . setDeviceMetricsOverride against the provided context .


func (p *SetScrollbarsHiddenParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetScrollbarsHidden, p, nil)
}

func ( p * SetScrollbarsHiddenParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetScrollbarsHidden , p , nil ) }

// Do executes Emulation.setScrollbarsHidden against the provided context.

Do executes Emulation . setScrollbarsHidden against the provided context .


func (p *SetDocumentCookieDisabledParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetDocumentCookieDisabled, p, nil)
}

func ( p * SetDocumentCookieDisabledParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetDocumentCookieDisabled , p , nil ) }

// Do executes Emulation.setDocumentCookieDisabled against the provided context.

Do executes Emulation . setDocumentCookieDisabled against the provided context .


func (p *SetEmitTouchEventsForMouseParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetEmitTouchEventsForMouse, p, nil)
}

func ( p * SetEmitTouchEventsForMouseParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetEmitTouchEventsForMouse , p , nil ) }

// Do executes Emulation.setEmitTouchEventsForMouse against the provided context.

Do executes Emulation . setEmitTouchEventsForMouse against the provided context .


func (p *SetEmulatedMediaParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetEmulatedMedia, p, nil)
}

func ( p * SetEmulatedMediaParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetEmulatedMedia , p , nil ) }

// Do executes Emulation.setEmulatedMedia against the provided context.

Do executes Emulation . setEmulatedMedia against the provided context .


func (p SetGeolocationOverrideParams) WithLatitude(latitude float64) *SetGeolocationOverrideParams {
	p.Latitude = latitude
	return &p
}

func ( p SetGeolocationOverrideParams ) WithLatitude ( latitude float64 ) * SetGeolocationOverrideParams { p . Latitude = latitude return & p }


func (p SetGeolocationOverrideParams) WithLongitude(longitude float64) *SetGeolocationOverrideParams {
	p.Longitude = longitude
	return &p
}

func ( p SetGeolocationOverrideParams ) WithLongitude ( longitude float64 ) * SetGeolocationOverrideParams { p . Longitude = longitude return & p }


func (p SetGeolocationOverrideParams) WithAccuracy(accuracy float64) *SetGeolocationOverrideParams {
	p.Accuracy = accuracy
	return &p
}

func ( p SetGeolocationOverrideParams ) WithAccuracy ( accuracy float64 ) * SetGeolocationOverrideParams { p . Accuracy = accuracy return & p }


func (p *SetGeolocationOverrideParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetGeolocationOverride, p, nil)
}

func ( p * SetGeolocationOverrideParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetGeolocationOverride , p , nil ) }

// Do executes Emulation.setGeolocationOverride against the provided context.

Do executes Emulation . setGeolocationOverride against the provided context .


func (p *SetPageScaleFactorParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetPageScaleFactor, p, nil)
}

func ( p * SetPageScaleFactorParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetPageScaleFactor , p , nil ) }

// Do executes Emulation.setPageScaleFactor against the provided context.

Do executes Emulation . setPageScaleFactor against the provided context .


func (p *SetScriptExecutionDisabledParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetScriptExecutionDisabled, p, nil)
}

func ( p * SetScriptExecutionDisabledParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetScriptExecutionDisabled , p , nil ) }

// Do executes Emulation.setScriptExecutionDisabled against the provided context.

Do executes Emulation . setScriptExecutionDisabled against the provided context .


func (p SetTouchEmulationEnabledParams) WithMaxTouchPoints(maxTouchPoints int64) *SetTouchEmulationEnabledParams {
	p.MaxTouchPoints = maxTouchPoints
	return &p
}

func ( p SetTouchEmulationEnabledParams ) WithMaxTouchPoints ( maxTouchPoints int64 ) * SetTouchEmulationEnabledParams { p . MaxTouchPoints = maxTouchPoints return & p }

// WithMaxTouchPoints maximum touch points supported. Defaults to one.

WithMaxTouchPoints maximum touch points supported . Defaults to one .


func (p *SetTouchEmulationEnabledParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetTouchEmulationEnabled, p, nil)
}

func ( p * SetTouchEmulationEnabledParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetTouchEmulationEnabled , p , nil ) }

// Do executes Emulation.setTouchEmulationEnabled against the provided context.

Do executes Emulation . setTouchEmulationEnabled against the provided context .


func (p SetVirtualTimePolicyParams) WithBudget(budget float64) *SetVirtualTimePolicyParams {
	p.Budget = budget
	return &p
}

func ( p SetVirtualTimePolicyParams ) WithBudget ( budget float64 ) * SetVirtualTimePolicyParams { p . Budget = budget return & p }

// WithBudget if set, after this many virtual milliseconds have elapsed
// virtual time will be paused and a virtualTimeBudgetExpired event is sent.

WithBudget if set after this many virtual milliseconds have elapsed virtual time will be paused and a virtualTimeBudgetExpired event is sent .


func (p SetVirtualTimePolicyParams) WithMaxVirtualTimeTaskStarvationCount(maxVirtualTimeTaskStarvationCount int64) *SetVirtualTimePolicyParams {
	p.MaxVirtualTimeTaskStarvationCount = maxVirtualTimeTaskStarvationCount
	return &p
}

func ( p SetVirtualTimePolicyParams ) WithMaxVirtualTimeTaskStarvationCount ( maxVirtualTimeTaskStarvationCount int64 ) * SetVirtualTimePolicyParams { p . MaxVirtualTimeTaskStarvationCount = maxVirtualTimeTaskStarvationCount return & p }

// WithMaxVirtualTimeTaskStarvationCount if set this specifies the maximum
// number of tasks that can be run before virtual is forced forwards to prevent
// deadlock.

WithMaxVirtualTimeTaskStarvationCount if set this specifies the maximum number of tasks that can be run before virtual is forced forwards to prevent deadlock .


func (p SetVirtualTimePolicyParams) WithWaitForNavigation(waitForNavigation bool) *SetVirtualTimePolicyParams {
	p.WaitForNavigation = waitForNavigation
	return &p
}

func ( p SetVirtualTimePolicyParams ) WithWaitForNavigation ( waitForNavigation bool ) * SetVirtualTimePolicyParams { p . WaitForNavigation = waitForNavigation return & p }

// WithWaitForNavigation if set the virtual time policy change should be
// deferred until any frame starts navigating. Note any previous deferred policy
// change is superseded.

WithWaitForNavigation if set the virtual time policy change should be deferred until any frame starts navigating . Note any previous deferred policy change is superseded .


func (p SetUserAgentOverrideParams) WithAcceptLanguage(acceptLanguage string) *SetUserAgentOverrideParams {
	p.AcceptLanguage = acceptLanguage
	return &p
}

func ( p SetUserAgentOverrideParams ) WithAcceptLanguage ( acceptLanguage string ) * SetUserAgentOverrideParams { p . AcceptLanguage = acceptLanguage return & p }

// WithAcceptLanguage browser langugage to emulate.

WithAcceptLanguage browser langugage to emulate .


func (p SetUserAgentOverrideParams) WithPlatform(platform string) *SetUserAgentOverrideParams {
	p.Platform = platform
	return &p
}

func ( p SetUserAgentOverrideParams ) WithPlatform ( platform string ) * SetUserAgentOverrideParams { p . Platform = platform return & p }

// WithPlatform the platform navigator.platform should return.

WithPlatform the platform navigator . platform should return .


func (p *SetUserAgentOverrideParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetUserAgentOverride, p, nil)
}

func ( p * SetUserAgentOverrideParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetUserAgentOverride , p , nil ) }

// Do executes Emulation.setUserAgentOverride against the provided context.

Do executes Emulation . setUserAgentOverride against the provided context .


func (p *DispatchKeyEventParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandDispatchKeyEvent, p, nil)
}

func ( p * DispatchKeyEventParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandDispatchKeyEvent , p , nil ) }

// Do executes Input.dispatchKeyEvent against the provided context.

Do executes Input . dispatchKeyEvent against the provided context .


func (p *InsertTextParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandInsertText, p, nil)
}

func ( p * InsertTextParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandInsertText , p , nil ) }

// Do executes Input.insertText against the provided context.

Do executes Input . insertText against the provided context .


func (p DispatchMouseEventParams) WithButtons(buttons int64) *DispatchMouseEventParams {
	p.Buttons = buttons
	return &p
}

func ( p DispatchMouseEventParams ) WithButtons ( buttons int64 ) * DispatchMouseEventParams { p . Buttons = buttons return & p }

// WithButtons a number indicating which buttons are pressed on the mouse
// when a mouse event is triggered. Left=1, Right=2, Middle=4, Back=8,
// Forward=16, None=0.

WithButtons a number indicating which buttons are pressed on the mouse when a mouse event is triggered . Left = 1 Right = 2 Middle = 4 Back = 8 Forward = 16 None = 0 .


func (p *DispatchMouseEventParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandDispatchMouseEvent, p, nil)
}

func ( p * DispatchMouseEventParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandDispatchMouseEvent , p , nil ) }

// Do executes Input.dispatchMouseEvent against the provided context.

Do executes Input . dispatchMouseEvent against the provided context .


func (p *DispatchTouchEventParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandDispatchTouchEvent, p, nil)
}

func ( p * DispatchTouchEventParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandDispatchTouchEvent , p , nil ) }

// Do executes Input.dispatchTouchEvent against the provided context.

Do executes Input . dispatchTouchEvent against the provided context .


func (p *EmulateTouchFromMouseEventParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandEmulateTouchFromMouseEvent, p, nil)
}

func ( p * EmulateTouchFromMouseEventParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandEmulateTouchFromMouseEvent , p , nil ) }

// Do executes Input.emulateTouchFromMouseEvent against the provided context.

Do executes Input . emulateTouchFromMouseEvent against the provided context .


func (p *SetIgnoreInputEventsParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetIgnoreInputEvents, p, nil)
}

func ( p * SetIgnoreInputEventsParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetIgnoreInputEvents , p , nil ) }

// Do executes Input.setIgnoreInputEvents against the provided context.

Do executes Input . setIgnoreInputEvents against the provided context .


func (p *SynthesizePinchGestureParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSynthesizePinchGesture, p, nil)
}

func ( p * SynthesizePinchGestureParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSynthesizePinchGesture , p , nil ) }

// Do executes Input.synthesizePinchGesture against the provided context.

Do executes Input . synthesizePinchGesture against the provided context .


func (p SynthesizeScrollGestureParams) WithXOverscroll(xOverscroll float64) *SynthesizeScrollGestureParams {
	p.XOverscroll = xOverscroll
	return &p
}

func ( p SynthesizeScrollGestureParams ) WithXOverscroll ( xOverscroll float64 ) * SynthesizeScrollGestureParams { p . XOverscroll = xOverscroll return & p }

// WithXOverscroll the number of additional pixels to scroll back along the X
// axis, in addition to the given distance.

WithXOverscroll the number of additional pixels to scroll back along the X axis in addition to the given distance .


func (p SynthesizeScrollGestureParams) WithYOverscroll(yOverscroll float64) *SynthesizeScrollGestureParams {
	p.YOverscroll = yOverscroll
	return &p
}

func ( p SynthesizeScrollGestureParams ) WithYOverscroll ( yOverscroll float64 ) * SynthesizeScrollGestureParams { p . YOverscroll = yOverscroll return & p }

// WithYOverscroll the number of additional pixels to scroll back along the Y
// axis, in addition to the given distance.

WithYOverscroll the number of additional pixels to scroll back along the Y axis in addition to the given distance .


func (p *SynthesizeScrollGestureParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSynthesizeScrollGesture, p, nil)
}

func ( p * SynthesizeScrollGestureParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSynthesizeScrollGesture , p , nil ) }

// Do executes Input.synthesizeScrollGesture against the provided context.

Do executes Input . synthesizeScrollGesture against the provided context .


func (p *SynthesizeTapGestureParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSynthesizeTapGesture, p, nil)
}

func ( p * SynthesizeTapGestureParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSynthesizeTapGesture , p , nil ) }

// Do executes Input.synthesizeTapGesture against the provided context.

Do executes Input . synthesizeTapGesture against the provided context .


func (t MethodType) Domain() string {
	return string(t[:strings.IndexByte(string(t), '.')])
}

func ( t MethodType ) Domain ( ) string { return string ( t [ : strings . IndexByte ( string ( t ) , '.' ) ] ) }

// Domain returns the Chrome DevTools Protocol domain of the event or command.

Domain returns the Chrome DevTools Protocol domain of the event or command .


func (p GetEventListenersParams) WithDepth(depth int64) *GetEventListenersParams {
	p.Depth = depth
	return &p
}

func ( p GetEventListenersParams ) WithDepth ( depth int64 ) * GetEventListenersParams { p . Depth = depth return & p }

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

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


func (p *RemoveDOMBreakpointParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandRemoveDOMBreakpoint, p, nil)
}

func ( p * RemoveDOMBreakpointParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandRemoveDOMBreakpoint , p , nil ) }

// Do executes DOMDebugger.removeDOMBreakpoint against the provided context.

Do executes DOMDebugger . removeDOMBreakpoint against the provided context .


func (p RemoveEventListenerBreakpointParams) WithTargetName(targetName string) *RemoveEventListenerBreakpointParams {
	p.TargetName = targetName
	return &p
}

func ( p RemoveEventListenerBreakpointParams ) WithTargetName ( targetName string ) * RemoveEventListenerBreakpointParams { p . TargetName = targetName return & p }

// WithTargetName eventTarget interface name.

WithTargetName eventTarget interface name .


func (p *RemoveEventListenerBreakpointParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandRemoveEventListenerBreakpoint, p, nil)
}

func ( p * RemoveEventListenerBreakpointParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandRemoveEventListenerBreakpoint , p , nil ) }

// Do executes DOMDebugger.removeEventListenerBreakpoint against the provided context.

Do executes DOMDebugger . removeEventListenerBreakpoint against the provided context .


func (p *RemoveInstrumentationBreakpointParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandRemoveInstrumentationBreakpoint, p, nil)
}

func ( p * RemoveInstrumentationBreakpointParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandRemoveInstrumentationBreakpoint , p , nil ) }

// Do executes DOMDebugger.removeInstrumentationBreakpoint against the provided context.

Do executes DOMDebugger . removeInstrumentationBreakpoint against the provided context .


func (p *RemoveXHRBreakpointParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandRemoveXHRBreakpoint, p, nil)
}

func ( p * RemoveXHRBreakpointParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandRemoveXHRBreakpoint , p , nil ) }

// Do executes DOMDebugger.removeXHRBreakpoint against the provided context.

Do executes DOMDebugger . removeXHRBreakpoint against the provided context .


func (p *SetDOMBreakpointParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetDOMBreakpoint, p, nil)
}

func ( p * SetDOMBreakpointParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetDOMBreakpoint , p , nil ) }

// Do executes DOMDebugger.setDOMBreakpoint against the provided context.

Do executes DOMDebugger . setDOMBreakpoint against the provided context .


func (p *SetEventListenerBreakpointParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetEventListenerBreakpoint, p, nil)
}

func ( p * SetEventListenerBreakpointParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetEventListenerBreakpoint , p , nil ) }

// Do executes DOMDebugger.setEventListenerBreakpoint against the provided context.

Do executes DOMDebugger . setEventListenerBreakpoint against the provided context .


func (p *SetInstrumentationBreakpointParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetInstrumentationBreakpoint, p, nil)
}

func ( p * SetInstrumentationBreakpointParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetInstrumentationBreakpoint , p , nil ) }

// Do executes DOMDebugger.setInstrumentationBreakpoint against the provided context.

Do executes DOMDebugger . setInstrumentationBreakpoint against the provided context .


func (p *SetXHRBreakpointParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetXHRBreakpoint, p, nil)
}

func ( p * SetXHRBreakpointParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetXHRBreakpoint , p , nil ) }

// Do executes DOMDebugger.setXHRBreakpoint against the provided context.

Do executes DOMDebugger . setXHRBreakpoint against the provided context .


func WithExecutor(parent context.Context, executor Executor) context.Context {
	return context.WithValue(parent, executorKey, executor)
}

func WithExecutor ( parent context . Context , executor Executor ) context . Context { return context . WithValue ( parent , executorKey , executor ) }

// WithExecutor sets the message executor for the context.

WithExecutor sets the message executor for the context .


func Execute(ctx context.Context, method string, params easyjson.Marshaler, res easyjson.Unmarshaler) error {
	if executor := ctx.Value(executorKey); executor != nil {
		return executor.(Executor).Execute(ctx, method, params, res)
	}
	return ErrInvalidContext
}

func Execute ( ctx context . Context , method string , params easyjson . Marshaler , res easyjson . Unmarshaler ) error { if executor := ctx . Value ( executorKey ) ; executor != nil { return executor . ( Executor ) . Execute ( ctx , method , params , res ) } return ErrInvalidContext }

// Execute uses the context's message executor to send a command or event
// method marshaling the provided parameters, and unmarshaling to res.

Execute uses the context s message executor to send a command or event method marshaling the provided parameters and unmarshaling to res .


func (n *Node) AttributeValue(name string) string {
	n.RLock()
	defer n.RUnlock()

	for i := 0; i < len(n.Attributes); i += 2 {
		if n.Attributes[i] == name {
			return n.Attributes[i+1]
		}
	}

	return ""
}

func ( n * Node ) AttributeValue ( name string ) string { n . RLock ( ) defer n . RUnlock ( ) for i := 0 ; i < len ( n . Attributes ) ; i += 2 { if n . Attributes [ i ] == name { return n . Attributes [ i + 1 ] } } return " " }

// AttributeValue returns the named attribute for the node.

AttributeValue returns the named attribute for the node .


func (n *Node) xpath(stopAtDocument, stopAtID bool) string {
	n.RLock()
	defer n.RUnlock()

	p := ""
	pos := ""
	id := n.AttributeValue("id")
	switch {
	case n.Parent == nil:
		return n.LocalName

	case stopAtDocument && n.NodeType == NodeTypeDocument:
		return ""

	case stopAtID && id != "":
		p = "/"
		pos = `[@id='` + id + `']`

	case n.Parent != nil:
		var i int
		var found bool

		n.Parent.RLock()
		for j := 0; j < len(n.Parent.Children); j++ {
			if n.Parent.Children[j].LocalName == n.LocalName {
				i++
			}
			if n.Parent.Children[j].NodeID == n.NodeID {
				found = true
				break
			}
		}
		n.Parent.RUnlock()

		if found {
			pos = "[" + strconv.Itoa(i) + "]"
		}

		p = n.Parent.xpath(stopAtDocument, stopAtID)
	}

	return p + "/" + n.LocalName + pos
}

func ( n * Node ) xpath ( stopAtDocument , stopAtID bool ) string { n . RLock ( ) defer n . RUnlock ( ) p := " " pos := " " id := n . AttributeValue ( " " ) switch { case n . Parent == nil : return n . LocalName case stopAtDocument && n . NodeType == NodeTypeDocument : return " " case stopAtID && id != " " : p = " " pos = `[@id='` + id + `']` case n . Parent != nil : var i int var found bool n . Parent . RLock ( ) for j := 0 ; j < len ( n . Parent . Children ) ; j ++ { if n . Parent . Children [ j ] . LocalName == n . LocalName { i ++ } if n . Parent . Children [ j ] . NodeID == n . NodeID { found = true break } } n . Parent . RUnlock ( ) if found { pos = " " + strconv . Itoa ( i ) + " " } p = n . Parent . xpath ( stopAtDocument , stopAtID ) } return p + " " + n . LocalName + pos }


func (t NodeType) String() string {
	switch t {
	case NodeTypeElement:
		return "Element"
	case NodeTypeAttribute:
		return "Attribute"
	case NodeTypeText:
		return "Text"
	case NodeTypeCDATA:
		return "CDATA"
	case NodeTypeEntityReference:
		return "EntityReference"
	case NodeTypeEntity:
		return "Entity"
	case NodeTypeProcessingInstruction:
		return "ProcessingInstruction"
	case NodeTypeComment:
		return "Comment"
	case NodeTypeDocument:
		return "Document"
	case NodeTypeDocumentType:
		return "DocumentType"
	case NodeTypeDocumentFragment:
		return "DocumentFragment"
	case NodeTypeNotation:
		return "Notation"
	}

	return fmt.Sprintf("NodeType(%d)", t)
}

func ( t NodeType ) String ( ) string { switch t { case NodeTypeElement : return " " case NodeTypeAttribute : return " " case NodeTypeText : return " " case NodeTypeCDATA : return " " case NodeTypeEntityReference : return " " case NodeTypeEntity : return " " case NodeTypeProcessingInstruction : return " " case NodeTypeComment : return " " case NodeTypeDocument : return " " case NodeTypeDocumentType : return " " case NodeTypeDocumentFragment : return " " case NodeTypeNotation : return " " } return fmt . Sprintf ( " " , t ) }

// String returns the NodeType as string value.

String returns the NodeType as string value .


func (p *SetSinkToUseParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetSinkToUse, p, nil)
}

func ( p * SetSinkToUseParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetSinkToUse , p , nil ) }

// Do executes Cast.setSinkToUse against the provided context.

Do executes Cast . setSinkToUse against the provided context .


func (p *StartTabMirroringParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandStartTabMirroring, p, nil)
}

func ( p * StartTabMirroringParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandStartTabMirroring , p , nil ) }

// Do executes Cast.startTabMirroring against the provided context.

Do executes Cast . startTabMirroring against the provided context .


func (p *StopCastingParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandStopCasting, p, nil)
}

func ( p * StopCastingParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandStopCasting , p , nil ) }

// Do executes Cast.stopCasting against the provided context.

Do executes Cast . stopCasting against the provided context .


func (p *StartObservingParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandStartObserving, p, nil)
}

func ( p * StartObservingParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandStartObserving , p , nil ) }

// Do executes BackgroundService.startObserving against the provided context.

Do executes BackgroundService . startObserving against the provided context .


func (p *StopObservingParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandStopObserving, p, nil)
}

func ( p * StopObservingParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandStopObserving , p , nil ) }

// Do executes BackgroundService.stopObserving against the provided context.

Do executes BackgroundService . stopObserving against the provided context .


func (p *SetRecordingParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetRecording, p, nil)
}

func ( p * SetRecordingParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetRecording , p , nil ) }

// Do executes BackgroundService.setRecording against the provided context.

Do executes BackgroundService . setRecording against the provided context .


func (p *ClearEventsParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandClearEvents, p, nil)
}

func ( p * ClearEventsParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandClearEvents , p , nil ) }

// Do executes BackgroundService.clearEvents against the provided context.

Do executes BackgroundService . clearEvents against the provided context .


func (p CallFunctionOnParams) WithObjectID(objectID RemoteObjectID) *CallFunctionOnParams {
	p.ObjectID = objectID
	return &p
}

func ( p CallFunctionOnParams ) WithObjectID ( objectID RemoteObjectID ) * CallFunctionOnParams { p . ObjectID = objectID return & p }

// WithObjectID identifier of the object to call function on. Either objectId
// or executionContextId should be specified.

WithObjectID identifier of the object to call function on . Either objectId or executionContextId should be specified .


func (p CallFunctionOnParams) WithArguments(arguments []*CallArgument) *CallFunctionOnParams {
	p.Arguments = arguments
	return &p
}

func ( p CallFunctionOnParams ) WithArguments ( arguments [ ] * CallArgument ) * CallFunctionOnParams { p . Arguments = arguments return & p }

// WithArguments call arguments. All call arguments must belong to the same
// JavaScript world as the target object.

WithArguments call arguments . All call arguments must belong to the same JavaScript world as the target object .


func (p CallFunctionOnParams) WithExecutionContextID(executionContextID ExecutionContextID) *CallFunctionOnParams {
	p.ExecutionContextID = executionContextID
	return &p
}

func ( p CallFunctionOnParams ) WithExecutionContextID ( executionContextID ExecutionContextID ) * CallFunctionOnParams { p . ExecutionContextID = executionContextID return & p }

// WithExecutionContextID specifies execution context which global object
// will be used to call function on. Either executionContextId or objectId
// should be specified.

WithExecutionContextID specifies execution context which global object will be used to call function on . Either executionContextId or objectId should be specified .


func (p CallFunctionOnParams) WithObjectGroup(objectGroup string) *CallFunctionOnParams {
	p.ObjectGroup = objectGroup
	return &p
}

func ( p CallFunctionOnParams ) WithObjectGroup ( objectGroup string ) * CallFunctionOnParams { p . ObjectGroup = objectGroup return & p }

// WithObjectGroup symbolic group name that can be used to release multiple
// objects. If objectGroup is not specified and objectId is, objectGroup will be
// inherited from object.

WithObjectGroup symbolic group name that can be used to release multiple objects . If objectGroup is not specified and objectId is objectGroup will be inherited from object .


func (p *DiscardConsoleEntriesParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandDiscardConsoleEntries, nil, nil)
}

func ( p * DiscardConsoleEntriesParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandDiscardConsoleEntries , nil , nil ) }

// Do executes Runtime.discardConsoleEntries against the provided context.

Do executes Runtime . discardConsoleEntries against the provided context .


func (p EvaluateParams) WithContextID(contextID ExecutionContextID) *EvaluateParams {
	p.ContextID = contextID
	return &p
}

func ( p EvaluateParams ) WithContextID ( contextID ExecutionContextID ) * EvaluateParams { p . ContextID = contextID return & p }

// WithContextID specifies in which execution context to perform evaluation.
// If the parameter is omitted the evaluation will be performed in the context
// of the inspected page.

WithContextID specifies in which execution context to perform evaluation . If the parameter is omitted the evaluation will be performed in the context of the inspected page .


func (p GetPropertiesParams) WithOwnProperties(ownProperties bool) *GetPropertiesParams {
	p.OwnProperties = ownProperties
	return &p
}

func ( p GetPropertiesParams ) WithOwnProperties ( ownProperties bool ) * GetPropertiesParams { p . OwnProperties = ownProperties return & p }

// WithOwnProperties if true, returns properties belonging only to the
// element itself, not to its prototype chain.

WithOwnProperties if true returns properties belonging only to the element itself not to its prototype chain .


func (p GetPropertiesParams) WithGeneratePreview(generatePreview bool) *GetPropertiesParams {
	p.GeneratePreview = generatePreview
	return &p
}

func ( p GetPropertiesParams ) WithGeneratePreview ( generatePreview bool ) * GetPropertiesParams { p . GeneratePreview = generatePreview return & p }

// WithGeneratePreview whether preview should be generated for the results.

WithGeneratePreview whether preview should be generated for the results .


func (p GlobalLexicalScopeNamesParams) WithExecutionContextID(executionContextID ExecutionContextID) *GlobalLexicalScopeNamesParams {
	p.ExecutionContextID = executionContextID
	return &p
}

func ( p GlobalLexicalScopeNamesParams ) WithExecutionContextID ( executionContextID ExecutionContextID ) * GlobalLexicalScopeNamesParams { p . ExecutionContextID = executionContextID return & p }

// WithExecutionContextID specifies in which execution context to lookup
// global scope variables.

WithExecutionContextID specifies in which execution context to lookup global scope variables .


func (p QueryObjectsParams) WithObjectGroup(objectGroup string) *QueryObjectsParams {
	p.ObjectGroup = objectGroup
	return &p
}

func ( p QueryObjectsParams ) WithObjectGroup ( objectGroup string ) * QueryObjectsParams { p . ObjectGroup = objectGroup return & p }

// WithObjectGroup symbolic group name that can be used to release the
// results.

WithObjectGroup symbolic group name that can be used to release the results .


func (p *ReleaseObjectParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandReleaseObject, p, nil)
}

func ( p * ReleaseObjectParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandReleaseObject , p , nil ) }

// Do executes Runtime.releaseObject against the provided context.

Do executes Runtime . releaseObject against the provided context .


func (p *ReleaseObjectGroupParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandReleaseObjectGroup, p, nil)
}

func ( p * ReleaseObjectGroupParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandReleaseObjectGroup , p , nil ) }

// Do executes Runtime.releaseObjectGroup against the provided context.

Do executes Runtime . releaseObjectGroup against the provided context .


func (p *RunIfWaitingForDebuggerParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandRunIfWaitingForDebugger, nil, nil)
}

func ( p * RunIfWaitingForDebuggerParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandRunIfWaitingForDebugger , nil , nil ) }

// Do executes Runtime.runIfWaitingForDebugger against the provided context.

Do executes Runtime . runIfWaitingForDebugger against the provided context .


func (p *SetCustomObjectFormatterEnabledParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetCustomObjectFormatterEnabled, p, nil)
}

func ( p * SetCustomObjectFormatterEnabledParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetCustomObjectFormatterEnabled , p , nil ) }

// Do executes Runtime.setCustomObjectFormatterEnabled against the provided context.

Do executes Runtime . setCustomObjectFormatterEnabled against the provided context .


func (p *SetMaxCallStackSizeToCaptureParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetMaxCallStackSizeToCapture, p, nil)
}

func ( p * SetMaxCallStackSizeToCaptureParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetMaxCallStackSizeToCapture , p , nil ) }

// Do executes Runtime.setMaxCallStackSizeToCapture against the provided context.

Do executes Runtime . setMaxCallStackSizeToCapture against the provided context .


func (p *TerminateExecutionParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandTerminateExecution, nil, nil)
}

func ( p * TerminateExecutionParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandTerminateExecution , nil , nil ) }

// Do executes Runtime.terminateExecution against the provided context.

Do executes Runtime . terminateExecution against the provided context .


func (p *AddBindingParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandAddBinding, p, nil)
}

func ( p * AddBindingParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandAddBinding , p , nil ) }

// Do executes Runtime.addBinding against the provided context.

Do executes Runtime . addBinding against the provided context .


func (p *RemoveBindingParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandRemoveBinding, p, nil)
}

func ( p * RemoveBindingParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandRemoveBinding , p , nil ) }

// Do executes Runtime.removeBinding against the provided context.

Do executes Runtime . removeBinding against the provided context .


func (p *EndParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandEnd, nil, nil)
}

func ( p * EndParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandEnd , nil , nil ) }

// Do executes Tracing.end against the provided context.

Do executes Tracing . end against the provided context .


func (p *RecordClockSyncMarkerParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandRecordClockSyncMarker, p, nil)
}

func ( p * RecordClockSyncMarkerParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandRecordClockSyncMarker , p , nil ) }

// Do executes Tracing.recordClockSyncMarker against the provided context.

Do executes Tracing . recordClockSyncMarker against the provided context .


func (p StartParams) WithBufferUsageReportingInterval(bufferUsageReportingInterval float64) *StartParams {
	p.BufferUsageReportingInterval = bufferUsageReportingInterval
	return &p
}

func ( p StartParams ) WithBufferUsageReportingInterval ( bufferUsageReportingInterval float64 ) * StartParams { p . BufferUsageReportingInterval = bufferUsageReportingInterval return & p }

// WithBufferUsageReportingInterval if set, the agent will issue bufferUsage
// events at this interval, specified in milliseconds.

WithBufferUsageReportingInterval if set the agent will issue bufferUsage events at this interval specified in milliseconds .


func (p BeginFrameParams) WithNoDisplayUpdates(noDisplayUpdates bool) *BeginFrameParams {
	p.NoDisplayUpdates = noDisplayUpdates
	return &p
}

func ( p BeginFrameParams ) WithNoDisplayUpdates ( noDisplayUpdates bool ) * BeginFrameParams { p . NoDisplayUpdates = noDisplayUpdates return & p }

// WithNoDisplayUpdates whether updates should not be committed and drawn
// onto the display. False by default. If true, only side effects of the
// BeginFrame will be run, such as layout and animations, but any visual updates
// may not be visible on the display or in screenshots.

WithNoDisplayUpdates whether updates should not be committed and drawn onto the display . False by default . If true only side effects of the BeginFrame will be run such as layout and animations but any visual updates may not be visible on the display or in screenshots .


func (p BeginFrameParams) WithScreenshot(screenshot *ScreenshotParams) *BeginFrameParams {
	p.Screenshot = screenshot
	return &p
}

func ( p BeginFrameParams ) WithScreenshot ( screenshot * ScreenshotParams ) * BeginFrameParams { p . Screenshot = screenshot return & p }

// WithScreenshot if set, a screenshot of the frame will be captured and
// returned in the response. Otherwise, no screenshot will be captured. Note
// that capturing a screenshot can fail, for example, during renderer
// initialization. In such a case, no screenshot data will be returned.

WithScreenshot if set a screenshot of the frame will be captured and returned in the response . Otherwise no screenshot will be captured . Note that capturing a screenshot can fail for example during renderer initialization . In such a case no screenshot data will be returned .


func (p *BringToFrontParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandBringToFront, nil, nil)
}

func ( p * BringToFrontParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandBringToFront , nil , nil ) }

// Do executes Page.bringToFront against the provided context.

Do executes Page . bringToFront against the provided context .


func (p CaptureScreenshotParams) WithClip(clip *Viewport) *CaptureScreenshotParams {
	p.Clip = clip
	return &p
}

func ( p CaptureScreenshotParams ) WithClip ( clip * Viewport ) * CaptureScreenshotParams { p . Clip = clip return & p }

// WithClip capture the screenshot of a given region only.

WithClip capture the screenshot of a given region only .


func (p CaptureScreenshotParams) WithFromSurface(fromSurface bool) *CaptureScreenshotParams {
	p.FromSurface = fromSurface
	return &p
}

func ( p CaptureScreenshotParams ) WithFromSurface ( fromSurface bool ) * CaptureScreenshotParams { p . FromSurface = fromSurface return & p }

// WithFromSurface capture the screenshot from the surface, rather than the
// view. Defaults to true.

WithFromSurface capture the screenshot from the surface rather than the view . Defaults to true .


func (p CreateIsolatedWorldParams) WithWorldName(worldName string) *CreateIsolatedWorldParams {
	p.WorldName = worldName
	return &p
}

func ( p CreateIsolatedWorldParams ) WithWorldName ( worldName string ) * CreateIsolatedWorldParams { p . WorldName = worldName return & p }

// WithWorldName an optional name which is reported in the Execution Context.

WithWorldName an optional name which is reported in the Execution Context .


func (p CreateIsolatedWorldParams) WithGrantUniveralAccess(grantUniveralAccess bool) *CreateIsolatedWorldParams {
	p.GrantUniveralAccess = grantUniveralAccess
	return &p
}

func ( p CreateIsolatedWorldParams ) WithGrantUniveralAccess ( grantUniveralAccess bool ) * CreateIsolatedWorldParams { p . GrantUniveralAccess = grantUniveralAccess return & p }

// WithGrantUniveralAccess whether or not universal access should be granted
// to the isolated world. This is a powerful option, use with caution.

WithGrantUniveralAccess whether or not universal access should be granted to the isolated world . This is a powerful option use with caution .


func (p *ResetNavigationHistoryParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandResetNavigationHistory, nil, nil)
}

func ( p * ResetNavigationHistoryParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandResetNavigationHistory , nil , nil ) }

// Do executes Page.resetNavigationHistory against the provided context.

Do executes Page . resetNavigationHistory against the provided context .


func (p HandleJavaScriptDialogParams) WithPromptText(promptText string) *HandleJavaScriptDialogParams {
	p.PromptText = promptText
	return &p
}

func ( p HandleJavaScriptDialogParams ) WithPromptText ( promptText string ) * HandleJavaScriptDialogParams { p . PromptText = promptText return & p }

// WithPromptText the text to enter into the dialog prompt before accepting.
// Used only if this is a prompt dialog.

WithPromptText the text to enter into the dialog prompt before accepting . Used only if this is a prompt dialog .


func (p *HandleJavaScriptDialogParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandHandleJavaScriptDialog, p, nil)
}

func ( p * HandleJavaScriptDialogParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandHandleJavaScriptDialog , p , nil ) }

// Do executes Page.handleJavaScriptDialog against the provided context.

Do executes Page . handleJavaScriptDialog against the provided context .


func (p NavigateParams) WithReferrer(referrer string) *NavigateParams {
	p.Referrer = referrer
	return &p
}

func ( p NavigateParams ) WithReferrer ( referrer string ) * NavigateParams { p . Referrer = referrer return & p }


func (p NavigateParams) WithTransitionType(transitionType TransitionType) *NavigateParams {
	p.TransitionType = transitionType
	return &p
}

func ( p NavigateParams ) WithTransitionType ( transitionType TransitionType ) * NavigateParams { p . TransitionType = transitionType return & p }

// WithTransitionType intended transition type.

WithTransitionType intended transition type .


func (p NavigateParams) WithFrameID(frameID cdp.FrameID) *NavigateParams {
	p.FrameID = frameID
	return &p
}

func ( p NavigateParams ) WithFrameID ( frameID cdp . FrameID ) * NavigateParams { p . FrameID = frameID return & p }

// WithFrameID frame id to navigate, if not specified navigates the top
// frame.

WithFrameID frame id to navigate if not specified navigates the top frame .


func (p *NavigateToHistoryEntryParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandNavigateToHistoryEntry, p, nil)
}

func ( p * NavigateToHistoryEntryParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandNavigateToHistoryEntry , p , nil ) }

// Do executes Page.navigateToHistoryEntry against the provided context.

Do executes Page . navigateToHistoryEntry against the provided context .


func (p PrintToPDFParams) WithLandscape(landscape bool) *PrintToPDFParams {
	p.Landscape = landscape
	return &p
}

func ( p PrintToPDFParams ) WithLandscape ( landscape bool ) * PrintToPDFParams { p . Landscape = landscape return & p }

// WithLandscape paper orientation. Defaults to false.

WithLandscape paper orientation . Defaults to false .


func (p PrintToPDFParams) WithDisplayHeaderFooter(displayHeaderFooter bool) *PrintToPDFParams {
	p.DisplayHeaderFooter = displayHeaderFooter
	return &p
}

func ( p PrintToPDFParams ) WithDisplayHeaderFooter ( displayHeaderFooter bool ) * PrintToPDFParams { p . DisplayHeaderFooter = displayHeaderFooter return & p }

// WithDisplayHeaderFooter display header and footer. Defaults to false.

WithDisplayHeaderFooter display header and footer . Defaults to false .


func (p PrintToPDFParams) WithPrintBackground(printBackground bool) *PrintToPDFParams {
	p.PrintBackground = printBackground
	return &p
}

func ( p PrintToPDFParams ) WithPrintBackground ( printBackground bool ) * PrintToPDFParams { p . PrintBackground = printBackground return & p }

// WithPrintBackground print background graphics. Defaults to false.

WithPrintBackground print background graphics . Defaults to false .


func (p PrintToPDFParams) WithScale(scale float64) *PrintToPDFParams {
	p.Scale = scale
	return &p
}

func ( p PrintToPDFParams ) WithScale ( scale float64 ) * PrintToPDFParams { p . Scale = scale return & p }

// WithScale scale of the webpage rendering. Defaults to 1.

WithScale scale of the webpage rendering . Defaults to 1 .


func (p PrintToPDFParams) WithPaperWidth(paperWidth float64) *PrintToPDFParams {
	p.PaperWidth = paperWidth
	return &p
}

func ( p PrintToPDFParams ) WithPaperWidth ( paperWidth float64 ) * PrintToPDFParams { p . PaperWidth = paperWidth return & p }

// WithPaperWidth paper width in inches. Defaults to 8.5 inches.

WithPaperWidth paper width in inches . Defaults to 8 . 5 inches .


func (p PrintToPDFParams) WithPaperHeight(paperHeight float64) *PrintToPDFParams {
	p.PaperHeight = paperHeight
	return &p
}

func ( p PrintToPDFParams ) WithPaperHeight ( paperHeight float64 ) * PrintToPDFParams { p . PaperHeight = paperHeight return & p }

// WithPaperHeight paper height in inches. Defaults to 11 inches.

WithPaperHeight paper height in inches . Defaults to 11 inches .


func (p PrintToPDFParams) WithIgnoreInvalidPageRanges(ignoreInvalidPageRanges bool) *PrintToPDFParams {
	p.IgnoreInvalidPageRanges = ignoreInvalidPageRanges
	return &p
}

func ( p PrintToPDFParams ) WithIgnoreInvalidPageRanges ( ignoreInvalidPageRanges bool ) * PrintToPDFParams { p . IgnoreInvalidPageRanges = ignoreInvalidPageRanges return & p }

// WithIgnoreInvalidPageRanges whether to silently ignore invalid but
// successfully parsed page ranges, such as '3-2'. Defaults to false.

WithIgnoreInvalidPageRanges whether to silently ignore invalid but successfully parsed page ranges such as 3 - 2 . Defaults to false .


func (p PrintToPDFParams) WithFooterTemplate(footerTemplate string) *PrintToPDFParams {
	p.FooterTemplate = footerTemplate
	return &p
}

func ( p PrintToPDFParams ) WithFooterTemplate ( footerTemplate string ) * PrintToPDFParams { p . FooterTemplate = footerTemplate return & p }

// WithFooterTemplate HTML template for the print footer. Should use the same
// format as the headerTemplate.

WithFooterTemplate HTML template for the print footer . Should use the same format as the headerTemplate .


func (p PrintToPDFParams) WithPreferCSSPageSize(preferCSSPageSize bool) *PrintToPDFParams {
	p.PreferCSSPageSize = preferCSSPageSize
	return &p
}

func ( p PrintToPDFParams ) WithPreferCSSPageSize ( preferCSSPageSize bool ) * PrintToPDFParams { p . PreferCSSPageSize = preferCSSPageSize return & p }

// WithPreferCSSPageSize whether or not to prefer page size as defined by
// css. Defaults to false, in which case the content will be scaled to fit the
// paper size.

WithPreferCSSPageSize whether or not to prefer page size as defined by css . Defaults to false in which case the content will be scaled to fit the paper size .


func (p ReloadParams) WithScriptToEvaluateOnLoad(scriptToEvaluateOnLoad string) *ReloadParams {
	p.ScriptToEvaluateOnLoad = scriptToEvaluateOnLoad
	return &p
}

func ( p ReloadParams ) WithScriptToEvaluateOnLoad ( scriptToEvaluateOnLoad string ) * ReloadParams { p . ScriptToEvaluateOnLoad = scriptToEvaluateOnLoad return & p }

// WithScriptToEvaluateOnLoad if set, the script will be injected into all
// frames of the inspected page after reload. Argument will be ignored if
// reloading dataURL origin.

WithScriptToEvaluateOnLoad if set the script will be injected into all frames of the inspected page after reload . Argument will be ignored if reloading dataURL origin .


func (p *ReloadParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandReload, p, nil)
}

func ( p * ReloadParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandReload , p , nil ) }

// Do executes Page.reload against the provided context.

Do executes Page . reload against the provided context .


func (p *RemoveScriptToEvaluateOnNewDocumentParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandRemoveScriptToEvaluateOnNewDocument, p, nil)
}

// Do executes Page.removeScriptToEvaluateOnNewDocument against the provided context.

Do executes Page . removeScriptToEvaluateOnNewDocument against the provided context .


func (p *ScreencastFrameAckParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandScreencastFrameAck, p, nil)
}

func ( p * ScreencastFrameAckParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandScreencastFrameAck , p , nil ) }

// Do executes Page.screencastFrameAck against the provided context.

Do executes Page . screencastFrameAck against the provided context .


func (p *SetAdBlockingEnabledParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetAdBlockingEnabled, p, nil)
}

func ( p * SetAdBlockingEnabledParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetAdBlockingEnabled , p , nil ) }

// Do executes Page.setAdBlockingEnabled against the provided context.

Do executes Page . setAdBlockingEnabled against the provided context .


func (p *SetBypassCSPParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetBypassCSP, p, nil)
}

func ( p * SetBypassCSPParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetBypassCSP , p , nil ) }

// Do executes Page.setBypassCSP against the provided context.

Do executes Page . setBypassCSP against the provided context .


func (p *SetFontFamiliesParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetFontFamilies, p, nil)
}

func ( p * SetFontFamiliesParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetFontFamilies , p , nil ) }

// Do executes Page.setFontFamilies against the provided context.

Do executes Page . setFontFamilies against the provided context .


func (p *SetFontSizesParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetFontSizes, p, nil)
}

func ( p * SetFontSizesParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetFontSizes , p , nil ) }

// Do executes Page.setFontSizes against the provided context.

Do executes Page . setFontSizes against the provided context .


func (p *SetDocumentContentParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetDocumentContent, p, nil)
}

func ( p * SetDocumentContentParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetDocumentContent , p , nil ) }

// Do executes Page.setDocumentContent against the provided context.

Do executes Page . setDocumentContent against the provided context .


func (p SetDownloadBehaviorParams) WithDownloadPath(downloadPath string) *SetDownloadBehaviorParams {
	p.DownloadPath = downloadPath
	return &p
}

func ( p SetDownloadBehaviorParams ) WithDownloadPath ( downloadPath string ) * SetDownloadBehaviorParams { p . DownloadPath = downloadPath return & p }

// WithDownloadPath the default path to save downloaded files to. This is
// required if behavior is set to 'allow'.

WithDownloadPath the default path to save downloaded files to . This is required if behavior is set to allow .


func (p *SetDownloadBehaviorParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetDownloadBehavior, p, nil)
}

func ( p * SetDownloadBehaviorParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetDownloadBehavior , p , nil ) }

// Do executes Page.setDownloadBehavior against the provided context.

Do executes Page . setDownloadBehavior against the provided context .


func (p *SetLifecycleEventsEnabledParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetLifecycleEventsEnabled, p, nil)
}

func ( p * SetLifecycleEventsEnabledParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetLifecycleEventsEnabled , p , nil ) }

// Do executes Page.setLifecycleEventsEnabled against the provided context.

Do executes Page . setLifecycleEventsEnabled against the provided context .


func (p StartScreencastParams) WithFormat(format ScreencastFormat) *StartScreencastParams {
	p.Format = format
	return &p
}

func ( p StartScreencastParams ) WithFormat ( format ScreencastFormat ) * StartScreencastParams { p . Format = format return & p }


func (p StartScreencastParams) WithMaxWidth(maxWidth int64) *StartScreencastParams {
	p.MaxWidth = maxWidth
	return &p
}

func ( p StartScreencastParams ) WithMaxWidth ( maxWidth int64 ) * StartScreencastParams { p . MaxWidth = maxWidth return & p }

// WithMaxWidth maximum screenshot width.


func (p StartScreencastParams) WithMaxHeight(maxHeight int64) *StartScreencastParams {
	p.MaxHeight = maxHeight
	return &p
}

func ( p StartScreencastParams ) WithMaxHeight ( maxHeight int64 ) * StartScreencastParams { p . MaxHeight = maxHeight return & p }

// WithMaxHeight maximum screenshot height.

WithMaxHeight maximum screenshot height .


func (p StartScreencastParams) WithEveryNthFrame(everyNthFrame int64) *StartScreencastParams {
	p.EveryNthFrame = everyNthFrame
	return &p
}

func ( p StartScreencastParams ) WithEveryNthFrame ( everyNthFrame int64 ) * StartScreencastParams { p . EveryNthFrame = everyNthFrame return & p }

// WithEveryNthFrame send every n-th frame.

WithEveryNthFrame send every n - th frame .


func (p *StartScreencastParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandStartScreencast, p, nil)
}

func ( p * StartScreencastParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandStartScreencast , p , nil ) }

// Do executes Page.startScreencast against the provided context.

Do executes Page . startScreencast against the provided context .


func (p *StopLoadingParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandStopLoading, nil, nil)
}

func ( p * StopLoadingParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandStopLoading , nil , nil ) }

// Do executes Page.stopLoading against the provided context.

Do executes Page . stopLoading against the provided context .


func (p *SetWebLifecycleStateParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetWebLifecycleState, p, nil)
}

func ( p * SetWebLifecycleStateParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetWebLifecycleState , p , nil ) }

// Do executes Page.setWebLifecycleState against the provided context.

Do executes Page . setWebLifecycleState against the provided context .


func (p *StopScreencastParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandStopScreencast, nil, nil)
}

func ( p * StopScreencastParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandStopScreencast , nil , nil ) }

// Do executes Page.stopScreencast against the provided context.

Do executes Page . stopScreencast against the provided context .


func (p *SetProduceCompilationCacheParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetProduceCompilationCache, p, nil)
}

func ( p * SetProduceCompilationCacheParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetProduceCompilationCache , p , nil ) }

// Do executes Page.setProduceCompilationCache against the provided context.

Do executes Page . setProduceCompilationCache against the provided context .


func (p *AddCompilationCacheParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandAddCompilationCache, p, nil)
}

func ( p * AddCompilationCacheParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandAddCompilationCache , p , nil ) }

// Do executes Page.addCompilationCache against the provided context.

Do executes Page . addCompilationCache against the provided context .


func (p *ClearCompilationCacheParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandClearCompilationCache, nil, nil)
}

func ( p * ClearCompilationCacheParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandClearCompilationCache , nil , nil ) }

// Do executes Page.clearCompilationCache against the provided context.

Do executes Page . clearCompilationCache against the provided context .


func (p GenerateTestReportParams) WithGroup(group string) *GenerateTestReportParams {
	p.Group = group
	return &p
}

func ( p GenerateTestReportParams ) WithGroup ( group string ) * GenerateTestReportParams { p . Group = group return & p }

// WithGroup specifies the endpoint group to deliver the report to.

WithGroup specifies the endpoint group to deliver the report to .


func (p *WaitForDebuggerParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandWaitForDebugger, nil, nil)
}

func ( p * WaitForDebuggerParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandWaitForDebugger , nil , nil ) }

// Do executes Page.waitForDebugger against the provided context.

Do executes Page . waitForDebugger against the provided context .


func (p *ActivateTargetParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandActivateTarget, p, nil)
}

func ( p * ActivateTargetParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandActivateTarget , p , nil ) }

// Do executes Target.activateTarget against the provided context.

Do executes Target . activateTarget against the provided context .


func (p ExposeDevToolsProtocolParams) WithBindingName(bindingName string) *ExposeDevToolsProtocolParams {
	p.BindingName = bindingName
	return &p
}

func ( p ExposeDevToolsProtocolParams ) WithBindingName ( bindingName string ) * ExposeDevToolsProtocolParams { p . BindingName = bindingName return & p }

// WithBindingName binding name, 'cdp' if not specified.

WithBindingName binding name cdp if not specified .


func (p *ExposeDevToolsProtocolParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandExposeDevToolsProtocol, p, nil)
}

func ( p * ExposeDevToolsProtocolParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandExposeDevToolsProtocol , p , nil ) }

// Do executes Target.exposeDevToolsProtocol against the provided context.

Do executes Target . exposeDevToolsProtocol against the provided context .


func (p CreateTargetParams) WithBrowserContextID(browserContextID BrowserContextID) *CreateTargetParams {
	p.BrowserContextID = browserContextID
	return &p
}

func ( p CreateTargetParams ) WithBrowserContextID ( browserContextID BrowserContextID ) * CreateTargetParams { p . BrowserContextID = browserContextID return & p }

// WithBrowserContextID the browser context to create the page in.

WithBrowserContextID the browser context to create the page in .


func (p DetachFromTargetParams) WithSessionID(sessionID SessionID) *DetachFromTargetParams {
	p.SessionID = sessionID
	return &p
}

func ( p DetachFromTargetParams ) WithSessionID ( sessionID SessionID ) * DetachFromTargetParams { p . SessionID = sessionID return & p }


func (p *DetachFromTargetParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandDetachFromTarget, p, nil)
}

func ( p * DetachFromTargetParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandDetachFromTarget , p , nil ) }

// Do executes Target.detachFromTarget against the provided context.

Do executes Target . detachFromTarget against the provided context .


func (p *DisposeBrowserContextParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandDisposeBrowserContext, p, nil)
}

func ( p * DisposeBrowserContextParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandDisposeBrowserContext , p , nil ) }

// Do executes Target.disposeBrowserContext against the provided context.

Do executes Target . disposeBrowserContext against the provided context .


func (p SendMessageToTargetParams) WithSessionID(sessionID SessionID) *SendMessageToTargetParams {
	p.SessionID = sessionID
	return &p
}

func ( p SendMessageToTargetParams ) WithSessionID ( sessionID SessionID ) * SendMessageToTargetParams { p . SessionID = sessionID return & p }

// WithSessionID identifier of the session.

WithSessionID identifier of the session .


func (p *SendMessageToTargetParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSendMessageToTarget, p, nil)
}

func ( p * SendMessageToTargetParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSendMessageToTarget , p , nil ) }

// Do executes Target.sendMessageToTarget against the provided context.

Do executes Target . sendMessageToTarget against the provided context .


func (p *SetAutoAttachParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetAutoAttach, p, nil)
}

func ( p * SetAutoAttachParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetAutoAttach , p , nil ) }

// Do executes Target.setAutoAttach against the provided context.

Do executes Target . setAutoAttach against the provided context .


func (p *SetDiscoverTargetsParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetDiscoverTargets, p, nil)
}

func ( p * SetDiscoverTargetsParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetDiscoverTargets , p , nil ) }

// Do executes Target.setDiscoverTargets against the provided context.

Do executes Target . setDiscoverTargets against the provided context .


func (p *SetRemoteLocationsParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetRemoteLocations, p, nil)
}

func ( p * SetRemoteLocationsParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetRemoteLocations , p , nil ) }

// Do executes Target.setRemoteLocations against the provided context.

Do executes Target . setRemoteLocations against the provided context .


func (p EnableParams) WithPatterns(patterns []*RequestPattern) *EnableParams {
	p.Patterns = patterns
	return &p
}

func ( p EnableParams ) WithPatterns ( patterns [ ] * RequestPattern ) * EnableParams { p . Patterns = patterns return & p }

// WithPatterns if specified, only requests matching any of these patterns
// will produce fetchRequested event and will be paused until clients response.
// If not set, all requests will be affected.

WithPatterns if specified only requests matching any of these patterns will produce fetchRequested event and will be paused until clients response . If not set all requests will be affected .


func (p EnableParams) WithHandleAuthRequests(handleAuthRequests bool) *EnableParams {
	p.HandleAuthRequests = handleAuthRequests
	return &p
}

func ( p EnableParams ) WithHandleAuthRequests ( handleAuthRequests bool ) * EnableParams { p . HandleAuthRequests = handleAuthRequests return & p }

// WithHandleAuthRequests if true, authRequired events will be issued and
// requests will be paused expecting a call to continueWithAuth.

WithHandleAuthRequests if true authRequired events will be issued and requests will be paused expecting a call to continueWithAuth .


func (p *FailRequestParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandFailRequest, p, nil)
}

func ( p * FailRequestParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandFailRequest , p , nil ) }

// Do executes Fetch.failRequest against the provided context.

Do executes Fetch . failRequest against the provided context .


func (p FulfillRequestParams) WithBody(body string) *FulfillRequestParams {
	p.Body = body
	return &p
}

func ( p FulfillRequestParams ) WithBody ( body string ) * FulfillRequestParams { p . Body = body return & p }


func (p FulfillRequestParams) WithResponsePhrase(responsePhrase string) *FulfillRequestParams {
	p.ResponsePhrase = responsePhrase
	return &p
}

func ( p FulfillRequestParams ) WithResponsePhrase ( responsePhrase string ) * FulfillRequestParams { p . ResponsePhrase = responsePhrase return & p }

// WithResponsePhrase a textual representation of responseCode. If absent, a
// standard phrase mathcing responseCode is used.

WithResponsePhrase a textual representation of responseCode . If absent a standard phrase mathcing responseCode is used .


func (p *FulfillRequestParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandFulfillRequest, p, nil)
}

func ( p * FulfillRequestParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandFulfillRequest , p , nil ) }

// Do executes Fetch.fulfillRequest against the provided context.

Do executes Fetch . fulfillRequest against the provided context .


func (p ContinueRequestParams) WithURL(url string) *ContinueRequestParams {
	p.URL = url
	return &p
}

func ( p ContinueRequestParams ) WithURL ( url string ) * ContinueRequestParams { p . URL = url return & p }

// WithURL if set, the request url will be modified in a way that's not
// observable by page.

WithURL if set the request url will be modified in a way that s not observable by page .


func (p ContinueRequestParams) WithMethod(method string) *ContinueRequestParams {
	p.Method = method
	return &p
}

func ( p ContinueRequestParams ) WithMethod ( method string ) * ContinueRequestParams { p . Method = method return & p }

// WithMethod if set, the request method is overridden.

WithMethod if set the request method is overridden .


func (p ContinueRequestParams) WithPostData(postData string) *ContinueRequestParams {
	p.PostData = postData
	return &p
}

func ( p ContinueRequestParams ) WithPostData ( postData string ) * ContinueRequestParams { p . PostData = postData return & p }

// WithPostData if set, overrides the post data in the request.

WithPostData if set overrides the post data in the request .


func (p ContinueRequestParams) WithHeaders(headers []*HeaderEntry) *ContinueRequestParams {
	p.Headers = headers
	return &p
}

func ( p ContinueRequestParams ) WithHeaders ( headers [ ] * HeaderEntry ) * ContinueRequestParams { p . Headers = headers return & p }

// WithHeaders if set, overrides the request headrts.

WithHeaders if set overrides the request headrts .


func (p *ContinueRequestParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandContinueRequest, p, nil)
}

func ( p * ContinueRequestParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandContinueRequest , p , nil ) }

// Do executes Fetch.continueRequest against the provided context.

Do executes Fetch . continueRequest against the provided context .


func (p *ContinueWithAuthParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandContinueWithAuth, p, nil)
}

func ( p * ContinueWithAuthParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandContinueWithAuth , p , nil ) }

// Do executes Fetch.continueWithAuth against the provided context.

Do executes Fetch . continueWithAuth against the provided context .


func (p *ContinueToLocationParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandContinueToLocation, p, nil)
}

func ( p * ContinueToLocationParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandContinueToLocation , p , nil ) }

// Do executes Debugger.continueToLocation against the provided context.

Do executes Debugger . continueToLocation against the provided context .


func (p EvaluateOnCallFrameParams) WithIncludeCommandLineAPI(includeCommandLineAPI bool) *EvaluateOnCallFrameParams {
	p.IncludeCommandLineAPI = includeCommandLineAPI
	return &p
}

func ( p EvaluateOnCallFrameParams ) WithIncludeCommandLineAPI ( includeCommandLineAPI bool ) * EvaluateOnCallFrameParams { p . IncludeCommandLineAPI = includeCommandLineAPI return & p }

// WithIncludeCommandLineAPI specifies whether command line API should be
// available to the evaluated expression, defaults to false.

WithIncludeCommandLineAPI specifies whether command line API should be available to the evaluated expression defaults to false .


func (p *PauseParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandPause, nil, nil)
}

func ( p * PauseParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandPause , nil , nil ) }

// Do executes Debugger.pause against the provided context.

Do executes Debugger . pause against the provided context .


func (p *PauseOnAsyncCallParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandPauseOnAsyncCall, p, nil)
}

func ( p * PauseOnAsyncCallParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandPauseOnAsyncCall , p , nil ) }

// Do executes Debugger.pauseOnAsyncCall against the provided context.

Do executes Debugger . pauseOnAsyncCall against the provided context .


func (p *RemoveBreakpointParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandRemoveBreakpoint, p, nil)
}

func ( p * RemoveBreakpointParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandRemoveBreakpoint , p , nil ) }

// Do executes Debugger.removeBreakpoint against the provided context.

Do executes Debugger . removeBreakpoint against the provided context .


func (p *ResumeParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandResume, nil, nil)
}

func ( p * ResumeParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandResume , nil , nil ) }

// Do executes Debugger.resume against the provided context.

Do executes Debugger . resume against the provided context .


func (p *SetAsyncCallStackDepthParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetAsyncCallStackDepth, p, nil)
}

func ( p * SetAsyncCallStackDepthParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetAsyncCallStackDepth , p , nil ) }

// Do executes Debugger.setAsyncCallStackDepth against the provided context.

Do executes Debugger . setAsyncCallStackDepth against the provided context .


func (p *SetBlackboxPatternsParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetBlackboxPatterns, p, nil)
}

func ( p * SetBlackboxPatternsParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetBlackboxPatterns , p , nil ) }

// Do executes Debugger.setBlackboxPatterns against the provided context.

Do executes Debugger . setBlackboxPatterns against the provided context .


func (p *SetBlackboxedRangesParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetBlackboxedRanges, p, nil)
}

func ( p * SetBlackboxedRangesParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetBlackboxedRanges , p , nil ) }

// Do executes Debugger.setBlackboxedRanges against the provided context.

Do executes Debugger . setBlackboxedRanges against the provided context .


func (p SetBreakpointByURLParams) WithURL(url string) *SetBreakpointByURLParams {
	p.URL = url
	return &p
}

func ( p SetBreakpointByURLParams ) WithURL ( url string ) * SetBreakpointByURLParams { p . URL = url return & p }

// WithURL URL of the resources to set breakpoint on.

WithURL URL of the resources to set breakpoint on .


func (p SetBreakpointByURLParams) WithURLRegex(urlRegex string) *SetBreakpointByURLParams {
	p.URLRegex = urlRegex
	return &p
}

func ( p SetBreakpointByURLParams ) WithURLRegex ( urlRegex string ) * SetBreakpointByURLParams { p . URLRegex = urlRegex return & p }

// WithURLRegex regex pattern for the URLs of the resources to set
// breakpoints on. Either url or urlRegex must be specified.

WithURLRegex regex pattern for the URLs of the resources to set breakpoints on . Either url or urlRegex must be specified .


func (p SetBreakpointByURLParams) WithScriptHash(scriptHash string) *SetBreakpointByURLParams {
	p.ScriptHash = scriptHash
	return &p
}

func ( p SetBreakpointByURLParams ) WithScriptHash ( scriptHash string ) * SetBreakpointByURLParams { p . ScriptHash = scriptHash return & p }

// WithScriptHash script hash of the resources to set breakpoint on.

WithScriptHash script hash of the resources to set breakpoint on .


func (p SetBreakpointByURLParams) WithColumnNumber(columnNumber int64) *SetBreakpointByURLParams {
	p.ColumnNumber = columnNumber
	return &p
}

func ( p SetBreakpointByURLParams ) WithColumnNumber ( columnNumber int64 ) * SetBreakpointByURLParams { p . ColumnNumber = columnNumber return & p }

// WithColumnNumber offset in the line to set breakpoint at.

WithColumnNumber offset in the line to set breakpoint at .


func (p SetBreakpointOnFunctionCallParams) WithCondition(condition string) *SetBreakpointOnFunctionCallParams {
	p.Condition = condition
	return &p
}

func ( p SetBreakpointOnFunctionCallParams ) WithCondition ( condition string ) * SetBreakpointOnFunctionCallParams { p . Condition = condition return & p }

// WithCondition expression to use as a breakpoint condition. When specified,
// debugger will stop on the breakpoint if this expression evaluates to true.

WithCondition expression to use as a breakpoint condition . When specified debugger will stop on the breakpoint if this expression evaluates to true .


func (p *SetBreakpointsActiveParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetBreakpointsActive, p, nil)
}

func ( p * SetBreakpointsActiveParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetBreakpointsActive , p , nil ) }

// Do executes Debugger.setBreakpointsActive against the provided context.

Do executes Debugger . setBreakpointsActive against the provided context .


func (p *SetPauseOnExceptionsParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetPauseOnExceptions, p, nil)
}

func ( p * SetPauseOnExceptionsParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetPauseOnExceptions , p , nil ) }

// Do executes Debugger.setPauseOnExceptions against the provided context.

Do executes Debugger . setPauseOnExceptions against the provided context .


func (p *SetReturnValueParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetReturnValue, p, nil)
}

func ( p * SetReturnValueParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetReturnValue , p , nil ) }

// Do executes Debugger.setReturnValue against the provided context.

Do executes Debugger . setReturnValue against the provided context .


func (p SetScriptSourceParams) WithDryRun(dryRun bool) *SetScriptSourceParams {
	p.DryRun = dryRun
	return &p
}

func ( p SetScriptSourceParams ) WithDryRun ( dryRun bool ) * SetScriptSourceParams { p . DryRun = dryRun return & p }

// WithDryRun if true the change will not actually be applied. Dry run may be
// used to get result description without actually modifying the code.

WithDryRun if true the change will not actually be applied . Dry run may be used to get result description without actually modifying the code .


func (p *SetSkipAllPausesParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetSkipAllPauses, p, nil)
}

func ( p * SetSkipAllPausesParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetSkipAllPauses , p , nil ) }

// Do executes Debugger.setSkipAllPauses against the provided context.

Do executes Debugger . setSkipAllPauses against the provided context .


func (p *SetVariableValueParams) Do(ctx context.Context) (err error) {
	return cdp.Execute(ctx, CommandSetVariableValue, p, nil)
}

func ( p * SetVariableValueParams ) Do ( ctx context . Context ) ( err error ) { return cdp . Execute ( ctx , CommandSetVariableValue , p , nil ) }

// Do executes Debugger.setVariableValue against the provided context.

Do executes Debugger . setVariableValue against the provided context .