chromedp/cdp/network/network.go

// Package network provides the Chrome Debugging Protocol
// commands, types, and events for the Network domain.
//
// Network domain allows tracking network activities of the page. It exposes
// information about http, file, data and other requests and responses, their
// headers, bodies, timing, etc.
//
// Generated by the chromedp-gen command.
package network

// AUTOGENERATED. DO NOT EDIT.

import (
	"context"
	"encoding/base64"

	cdp "github.com/knq/chromedp/cdp"
)

// EnableParams enables network tracking, network events will now be
// delivered to the client.
type EnableParams struct {
	MaxTotalBufferSize    int64 `json:"maxTotalBufferSize,omitempty"`    // Buffer size in bytes to use when preserving network payloads (XHRs, etc).
	MaxResourceBufferSize int64 `json:"maxResourceBufferSize,omitempty"` // Per-resource buffer size in bytes to use when preserving network payloads (XHRs, etc).
}

// Enable enables network tracking, network events will now be delivered to
// the client.
//
// parameters:
func Enable() *EnableParams {
	return &EnableParams{}
}

// WithMaxTotalBufferSize buffer size in bytes to use when preserving network
// payloads (XHRs, etc).
func (p EnableParams) WithMaxTotalBufferSize(maxTotalBufferSize int64) *EnableParams {
	p.MaxTotalBufferSize = maxTotalBufferSize
	return &p
}

// WithMaxResourceBufferSize per-resource buffer size in bytes to use when
// preserving network payloads (XHRs, etc).
func (p EnableParams) WithMaxResourceBufferSize(maxResourceBufferSize int64) *EnableParams {
	p.MaxResourceBufferSize = maxResourceBufferSize
	return &p
}

// Do executes Network.enable against the provided context and
// target handler.
func (p *EnableParams) Do(ctxt context.Context, h cdp.Handler) (err error) {
	return h.Execute(ctxt, cdp.CommandNetworkEnable, p, nil)
}

// DisableParams disables network tracking, prevents network events from
// being sent to the client.
type DisableParams struct{}

// Disable disables network tracking, prevents network events from being sent
// to the client.
func Disable() *DisableParams {
	return &DisableParams{}
}

// Do executes Network.disable against the provided context and
// target handler.
func (p *DisableParams) Do(ctxt context.Context, h cdp.Handler) (err error) {
	return h.Execute(ctxt, cdp.CommandNetworkDisable, nil, nil)
}

// SetUserAgentOverrideParams allows overriding user agent with the given
// string.
type SetUserAgentOverrideParams struct {
	UserAgent string `json:"userAgent"` // User agent to use.
}

// SetUserAgentOverride allows overriding user agent with the given string.
//
// parameters:
//   userAgent - User agent to use.
func SetUserAgentOverride(userAgent string) *SetUserAgentOverrideParams {
	return &SetUserAgentOverrideParams{
		UserAgent: userAgent,
	}
}

// Do executes Network.setUserAgentOverride against the provided context and
// target handler.
func (p *SetUserAgentOverrideParams) Do(ctxt context.Context, h cdp.Handler) (err error) {
	return h.Execute(ctxt, cdp.CommandNetworkSetUserAgentOverride, p, nil)
}

// SetExtraHTTPHeadersParams specifies whether to always send extra HTTP
// headers with the requests from this page.
type SetExtraHTTPHeadersParams struct {
	Headers *Headers `json:"headers"` // Map with extra HTTP headers.
}

// SetExtraHTTPHeaders specifies whether to always send extra HTTP headers
// with the requests from this page.
//
// parameters:
//   headers - Map with extra HTTP headers.
func SetExtraHTTPHeaders(headers *Headers) *SetExtraHTTPHeadersParams {
	return &SetExtraHTTPHeadersParams{
		Headers: headers,
	}
}

// Do executes Network.setExtraHTTPHeaders against the provided context and
// target handler.
func (p *SetExtraHTTPHeadersParams) Do(ctxt context.Context, h cdp.Handler) (err error) {
	return h.Execute(ctxt, cdp.CommandNetworkSetExtraHTTPHeaders, p, nil)
}

// GetResponseBodyParams returns content served for the given request.
type GetResponseBodyParams struct {
	RequestID RequestID `json:"requestId"` // Identifier of the network request to get content for.
}

// GetResponseBody returns content served for the given request.
//
// parameters:
//   requestID - Identifier of the network request to get content for.
func GetResponseBody(requestID RequestID) *GetResponseBodyParams {
	return &GetResponseBodyParams{
		RequestID: requestID,
	}
}

// GetResponseBodyReturns return values.
type GetResponseBodyReturns struct {
	Body          string `json:"body,omitempty"`          // Response body.
	Base64encoded bool   `json:"base64Encoded,omitempty"` // True, if content was sent as base64.
}

// Do executes Network.getResponseBody against the provided context and
// target handler.
//
// returns:
//   body - Response body.
func (p *GetResponseBodyParams) Do(ctxt context.Context, h cdp.Handler) (body []byte, err error) {
	// execute
	var res GetResponseBodyReturns
	err = h.Execute(ctxt, cdp.CommandNetworkGetResponseBody, p, &res)
	if err != nil {
		return nil, err
	}

	// decode
	var dec []byte
	if res.Base64encoded {
		dec, err = base64.StdEncoding.DecodeString(res.Body)
		if err != nil {
			return nil, err
		}
	} else {
		dec = []byte(res.Body)
	}
	return dec, nil
}

// SetBlockedURLSParams blocks URLs from loading.
type SetBlockedURLSParams struct {
	Urls []string `json:"urls"` // URL patterns to block. Wildcards ('*') are allowed.
}

// SetBlockedURLS blocks URLs from loading.
//
// parameters:
//   urls - URL patterns to block. Wildcards ('*') are allowed.
func SetBlockedURLS(urls []string) *SetBlockedURLSParams {
	return &SetBlockedURLSParams{
		Urls: urls,
	}
}

// Do executes Network.setBlockedURLs against the provided context and
// target handler.
func (p *SetBlockedURLSParams) Do(ctxt context.Context, h cdp.Handler) (err error) {
	return h.Execute(ctxt, cdp.CommandNetworkSetBlockedURLS, p, nil)
}

// ReplayXHRParams this method sends a new XMLHttpRequest which is identical
// to the original one. The following parameters should be identical: method,
// url, async, request body, extra headers, withCredentials attribute, user,
// password.
type ReplayXHRParams struct {
	RequestID RequestID `json:"requestId"` // Identifier of XHR to replay.
}

// ReplayXHR this method sends a new XMLHttpRequest which is identical to the
// original one. The following parameters should be identical: method, url,
// async, request body, extra headers, withCredentials attribute, user,
// password.
//
// parameters:
//   requestID - Identifier of XHR to replay.
func ReplayXHR(requestID RequestID) *ReplayXHRParams {
	return &ReplayXHRParams{
		RequestID: requestID,
	}
}

// Do executes Network.replayXHR against the provided context and
// target handler.
func (p *ReplayXHRParams) Do(ctxt context.Context, h cdp.Handler) (err error) {
	return h.Execute(ctxt, cdp.CommandNetworkReplayXHR, p, nil)
}

// CanClearBrowserCacheParams tells whether clearing browser cache is
// supported.
type CanClearBrowserCacheParams struct{}

// CanClearBrowserCache tells whether clearing browser cache is supported.
func CanClearBrowserCache() *CanClearBrowserCacheParams {
	return &CanClearBrowserCacheParams{}
}

// CanClearBrowserCacheReturns return values.
type CanClearBrowserCacheReturns struct {
	Result bool `json:"result,omitempty"` // True if browser cache can be cleared.
}

// Do executes Network.canClearBrowserCache against the provided context and
// target handler.
//
// returns:
//   result - True if browser cache can be cleared.
func (p *CanClearBrowserCacheParams) Do(ctxt context.Context, h cdp.Handler) (result bool, err error) {
	// execute
	var res CanClearBrowserCacheReturns
	err = h.Execute(ctxt, cdp.CommandNetworkCanClearBrowserCache, nil, &res)
	if err != nil {
		return false, err
	}

	return res.Result, nil
}

// ClearBrowserCacheParams clears browser cache.
type ClearBrowserCacheParams struct{}

// ClearBrowserCache clears browser cache.
func ClearBrowserCache() *ClearBrowserCacheParams {
	return &ClearBrowserCacheParams{}
}

// Do executes Network.clearBrowserCache against the provided context and
// target handler.
func (p *ClearBrowserCacheParams) Do(ctxt context.Context, h cdp.Handler) (err error) {
	return h.Execute(ctxt, cdp.CommandNetworkClearBrowserCache, nil, nil)
}

// CanClearBrowserCookiesParams tells whether clearing browser cookies is
// supported.
type CanClearBrowserCookiesParams struct{}

// CanClearBrowserCookies tells whether clearing browser cookies is
// supported.
func CanClearBrowserCookies() *CanClearBrowserCookiesParams {
	return &CanClearBrowserCookiesParams{}
}

// CanClearBrowserCookiesReturns return values.
type CanClearBrowserCookiesReturns struct {
	Result bool `json:"result,omitempty"` // True if browser cookies can be cleared.
}

// Do executes Network.canClearBrowserCookies against the provided context and
// target handler.
//
// returns:
//   result - True if browser cookies can be cleared.
func (p *CanClearBrowserCookiesParams) Do(ctxt context.Context, h cdp.Handler) (result bool, err error) {
	// execute
	var res CanClearBrowserCookiesReturns
	err = h.Execute(ctxt, cdp.CommandNetworkCanClearBrowserCookies, nil, &res)
	if err != nil {
		return false, err
	}

	return res.Result, nil
}

// ClearBrowserCookiesParams clears browser cookies.
type ClearBrowserCookiesParams struct{}

// ClearBrowserCookies clears browser cookies.
func ClearBrowserCookies() *ClearBrowserCookiesParams {
	return &ClearBrowserCookiesParams{}
}

// Do executes Network.clearBrowserCookies against the provided context and
// target handler.
func (p *ClearBrowserCookiesParams) Do(ctxt context.Context, h cdp.Handler) (err error) {
	return h.Execute(ctxt, cdp.CommandNetworkClearBrowserCookies, nil, nil)
}

// GetCookiesParams returns all browser cookies for the current URL.
// Depending on the backend support, will return detailed cookie information in
// the cookies field.
type GetCookiesParams struct {
	Urls []string `json:"urls,omitempty"` // The list of URLs for which applicable cookies will be fetched
}

// GetCookies returns all browser cookies for the current URL. Depending on
// the backend support, will return detailed cookie information in the cookies
// field.
//
// parameters:
func GetCookies() *GetCookiesParams {
	return &GetCookiesParams{}
}

// WithUrls the list of URLs for which applicable cookies will be fetched.
func (p GetCookiesParams) WithUrls(urls []string) *GetCookiesParams {
	p.Urls = urls
	return &p
}

// GetCookiesReturns return values.
type GetCookiesReturns struct {
	Cookies []*Cookie `json:"cookies,omitempty"` // Array of cookie objects.
}

// Do executes Network.getCookies against the provided context and
// target handler.
//
// returns:
//   cookies - Array of cookie objects.
func (p *GetCookiesParams) Do(ctxt context.Context, h cdp.Handler) (cookies []*Cookie, err error) {
	// execute
	var res GetCookiesReturns
	err = h.Execute(ctxt, cdp.CommandNetworkGetCookies, p, &res)
	if err != nil {
		return nil, err
	}

	return res.Cookies, nil
}

// GetAllCookiesParams returns all browser cookies. Depending on the backend
// support, will return detailed cookie information in the cookies field.
type GetAllCookiesParams struct{}

// GetAllCookies returns all browser cookies. Depending on the backend
// support, will return detailed cookie information in the cookies field.
func GetAllCookies() *GetAllCookiesParams {
	return &GetAllCookiesParams{}
}

// GetAllCookiesReturns return values.
type GetAllCookiesReturns struct {
	Cookies []*Cookie `json:"cookies,omitempty"` // Array of cookie objects.
}

// Do executes Network.getAllCookies against the provided context and
// target handler.
//
// returns:
//   cookies - Array of cookie objects.
func (p *GetAllCookiesParams) Do(ctxt context.Context, h cdp.Handler) (cookies []*Cookie, err error) {
	// execute
	var res GetAllCookiesReturns
	err = h.Execute(ctxt, cdp.CommandNetworkGetAllCookies, nil, &res)
	if err != nil {
		return nil, err
	}

	return res.Cookies, nil
}

// DeleteCookieParams deletes browser cookie with given name, domain and
// path.
type DeleteCookieParams struct {
	CookieName string `json:"cookieName"` // Name of the cookie to remove.
	URL        string `json:"url"`        // URL to match cooke domain and path.
}

// DeleteCookie deletes browser cookie with given name, domain and path.
//
// parameters:
//   cookieName - Name of the cookie to remove.
//   url - URL to match cooke domain and path.
func DeleteCookie(cookieName string, url string) *DeleteCookieParams {
	return &DeleteCookieParams{
		CookieName: cookieName,
		URL:        url,
	}
}

// Do executes Network.deleteCookie against the provided context and
// target handler.
func (p *DeleteCookieParams) Do(ctxt context.Context, h cdp.Handler) (err error) {
	return h.Execute(ctxt, cdp.CommandNetworkDeleteCookie, p, nil)
}

// SetCookieParams sets a cookie with the given cookie data; may overwrite
// equivalent cookies if they exist.
type SetCookieParams struct {
	URL            string         `json:"url"`                      // 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.
	Name           string         `json:"name"`                     // The name of the cookie.
	Value          string         `json:"value"`                    // The value of the cookie.
	Domain         string         `json:"domain,omitempty"`         // If omitted, the cookie becomes a host-only cookie.
	Path           string         `json:"path,omitempty"`           // Defaults to the path portion of the url parameter.
	Secure         bool           `json:"secure,omitempty"`         // Defaults ot false.
	HTTPOnly       bool           `json:"httpOnly,omitempty"`       // Defaults to false.
	SameSite       CookieSameSite `json:"sameSite,omitempty"`       // Defaults to browser default behavior.
	ExpirationDate cdp.Timestamp  `json:"expirationDate,omitempty"` // If omitted, the cookie becomes a session cookie.
}

// SetCookie sets a cookie with the given cookie data; may overwrite
// equivalent cookies if they exist.
//
// parameters:
//   url - 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.
//   name - The name of the cookie.
//   value - The value of the cookie.
func SetCookie(url string, name string, value string) *SetCookieParams {
	return &SetCookieParams{
		URL:   url,
		Name:  name,
		Value: value,
	}
}

// WithDomain if omitted, the cookie becomes a host-only cookie.
func (p SetCookieParams) WithDomain(domain string) *SetCookieParams {
	p.Domain = domain
	return &p
}

// WithPath defaults to the path portion of the url parameter.
func (p SetCookieParams) WithPath(path string) *SetCookieParams {
	p.Path = path
	return &p
}

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

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

// WithSameSite defaults to browser default behavior.
func (p SetCookieParams) WithSameSite(sameSite CookieSameSite) *SetCookieParams {
	p.SameSite = sameSite
	return &p
}

// WithExpirationDate if omitted, the cookie becomes a session cookie.
func (p SetCookieParams) WithExpirationDate(expirationDate cdp.Timestamp) *SetCookieParams {
	p.ExpirationDate = expirationDate
	return &p
}

// SetCookieReturns return values.
type SetCookieReturns struct {
	Success bool `json:"success,omitempty"` // True if successfully set cookie.
}

// Do executes Network.setCookie against the provided context and
// target handler.
//
// returns:
//   success - True if successfully set cookie.
func (p *SetCookieParams) Do(ctxt context.Context, h cdp.Handler) (success bool, err error) {
	// execute
	var res SetCookieReturns
	err = h.Execute(ctxt, cdp.CommandNetworkSetCookie, p, &res)
	if err != nil {
		return false, err
	}

	return res.Success, nil
}

// CanEmulateNetworkConditionsParams tells whether emulation of network
// conditions is supported.
type CanEmulateNetworkConditionsParams struct{}

// CanEmulateNetworkConditions tells whether emulation of network conditions
// is supported.
func CanEmulateNetworkConditions() *CanEmulateNetworkConditionsParams {
	return &CanEmulateNetworkConditionsParams{}
}

// CanEmulateNetworkConditionsReturns return values.
type CanEmulateNetworkConditionsReturns struct {
	Result bool `json:"result,omitempty"` // True if emulation of network conditions is supported.
}

// Do executes Network.canEmulateNetworkConditions against the provided context and
// target handler.
//
// returns:
//   result - True if emulation of network conditions is supported.
func (p *CanEmulateNetworkConditionsParams) Do(ctxt context.Context, h cdp.Handler) (result bool, err error) {
	// execute
	var res CanEmulateNetworkConditionsReturns
	err = h.Execute(ctxt, cdp.CommandNetworkCanEmulateNetworkConditions, nil, &res)
	if err != nil {
		return false, err
	}

	return res.Result, nil
}

// EmulateNetworkConditionsParams activates emulation of network conditions.
type EmulateNetworkConditionsParams struct {
	Offline            bool           `json:"offline"`                  // True to emulate internet disconnection.
	Latency            float64        `json:"latency"`                  // Additional latency (ms).
	DownloadThroughput float64        `json:"downloadThroughput"`       // Maximal aggregated download throughput.
	UploadThroughput   float64        `json:"uploadThroughput"`         // Maximal aggregated upload throughput.
	ConnectionType     ConnectionType `json:"connectionType,omitempty"` // Connection type if known.
}

// EmulateNetworkConditions activates emulation of network conditions.
//
// parameters:
//   offline - True to emulate internet disconnection.
//   latency - Additional latency (ms).
//   downloadThroughput - Maximal aggregated download throughput.
//   uploadThroughput - Maximal aggregated upload throughput.
func EmulateNetworkConditions(offline bool, latency float64, downloadThroughput float64, uploadThroughput float64) *EmulateNetworkConditionsParams {
	return &EmulateNetworkConditionsParams{
		Offline:            offline,
		Latency:            latency,
		DownloadThroughput: downloadThroughput,
		UploadThroughput:   uploadThroughput,
	}
}

// WithConnectionType connection type if known.
func (p EmulateNetworkConditionsParams) WithConnectionType(connectionType ConnectionType) *EmulateNetworkConditionsParams {
	p.ConnectionType = connectionType
	return &p
}

// Do executes Network.emulateNetworkConditions against the provided context and
// target handler.
func (p *EmulateNetworkConditionsParams) Do(ctxt context.Context, h cdp.Handler) (err error) {
	return h.Execute(ctxt, cdp.CommandNetworkEmulateNetworkConditions, p, nil)
}

// SetCacheDisabledParams toggles ignoring cache for each request. If true,
// cache will not be used.
type SetCacheDisabledParams struct {
	CacheDisabled bool `json:"cacheDisabled"` // Cache disabled state.
}

// SetCacheDisabled toggles ignoring cache for each request. If true, cache
// will not be used.
//
// parameters:
//   cacheDisabled - Cache disabled state.
func SetCacheDisabled(cacheDisabled bool) *SetCacheDisabledParams {
	return &SetCacheDisabledParams{
		CacheDisabled: cacheDisabled,
	}
}

// Do executes Network.setCacheDisabled against the provided context and
// target handler.
func (p *SetCacheDisabledParams) Do(ctxt context.Context, h cdp.Handler) (err error) {
	return h.Execute(ctxt, cdp.CommandNetworkSetCacheDisabled, p, nil)
}

// SetBypassServiceWorkerParams toggles ignoring of service worker for each
// request.
type SetBypassServiceWorkerParams struct {
	Bypass bool `json:"bypass"` // Bypass service worker and load from network.
}

// SetBypassServiceWorker toggles ignoring of service worker for each
// request.
//
// parameters:
//   bypass - Bypass service worker and load from network.
func SetBypassServiceWorker(bypass bool) *SetBypassServiceWorkerParams {
	return &SetBypassServiceWorkerParams{
		Bypass: bypass,
	}
}

// Do executes Network.setBypassServiceWorker against the provided context and
// target handler.
func (p *SetBypassServiceWorkerParams) Do(ctxt context.Context, h cdp.Handler) (err error) {
	return h.Execute(ctxt, cdp.CommandNetworkSetBypassServiceWorker, p, nil)
}

// SetDataSizeLimitsForTestParams for testing.
type SetDataSizeLimitsForTestParams struct {
	MaxTotalSize    int64 `json:"maxTotalSize"`    // Maximum total buffer size.
	MaxResourceSize int64 `json:"maxResourceSize"` // Maximum per-resource size.
}

// SetDataSizeLimitsForTest for testing.
//
// parameters:
//   maxTotalSize - Maximum total buffer size.
//   maxResourceSize - Maximum per-resource size.
func SetDataSizeLimitsForTest(maxTotalSize int64, maxResourceSize int64) *SetDataSizeLimitsForTestParams {
	return &SetDataSizeLimitsForTestParams{
		MaxTotalSize:    maxTotalSize,
		MaxResourceSize: maxResourceSize,
	}
}

// Do executes Network.setDataSizeLimitsForTest against the provided context and
// target handler.
func (p *SetDataSizeLimitsForTestParams) Do(ctxt context.Context, h cdp.Handler) (err error) {
	return h.Execute(ctxt, cdp.CommandNetworkSetDataSizeLimitsForTest, p, nil)
}

// GetCertificateParams returns the DER-encoded certificate.
type GetCertificateParams struct {
	Origin string `json:"origin"` // Origin to get certificate for.
}

// GetCertificate returns the DER-encoded certificate.
//
// parameters:
//   origin - Origin to get certificate for.
func GetCertificate(origin string) *GetCertificateParams {
	return &GetCertificateParams{
		Origin: origin,
	}
}

// GetCertificateReturns return values.
type GetCertificateReturns struct {
	TableNames []string `json:"tableNames,omitempty"`
}

// Do executes Network.getCertificate against the provided context and
// target handler.
//
// returns:
//   tableNames
func (p *GetCertificateParams) Do(ctxt context.Context, h cdp.Handler) (tableNames []string, err error) {
	// execute
	var res GetCertificateReturns
	err = h.Execute(ctxt, cdp.CommandNetworkGetCertificate, p, &res)
	if err != nil {
		return nil, err
	}

	return res.TableNames, nil
}

// EnableRequestInterceptionParams [no description].
type EnableRequestInterceptionParams struct {
	Enabled bool `json:"enabled"` // Whether or not HTTP requests should be intercepted and Network.requestIntercepted events sent.
}

// EnableRequestInterception [no description].
//
// parameters:
//   enabled - Whether or not HTTP requests should be intercepted and Network.requestIntercepted events sent.
func EnableRequestInterception(enabled bool) *EnableRequestInterceptionParams {
	return &EnableRequestInterceptionParams{
		Enabled: enabled,
	}
}

// Do executes Network.enableRequestInterception against the provided context and
// target handler.
func (p *EnableRequestInterceptionParams) Do(ctxt context.Context, h cdp.Handler) (err error) {
	return h.Execute(ctxt, cdp.CommandNetworkEnableRequestInterception, p, nil)
}

// ContinueInterceptedRequestParams response to Network.requestIntercepted
// which either modifies the request to continue with any modifications, or
// blocks it, or completes it with the provided response bytes. If a network
// fetch occurs as a result which encounters a redirect an additional
// Network.requestIntercepted event will be sent with the same InterceptionId.
type ContinueInterceptedRequestParams struct {
	InterceptionID InterceptionID `json:"interceptionId"`
	ErrorReason    ErrorReason    `json:"errorReason,omitempty"` // If set this causes the request to fail with the given reason.
	RawResponse    string         `json:"rawResponse,omitempty"` // If set the requests completes using with the provided base64 encoded raw response, including HTTP status line and headers etc...
	URL            string         `json:"url,omitempty"`         // If set the request url will be modified in a way that's not observable by page.
	Method         string         `json:"method,omitempty"`      // If set this allows the request method to be overridden.
	PostData       string         `json:"postData,omitempty"`    // If set this allows postData to be set.
	Headers        *Headers       `json:"headers,omitempty"`     // If set this allows the request headers to be changed.
}

// ContinueInterceptedRequest response to Network.requestIntercepted which
// either modifies the request to continue with any modifications, or blocks it,
// or completes it with the provided response bytes. If a network fetch occurs
// as a result which encounters a redirect an additional
// Network.requestIntercepted event will be sent with the same InterceptionId.
//
// parameters:
//   interceptionID
func ContinueInterceptedRequest(interceptionID InterceptionID) *ContinueInterceptedRequestParams {
	return &ContinueInterceptedRequestParams{
		InterceptionID: interceptionID,
	}
}

// WithErrorReason if set this causes the request to fail with the given
// reason.
func (p ContinueInterceptedRequestParams) WithErrorReason(errorReason ErrorReason) *ContinueInterceptedRequestParams {
	p.ErrorReason = errorReason
	return &p
}

// WithRawResponse if set the requests completes using with the provided
// base64 encoded raw response, including HTTP status line and headers etc...
func (p ContinueInterceptedRequestParams) WithRawResponse(rawResponse string) *ContinueInterceptedRequestParams {
	p.RawResponse = rawResponse
	return &p
}

// WithURL if set the request url will be modified in a way that's not
// observable by page.
func (p ContinueInterceptedRequestParams) WithURL(url string) *ContinueInterceptedRequestParams {
	p.URL = url
	return &p
}

// WithMethod if set this allows the request method to be overridden.
func (p ContinueInterceptedRequestParams) WithMethod(method string) *ContinueInterceptedRequestParams {
	p.Method = method
	return &p
}

// WithPostData if set this allows postData to be set.
func (p ContinueInterceptedRequestParams) WithPostData(postData string) *ContinueInterceptedRequestParams {
	p.PostData = postData
	return &p
}

// WithHeaders if set this allows the request headers to be changed.
func (p ContinueInterceptedRequestParams) WithHeaders(headers *Headers) *ContinueInterceptedRequestParams {
	p.Headers = headers
	return &p
}

// Do executes Network.continueInterceptedRequest against the provided context and
// target handler.
func (p *ContinueInterceptedRequestParams) Do(ctxt context.Context, h cdp.Handler) (err error) {
	return h.Execute(ctxt, cdp.CommandNetworkContinueInterceptedRequest, p, nil)
}