cdpcmd

package
v0.8.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 18, 2017 License: MIT Imports: 2 Imported by: 0

Documentation

Overview

Package cdpcmd defines the command arguments and replies for CDP commands.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AccessibilityGetPartialAXTreeArgs 

type AccessibilityGetPartialAXTreeArgs struct {
	NodeID         cdptype.DOMNodeID `json:"nodeId"`                   // ID of node to get the partial accessibility tree for.
	FetchRelatives *bool             `json:"fetchRelatives,omitempty"` // Whether to fetch this nodes ancestors, siblings and children. Defaults to true.
}

AccessibilityGetPartialAXTreeArgs represents the arguments for GetPartialAXTree in the Accessibility domain.

func NewAccessibilityGetPartialAXTreeArgs 

func NewAccessibilityGetPartialAXTreeArgs(nodeID cdptype.DOMNodeID) *AccessibilityGetPartialAXTreeArgs

NewAccessibilityGetPartialAXTreeArgs initializes AccessibilityGetPartialAXTreeArgs with the required arguments.

func (*AccessibilityGetPartialAXTreeArgs) SetFetchRelatives 

func (a *AccessibilityGetPartialAXTreeArgs) SetFetchRelatives(fetchRelatives bool) *AccessibilityGetPartialAXTreeArgs

SetFetchRelatives sets the FetchRelatives optional argument. Whether to fetch this nodes ancestors, siblings and children. Defaults to true.

type AccessibilityGetPartialAXTreeReply 

type AccessibilityGetPartialAXTreeReply struct {
	Nodes []cdptype.AccessibilityAXNode `json:"nodes"` // The Accessibility.AXNode for this DOM node, if it exists, plus its ancestors, siblings and children, if requested.
}

AccessibilityGetPartialAXTreeReply represents the return values for GetPartialAXTree in the Accessibility domain.

type AnimationGetCurrentTimeArgs 

type AnimationGetCurrentTimeArgs struct {
	ID string `json:"id"` // Id of animation.
}

AnimationGetCurrentTimeArgs represents the arguments for GetCurrentTime in the Animation domain.

func NewAnimationGetCurrentTimeArgs 

func NewAnimationGetCurrentTimeArgs(id string) *AnimationGetCurrentTimeArgs

NewAnimationGetCurrentTimeArgs initializes AnimationGetCurrentTimeArgs with the required arguments.

type AnimationGetCurrentTimeReply 

type AnimationGetCurrentTimeReply struct {
	CurrentTime float64 `json:"currentTime"` // Current time of the page.
}

AnimationGetCurrentTimeReply represents the return values for GetCurrentTime in the Animation domain.

type AnimationGetPlaybackRateReply 

type AnimationGetPlaybackRateReply struct {
	PlaybackRate float64 `json:"playbackRate"` // Playback rate for animations on page.
}

AnimationGetPlaybackRateReply represents the return values for GetPlaybackRate in the Animation domain.

type AnimationReleaseAnimationsArgs 

type AnimationReleaseAnimationsArgs struct {
	Animations []string `json:"animations"` // List of animation ids to seek.
}

AnimationReleaseAnimationsArgs represents the arguments for ReleaseAnimations in the Animation domain.

func NewAnimationReleaseAnimationsArgs 

func NewAnimationReleaseAnimationsArgs(animations []string) *AnimationReleaseAnimationsArgs

NewAnimationReleaseAnimationsArgs initializes AnimationReleaseAnimationsArgs with the required arguments.

type AnimationResolveAnimationArgs 

type AnimationResolveAnimationArgs struct {
	AnimationID string `json:"animationId"` // Animation id.
}

AnimationResolveAnimationArgs represents the arguments for ResolveAnimation in the Animation domain.

func NewAnimationResolveAnimationArgs 

func NewAnimationResolveAnimationArgs(animationID string) *AnimationResolveAnimationArgs

NewAnimationResolveAnimationArgs initializes AnimationResolveAnimationArgs with the required arguments.

type AnimationResolveAnimationReply 

type AnimationResolveAnimationReply struct {
	RemoteObject cdptype.RuntimeRemoteObject `json:"remoteObject"` // Corresponding remote object.
}

AnimationResolveAnimationReply represents the return values for ResolveAnimation in the Animation domain.

type AnimationSeekAnimationsArgs 

type AnimationSeekAnimationsArgs struct {
	Animations  []string `json:"animations"`  // List of animation ids to seek.
	CurrentTime float64  `json:"currentTime"` // Set the current time of each animation.
}

AnimationSeekAnimationsArgs represents the arguments for SeekAnimations in the Animation domain.

func NewAnimationSeekAnimationsArgs 

func NewAnimationSeekAnimationsArgs(animations []string, currentTime float64) *AnimationSeekAnimationsArgs

NewAnimationSeekAnimationsArgs initializes AnimationSeekAnimationsArgs with the required arguments.

type AnimationSetPausedArgs 

type AnimationSetPausedArgs struct {
	Animations []string `json:"animations"` // Animations to set the pause state of.
	Paused     bool     `json:"paused"`     // Paused state to set to.
}

AnimationSetPausedArgs represents the arguments for SetPaused in the Animation domain.

func NewAnimationSetPausedArgs 

func NewAnimationSetPausedArgs(animations []string, paused bool) *AnimationSetPausedArgs

NewAnimationSetPausedArgs initializes AnimationSetPausedArgs with the required arguments.

type AnimationSetPlaybackRateArgs 

type AnimationSetPlaybackRateArgs struct {
	PlaybackRate float64 `json:"playbackRate"` // Playback rate for animations on page
}

AnimationSetPlaybackRateArgs represents the arguments for SetPlaybackRate in the Animation domain.

func NewAnimationSetPlaybackRateArgs 

func NewAnimationSetPlaybackRateArgs(playbackRate float64) *AnimationSetPlaybackRateArgs

NewAnimationSetPlaybackRateArgs initializes AnimationSetPlaybackRateArgs with the required arguments.

type AnimationSetTimingArgs 

type AnimationSetTimingArgs struct {
	AnimationID string  `json:"animationId"` // Animation id.
	Duration    float64 `json:"duration"`    // Duration of the animation.
	Delay       float64 `json:"delay"`       // Delay of the animation.
}

AnimationSetTimingArgs represents the arguments for SetTiming in the Animation domain.

func NewAnimationSetTimingArgs 

func NewAnimationSetTimingArgs(animationID string, duration float64, delay float64) *AnimationSetTimingArgs

NewAnimationSetTimingArgs initializes AnimationSetTimingArgs with the required arguments.

type ApplicationCacheGetApplicationCacheForFrameArgs 

type ApplicationCacheGetApplicationCacheForFrameArgs struct {
	FrameID cdptype.PageFrameID `json:"frameId"` // Identifier of the frame containing document whose application cache is retrieved.
}

ApplicationCacheGetApplicationCacheForFrameArgs represents the arguments for GetApplicationCacheForFrame in the ApplicationCache domain.

func NewApplicationCacheGetApplicationCacheForFrameArgs 

func NewApplicationCacheGetApplicationCacheForFrameArgs(frameID cdptype.PageFrameID) *ApplicationCacheGetApplicationCacheForFrameArgs

NewApplicationCacheGetApplicationCacheForFrameArgs initializes ApplicationCacheGetApplicationCacheForFrameArgs with the required arguments.

type ApplicationCacheGetApplicationCacheForFrameReply 

type ApplicationCacheGetApplicationCacheForFrameReply struct {
	ApplicationCache cdptype.ApplicationCache `json:"applicationCache"` // Relevant application cache data for the document in given frame.
}

ApplicationCacheGetApplicationCacheForFrameReply represents the return values for GetApplicationCacheForFrame in the ApplicationCache domain.

type ApplicationCacheGetFramesWithManifestsReply 

type ApplicationCacheGetFramesWithManifestsReply struct {
	FrameIDs []cdptype.ApplicationCacheFrameWithManifest `json:"frameIds"` // Array of frame identifiers with manifest urls for each frame containing a document associated with some application cache.
}

ApplicationCacheGetFramesWithManifestsReply represents the return values for GetFramesWithManifests in the ApplicationCache domain.

type ApplicationCacheGetManifestForFrameArgs 

type ApplicationCacheGetManifestForFrameArgs struct {
	FrameID cdptype.PageFrameID `json:"frameId"` // Identifier of the frame containing document whose manifest is retrieved.
}

ApplicationCacheGetManifestForFrameArgs represents the arguments for GetManifestForFrame in the ApplicationCache domain.

func NewApplicationCacheGetManifestForFrameArgs 

func NewApplicationCacheGetManifestForFrameArgs(frameID cdptype.PageFrameID) *ApplicationCacheGetManifestForFrameArgs

NewApplicationCacheGetManifestForFrameArgs initializes ApplicationCacheGetManifestForFrameArgs with the required arguments.

type ApplicationCacheGetManifestForFrameReply 

type ApplicationCacheGetManifestForFrameReply struct {
	ManifestURL string `json:"manifestURL"` // Manifest URL for document in the given frame.
}

ApplicationCacheGetManifestForFrameReply represents the return values for GetManifestForFrame in the ApplicationCache domain.

type BrowserGetWindowBoundsArgs 

type BrowserGetWindowBoundsArgs struct {
	WindowID cdptype.BrowserWindowID `json:"windowId"` // Browser window id.
}

BrowserGetWindowBoundsArgs represents the arguments for GetWindowBounds in the Browser domain.

func NewBrowserGetWindowBoundsArgs 

func NewBrowserGetWindowBoundsArgs(windowID cdptype.BrowserWindowID) *BrowserGetWindowBoundsArgs

NewBrowserGetWindowBoundsArgs initializes BrowserGetWindowBoundsArgs with the required arguments.

type BrowserGetWindowBoundsReply 

type BrowserGetWindowBoundsReply struct {
	Bounds cdptype.BrowserBounds `json:"bounds"` // Bounds information of the window. When window state is 'minimized', the restored window position and size are returned.
}

BrowserGetWindowBoundsReply represents the return values for GetWindowBounds in the Browser domain.

type BrowserGetWindowForTargetArgs 

type BrowserGetWindowForTargetArgs struct {
	TargetID cdptype.TargetID `json:"targetId"` // Devtools agent host id.
}

BrowserGetWindowForTargetArgs represents the arguments for GetWindowForTarget in the Browser domain.

func NewBrowserGetWindowForTargetArgs 

func NewBrowserGetWindowForTargetArgs(targetID cdptype.TargetID) *BrowserGetWindowForTargetArgs

NewBrowserGetWindowForTargetArgs initializes BrowserGetWindowForTargetArgs with the required arguments.

type BrowserGetWindowForTargetReply 

type BrowserGetWindowForTargetReply struct {
	WindowID cdptype.BrowserWindowID `json:"windowId"` // Browser window id.
	Bounds   cdptype.BrowserBounds   `json:"bounds"`   // Bounds information of the window. When window state is 'minimized', the restored window position and size are returned.
}

BrowserGetWindowForTargetReply represents the return values for GetWindowForTarget in the Browser domain.

type BrowserSetWindowBoundsArgs 

type BrowserSetWindowBoundsArgs struct {
	WindowID cdptype.BrowserWindowID `json:"windowId"` // Browser window id.
	Bounds   cdptype.BrowserBounds   `json:"bounds"`   // New window bounds. The 'minimized', 'maximized' and 'fullscreen' states cannot be combined with 'left', 'top', 'width' or 'height'. Leaves unspecified fields unchanged.
}

BrowserSetWindowBoundsArgs represents the arguments for SetWindowBounds in the Browser domain.

func NewBrowserSetWindowBoundsArgs 

func NewBrowserSetWindowBoundsArgs(windowID cdptype.BrowserWindowID, bounds cdptype.BrowserBounds) *BrowserSetWindowBoundsArgs

NewBrowserSetWindowBoundsArgs initializes BrowserSetWindowBoundsArgs with the required arguments.

type CSSAddRuleArgs 

type CSSAddRuleArgs struct {
	StyleSheetID cdptype.CSSStyleSheetID `json:"styleSheetId"` // The css style sheet identifier where a new rule should be inserted.
	RuleText     string                  `json:"ruleText"`     // The text of a new rule.
	Location     cdptype.CSSSourceRange  `json:"location"`     // Text position of a new rule in the target style sheet.
}

CSSAddRuleArgs represents the arguments for AddRule in the CSS domain.

func NewCSSAddRuleArgs 

func NewCSSAddRuleArgs(styleSheetID cdptype.CSSStyleSheetID, ruleText string, location cdptype.CSSSourceRange) *CSSAddRuleArgs

NewCSSAddRuleArgs initializes CSSAddRuleArgs with the required arguments.

type CSSAddRuleReply 

type CSSAddRuleReply struct {
	Rule cdptype.CSSRule `json:"rule"` // The newly created rule.
}

CSSAddRuleReply represents the return values for AddRule in the CSS domain.

type CSSCollectClassNamesArgs 

type CSSCollectClassNamesArgs struct {
	StyleSheetID cdptype.CSSStyleSheetID `json:"styleSheetId"` //
}

CSSCollectClassNamesArgs represents the arguments for CollectClassNames in the CSS domain.

func NewCSSCollectClassNamesArgs 

func NewCSSCollectClassNamesArgs(styleSheetID cdptype.CSSStyleSheetID) *CSSCollectClassNamesArgs

NewCSSCollectClassNamesArgs initializes CSSCollectClassNamesArgs with the required arguments.

type CSSCollectClassNamesReply 

type CSSCollectClassNamesReply struct {
	ClassNames []string `json:"classNames"` // Class name list.
}

CSSCollectClassNamesReply represents the return values for CollectClassNames in the CSS domain.

type CSSCreateStyleSheetArgs 

type CSSCreateStyleSheetArgs struct {
	FrameID cdptype.PageFrameID `json:"frameId"` // Identifier of the frame where "via-inspector" stylesheet should be created.
}

CSSCreateStyleSheetArgs represents the arguments for CreateStyleSheet in the CSS domain.

func NewCSSCreateStyleSheetArgs 

func NewCSSCreateStyleSheetArgs(frameID cdptype.PageFrameID) *CSSCreateStyleSheetArgs

NewCSSCreateStyleSheetArgs initializes CSSCreateStyleSheetArgs with the required arguments.

type CSSCreateStyleSheetReply 

type CSSCreateStyleSheetReply struct {
	StyleSheetID cdptype.CSSStyleSheetID `json:"styleSheetId"` // Identifier of the created "via-inspector" stylesheet.
}

CSSCreateStyleSheetReply represents the return values for CreateStyleSheet in the CSS domain.

type CSSForcePseudoStateArgs 

type CSSForcePseudoStateArgs struct {
	NodeID              cdptype.DOMNodeID `json:"nodeId"`              // The element id for which to force the pseudo state.
	ForcedPseudoClasses []string          `json:"forcedPseudoClasses"` // Element pseudo classes to force when computing the element's style.
}

CSSForcePseudoStateArgs represents the arguments for ForcePseudoState in the CSS domain.

func NewCSSForcePseudoStateArgs 

func NewCSSForcePseudoStateArgs(nodeID cdptype.DOMNodeID, forcedPseudoClasses []string) *CSSForcePseudoStateArgs

NewCSSForcePseudoStateArgs initializes CSSForcePseudoStateArgs with the required arguments.

type CSSGetBackgroundColorsArgs 

type CSSGetBackgroundColorsArgs struct {
	NodeID cdptype.DOMNodeID `json:"nodeId"` // Id of the node to get background colors for.
}

CSSGetBackgroundColorsArgs represents the arguments for GetBackgroundColors in the CSS domain.

func NewCSSGetBackgroundColorsArgs 

func NewCSSGetBackgroundColorsArgs(nodeID cdptype.DOMNodeID) *CSSGetBackgroundColorsArgs

NewCSSGetBackgroundColorsArgs initializes CSSGetBackgroundColorsArgs with the required arguments.

type CSSGetBackgroundColorsReply 

type CSSGetBackgroundColorsReply struct {
	BackgroundColors []string `json:"backgroundColors,omitempty"` // The range of background colors behind this element, if it contains any visible text. If no visible text is present, this will be undefined. In the case of a flat background color, this will consist of simply that color. In the case of a gradient, this will consist of each of the color stops. For anything more complicated, this will be an empty array. Images will be ignored (as if the image had failed to load).
}

CSSGetBackgroundColorsReply represents the return values for GetBackgroundColors in the CSS domain.

type CSSGetComputedStyleForNodeArgs 

type CSSGetComputedStyleForNodeArgs struct {
	NodeID cdptype.DOMNodeID `json:"nodeId"` //
}

CSSGetComputedStyleForNodeArgs represents the arguments for GetComputedStyleForNode in the CSS domain.

func NewCSSGetComputedStyleForNodeArgs 

func NewCSSGetComputedStyleForNodeArgs(nodeID cdptype.DOMNodeID) *CSSGetComputedStyleForNodeArgs

NewCSSGetComputedStyleForNodeArgs initializes CSSGetComputedStyleForNodeArgs with the required arguments.

type CSSGetComputedStyleForNodeReply 

type CSSGetComputedStyleForNodeReply struct {
	ComputedStyle []cdptype.CSSComputedStyleProperty `json:"computedStyle"` // Computed style for the specified DOM node.
}

CSSGetComputedStyleForNodeReply represents the return values for GetComputedStyleForNode in the CSS domain.

type CSSGetInlineStylesForNodeArgs 

type CSSGetInlineStylesForNodeArgs struct {
	NodeID cdptype.DOMNodeID `json:"nodeId"` //
}

CSSGetInlineStylesForNodeArgs represents the arguments for GetInlineStylesForNode in the CSS domain.

func NewCSSGetInlineStylesForNodeArgs 

func NewCSSGetInlineStylesForNodeArgs(nodeID cdptype.DOMNodeID) *CSSGetInlineStylesForNodeArgs

NewCSSGetInlineStylesForNodeArgs initializes CSSGetInlineStylesForNodeArgs with the required arguments.

type CSSGetInlineStylesForNodeReply 

type CSSGetInlineStylesForNodeReply struct {
	InlineStyle     *cdptype.CSSStyle `json:"inlineStyle,omitempty"`     // Inline style for the specified DOM node.
	AttributesStyle *cdptype.CSSStyle `json:"attributesStyle,omitempty"` // Attribute-defined element style (e.g. resulting from "width=20 height=100%").
}

CSSGetInlineStylesForNodeReply represents the return values for GetInlineStylesForNode in the CSS domain.

type CSSGetMatchedStylesForNodeArgs 

type CSSGetMatchedStylesForNodeArgs struct {
	NodeID cdptype.DOMNodeID `json:"nodeId"` //
}

CSSGetMatchedStylesForNodeArgs represents the arguments for GetMatchedStylesForNode in the CSS domain.

func NewCSSGetMatchedStylesForNodeArgs 

func NewCSSGetMatchedStylesForNodeArgs(nodeID cdptype.DOMNodeID) *CSSGetMatchedStylesForNodeArgs

NewCSSGetMatchedStylesForNodeArgs initializes CSSGetMatchedStylesForNodeArgs with the required arguments.

type CSSGetMatchedStylesForNodeReply 

type CSSGetMatchedStylesForNodeReply struct {
	InlineStyle       *cdptype.CSSStyle                 `json:"inlineStyle,omitempty"`       // Inline style for the specified DOM node.
	AttributesStyle   *cdptype.CSSStyle                 `json:"attributesStyle,omitempty"`   // Attribute-defined element style (e.g. resulting from "width=20 height=100%").
	MatchedCSSRules   []cdptype.CSSRuleMatch            `json:"matchedCSSRules,omitempty"`   // CSS rules matching this node, from all applicable stylesheets.
	PseudoElements    []cdptype.CSSPseudoElementMatches `json:"pseudoElements,omitempty"`    // Pseudo style matches for this node.
	Inherited         []cdptype.CSSInheritedStyleEntry  `json:"inherited,omitempty"`         // A chain of inherited styles (from the immediate node parent up to the DOM tree root).
	CSSKeyframesRules []cdptype.CSSKeyframesRule        `json:"cssKeyframesRules,omitempty"` // A list of CSS keyframed animations matching this node.
}

CSSGetMatchedStylesForNodeReply represents the return values for GetMatchedStylesForNode in the CSS domain.

type CSSGetMediaQueriesReply 

type CSSGetMediaQueriesReply struct {
	Medias []cdptype.CSSMedia `json:"medias"` //
}

CSSGetMediaQueriesReply represents the return values for GetMediaQueries in the CSS domain.

type CSSGetPlatformFontsForNodeArgs 

type CSSGetPlatformFontsForNodeArgs struct {
	NodeID cdptype.DOMNodeID `json:"nodeId"` //
}

CSSGetPlatformFontsForNodeArgs represents the arguments for GetPlatformFontsForNode in the CSS domain.

func NewCSSGetPlatformFontsForNodeArgs 

func NewCSSGetPlatformFontsForNodeArgs(nodeID cdptype.DOMNodeID) *CSSGetPlatformFontsForNodeArgs

NewCSSGetPlatformFontsForNodeArgs initializes CSSGetPlatformFontsForNodeArgs with the required arguments.

type CSSGetPlatformFontsForNodeReply 

type CSSGetPlatformFontsForNodeReply struct {
	Fonts []cdptype.CSSPlatformFontUsage `json:"fonts"` // Usage statistics for every employed platform font.
}

CSSGetPlatformFontsForNodeReply represents the return values for GetPlatformFontsForNode in the CSS domain.

type CSSGetStyleSheetTextArgs 

type CSSGetStyleSheetTextArgs struct {
	StyleSheetID cdptype.CSSStyleSheetID `json:"styleSheetId"` //
}

CSSGetStyleSheetTextArgs represents the arguments for GetStyleSheetText in the CSS domain.

func NewCSSGetStyleSheetTextArgs 

func NewCSSGetStyleSheetTextArgs(styleSheetID cdptype.CSSStyleSheetID) *CSSGetStyleSheetTextArgs

NewCSSGetStyleSheetTextArgs initializes CSSGetStyleSheetTextArgs with the required arguments.

type CSSGetStyleSheetTextReply 

type CSSGetStyleSheetTextReply struct {
	Text string `json:"text"` // The stylesheet text.
}

CSSGetStyleSheetTextReply represents the return values for GetStyleSheetText in the CSS domain.

type CSSSetEffectivePropertyValueForNodeArgs 

type CSSSetEffectivePropertyValueForNodeArgs struct {
	NodeID       cdptype.DOMNodeID `json:"nodeId"`       // The element id for which to set property.
	PropertyName string            `json:"propertyName"` //
	Value        string            `json:"value"`        //
}

CSSSetEffectivePropertyValueForNodeArgs represents the arguments for SetEffectivePropertyValueForNode in the CSS domain.

func NewCSSSetEffectivePropertyValueForNodeArgs 

func NewCSSSetEffectivePropertyValueForNodeArgs(nodeID cdptype.DOMNodeID, propertyName string, value string) *CSSSetEffectivePropertyValueForNodeArgs

NewCSSSetEffectivePropertyValueForNodeArgs initializes CSSSetEffectivePropertyValueForNodeArgs with the required arguments.

type CSSSetKeyframeKeyArgs 

type CSSSetKeyframeKeyArgs struct {
	StyleSheetID cdptype.CSSStyleSheetID `json:"styleSheetId"` //
	Range        cdptype.CSSSourceRange  `json:"range"`        //
	KeyText      string                  `json:"keyText"`      //
}

CSSSetKeyframeKeyArgs represents the arguments for SetKeyframeKey in the CSS domain.

func NewCSSSetKeyframeKeyArgs 

func NewCSSSetKeyframeKeyArgs(styleSheetID cdptype.CSSStyleSheetID, rang cdptype.CSSSourceRange, keyText string) *CSSSetKeyframeKeyArgs

NewCSSSetKeyframeKeyArgs initializes CSSSetKeyframeKeyArgs with the required arguments.

type CSSSetKeyframeKeyReply 

type CSSSetKeyframeKeyReply struct {
	KeyText cdptype.CSSValue `json:"keyText"` // The resulting key text after modification.
}

CSSSetKeyframeKeyReply represents the return values for SetKeyframeKey in the CSS domain.

type CSSSetMediaTextArgs 

type CSSSetMediaTextArgs struct {
	StyleSheetID cdptype.CSSStyleSheetID `json:"styleSheetId"` //
	Range        cdptype.CSSSourceRange  `json:"range"`        //
	Text         string                  `json:"text"`         //
}

CSSSetMediaTextArgs represents the arguments for SetMediaText in the CSS domain.

func NewCSSSetMediaTextArgs 

func NewCSSSetMediaTextArgs(styleSheetID cdptype.CSSStyleSheetID, rang cdptype.CSSSourceRange, text string) *CSSSetMediaTextArgs

NewCSSSetMediaTextArgs initializes CSSSetMediaTextArgs with the required arguments.

type CSSSetMediaTextReply 

type CSSSetMediaTextReply struct {
	Media cdptype.CSSMedia `json:"media"` // The resulting CSS media rule after modification.
}

CSSSetMediaTextReply represents the return values for SetMediaText in the CSS domain.

type CSSSetRuleSelectorArgs 

type CSSSetRuleSelectorArgs struct {
	StyleSheetID cdptype.CSSStyleSheetID `json:"styleSheetId"` //
	Range        cdptype.CSSSourceRange  `json:"range"`        //
	Selector     string                  `json:"selector"`     //
}

CSSSetRuleSelectorArgs represents the arguments for SetRuleSelector in the CSS domain.

func NewCSSSetRuleSelectorArgs 

func NewCSSSetRuleSelectorArgs(styleSheetID cdptype.CSSStyleSheetID, rang cdptype.CSSSourceRange, selector string) *CSSSetRuleSelectorArgs

NewCSSSetRuleSelectorArgs initializes CSSSetRuleSelectorArgs with the required arguments.

type CSSSetRuleSelectorReply 

type CSSSetRuleSelectorReply struct {
	SelectorList cdptype.CSSSelectorList `json:"selectorList"` // The resulting selector list after modification.
}

CSSSetRuleSelectorReply represents the return values for SetRuleSelector in the CSS domain.

type CSSSetStyleSheetTextArgs 

type CSSSetStyleSheetTextArgs struct {
	StyleSheetID cdptype.CSSStyleSheetID `json:"styleSheetId"` //
	Text         string                  `json:"text"`         //
}

CSSSetStyleSheetTextArgs represents the arguments for SetStyleSheetText in the CSS domain.

func NewCSSSetStyleSheetTextArgs 

func NewCSSSetStyleSheetTextArgs(styleSheetID cdptype.CSSStyleSheetID, text string) *CSSSetStyleSheetTextArgs

NewCSSSetStyleSheetTextArgs initializes CSSSetStyleSheetTextArgs with the required arguments.

type CSSSetStyleSheetTextReply 

type CSSSetStyleSheetTextReply struct {
	SourceMapURL *string `json:"sourceMapURL,omitempty"` // URL of source map associated with script (if any).
}

CSSSetStyleSheetTextReply represents the return values for SetStyleSheetText in the CSS domain.

type CSSSetStyleTextsArgs 

type CSSSetStyleTextsArgs struct {
	Edits []cdptype.CSSStyleDeclarationEdit `json:"edits"` //
}

CSSSetStyleTextsArgs represents the arguments for SetStyleTexts in the CSS domain.

func NewCSSSetStyleTextsArgs 

func NewCSSSetStyleTextsArgs(edits []cdptype.CSSStyleDeclarationEdit) *CSSSetStyleTextsArgs

NewCSSSetStyleTextsArgs initializes CSSSetStyleTextsArgs with the required arguments.

type CSSSetStyleTextsReply 

type CSSSetStyleTextsReply struct {
	Styles []cdptype.CSSStyle `json:"styles"` // The resulting styles after modification.
}

CSSSetStyleTextsReply represents the return values for SetStyleTexts in the CSS domain.

type CSSStopRuleUsageTrackingReply 

type CSSStopRuleUsageTrackingReply struct {
	RuleUsage []cdptype.CSSRuleUsage `json:"ruleUsage"` //
}

CSSStopRuleUsageTrackingReply represents the return values for StopRuleUsageTracking in the CSS domain.

type CSSTakeCoverageDeltaReply 

type CSSTakeCoverageDeltaReply struct {
	Coverage []cdptype.CSSRuleUsage `json:"coverage"` //
}

CSSTakeCoverageDeltaReply represents the return values for TakeCoverageDelta in the CSS domain.

type CacheStorageDeleteCacheArgs 

type CacheStorageDeleteCacheArgs struct {
	CacheID cdptype.CacheStorageCacheID `json:"cacheId"` // Id of cache for deletion.
}

CacheStorageDeleteCacheArgs represents the arguments for DeleteCache in the CacheStorage domain.

func NewCacheStorageDeleteCacheArgs 

func NewCacheStorageDeleteCacheArgs(cacheID cdptype.CacheStorageCacheID) *CacheStorageDeleteCacheArgs

NewCacheStorageDeleteCacheArgs initializes CacheStorageDeleteCacheArgs with the required arguments.

type CacheStorageDeleteEntryArgs 

type CacheStorageDeleteEntryArgs struct {
	CacheID cdptype.CacheStorageCacheID `json:"cacheId"` // Id of cache where the entry will be deleted.
	Request string                      `json:"request"` // URL spec of the request.
}

CacheStorageDeleteEntryArgs represents the arguments for DeleteEntry in the CacheStorage domain.

func NewCacheStorageDeleteEntryArgs 

func NewCacheStorageDeleteEntryArgs(cacheID cdptype.CacheStorageCacheID, request string) *CacheStorageDeleteEntryArgs

NewCacheStorageDeleteEntryArgs initializes CacheStorageDeleteEntryArgs with the required arguments.

type CacheStorageRequestCacheNamesArgs 

type CacheStorageRequestCacheNamesArgs struct {
	SecurityOrigin string `json:"securityOrigin"` // Security origin.
}

CacheStorageRequestCacheNamesArgs represents the arguments for RequestCacheNames in the CacheStorage domain.

func NewCacheStorageRequestCacheNamesArgs 

func NewCacheStorageRequestCacheNamesArgs(securityOrigin string) *CacheStorageRequestCacheNamesArgs

NewCacheStorageRequestCacheNamesArgs initializes CacheStorageRequestCacheNamesArgs with the required arguments.

type CacheStorageRequestCacheNamesReply 

type CacheStorageRequestCacheNamesReply struct {
	Caches []cdptype.CacheStorageCache `json:"caches"` // Caches for the security origin.
}

CacheStorageRequestCacheNamesReply represents the return values for RequestCacheNames in the CacheStorage domain.

type CacheStorageRequestEntriesArgs 

type CacheStorageRequestEntriesArgs struct {
	CacheID   cdptype.CacheStorageCacheID `json:"cacheId"`   // ID of cache to get entries from.
	SkipCount int                         `json:"skipCount"` // Number of records to skip.
	PageSize  int                         `json:"pageSize"`  // Number of records to fetch.
}

CacheStorageRequestEntriesArgs represents the arguments for RequestEntries in the CacheStorage domain.

func NewCacheStorageRequestEntriesArgs 

func NewCacheStorageRequestEntriesArgs(cacheID cdptype.CacheStorageCacheID, skipCount int, pageSize int) *CacheStorageRequestEntriesArgs

NewCacheStorageRequestEntriesArgs initializes CacheStorageRequestEntriesArgs with the required arguments.

type CacheStorageRequestEntriesReply 

type CacheStorageRequestEntriesReply struct {
	CacheDataEntries []cdptype.CacheStorageDataEntry `json:"cacheDataEntries"` // Array of object store data entries.
	HasMore          bool                            `json:"hasMore"`          // If true, there are more entries to fetch in the given range.
}

CacheStorageRequestEntriesReply represents the return values for RequestEntries in the CacheStorage domain.

type CmdType 

type CmdType string

CmdType is the type for CDP methods names. 

const (
	AccessibilityGetPartialAXTree                   CmdType = "Accessibility.getPartialAXTree"
	AnimationEnable                                 CmdType = "Animation.enable"
	AnimationDisable                                CmdType = "Animation.disable"
	AnimationGetPlaybackRate                        CmdType = "Animation.getPlaybackRate"
	AnimationSetPlaybackRate                        CmdType = "Animation.setPlaybackRate"
	AnimationGetCurrentTime                         CmdType = "Animation.getCurrentTime"
	AnimationSetPaused                              CmdType = "Animation.setPaused"
	AnimationSetTiming                              CmdType = "Animation.setTiming"
	AnimationSeekAnimations                         CmdType = "Animation.seekAnimations"
	AnimationReleaseAnimations                      CmdType = "Animation.releaseAnimations"
	AnimationResolveAnimation                       CmdType = "Animation.resolveAnimation"
	ApplicationCacheGetFramesWithManifests          CmdType = "ApplicationCache.getFramesWithManifests"
	ApplicationCacheEnable                          CmdType = "ApplicationCache.enable"
	ApplicationCacheGetManifestForFrame             CmdType = "ApplicationCache.getManifestForFrame"
	ApplicationCacheGetApplicationCacheForFrame     CmdType = "ApplicationCache.getApplicationCacheForFrame"
	BrowserGetWindowForTarget                       CmdType = "Browser.getWindowForTarget"
	BrowserSetWindowBounds                          CmdType = "Browser.setWindowBounds"
	BrowserGetWindowBounds                          CmdType = "Browser.getWindowBounds"
	CSSEnable                                       CmdType = "CSS.enable"
	CSSDisable                                      CmdType = "CSS.disable"
	CSSGetMatchedStylesForNode                      CmdType = "CSS.getMatchedStylesForNode"
	CSSGetInlineStylesForNode                       CmdType = "CSS.getInlineStylesForNode"
	CSSGetComputedStyleForNode                      CmdType = "CSS.getComputedStyleForNode"
	CSSGetPlatformFontsForNode                      CmdType = "CSS.getPlatformFontsForNode"
	CSSGetStyleSheetText                            CmdType = "CSS.getStyleSheetText"
	CSSCollectClassNames                            CmdType = "CSS.collectClassNames"
	CSSSetStyleSheetText                            CmdType = "CSS.setStyleSheetText"
	CSSSetRuleSelector                              CmdType = "CSS.setRuleSelector"
	CSSSetKeyframeKey                               CmdType = "CSS.setKeyframeKey"
	CSSSetStyleTexts                                CmdType = "CSS.setStyleTexts"
	CSSSetMediaText                                 CmdType = "CSS.setMediaText"
	CSSCreateStyleSheet                             CmdType = "CSS.createStyleSheet"
	CSSAddRule                                      CmdType = "CSS.addRule"
	CSSForcePseudoState                             CmdType = "CSS.forcePseudoState"
	CSSGetMediaQueries                              CmdType = "CSS.getMediaQueries"
	CSSSetEffectivePropertyValueForNode             CmdType = "CSS.setEffectivePropertyValueForNode"
	CSSGetBackgroundColors                          CmdType = "CSS.getBackgroundColors"
	CSSStartRuleUsageTracking                       CmdType = "CSS.startRuleUsageTracking"
	CSSTakeCoverageDelta                            CmdType = "CSS.takeCoverageDelta"
	CSSStopRuleUsageTracking                        CmdType = "CSS.stopRuleUsageTracking"
	CacheStorageRequestCacheNames                   CmdType = "CacheStorage.requestCacheNames"
	CacheStorageRequestEntries                      CmdType = "CacheStorage.requestEntries"
	CacheStorageDeleteCache                         CmdType = "CacheStorage.deleteCache"
	CacheStorageDeleteEntry                         CmdType = "CacheStorage.deleteEntry"
	ConsoleEnable                                   CmdType = "Console.enable"
	ConsoleDisable                                  CmdType = "Console.disable"
	ConsoleClearMessages                            CmdType = "Console.clearMessages"
	DOMEnable                                       CmdType = "DOM.enable"
	DOMDisable                                      CmdType = "DOM.disable"
	DOMGetDocument                                  CmdType = "DOM.getDocument"
	DOMGetFlattenedDocument                         CmdType = "DOM.getFlattenedDocument"
	DOMCollectClassNamesFromSubtree                 CmdType = "DOM.collectClassNamesFromSubtree"
	DOMRequestChildNodes                            CmdType = "DOM.requestChildNodes"
	DOMQuerySelector                                CmdType = "DOM.querySelector"
	DOMQuerySelectorAll                             CmdType = "DOM.querySelectorAll"
	DOMSetNodeName                                  CmdType = "DOM.setNodeName"
	DOMSetNodeValue                                 CmdType = "DOM.setNodeValue"
	DOMRemoveNode                                   CmdType = "DOM.removeNode"
	DOMSetAttributeValue                            CmdType = "DOM.setAttributeValue"
	DOMSetAttributesAsText                          CmdType = "DOM.setAttributesAsText"
	DOMRemoveAttribute                              CmdType = "DOM.removeAttribute"
	DOMGetOuterHTML                                 CmdType = "DOM.getOuterHTML"
	DOMSetOuterHTML                                 CmdType = "DOM.setOuterHTML"
	DOMPerformSearch                                CmdType = "DOM.performSearch"
	DOMGetSearchResults                             CmdType = "DOM.getSearchResults"
	DOMDiscardSearchResults                         CmdType = "DOM.discardSearchResults"
	DOMRequestNode                                  CmdType = "DOM.requestNode"
	DOMHighlightRect                                CmdType = "DOM.highlightRect"
	DOMHighlightNode                                CmdType = "DOM.highlightNode"
	DOMHideHighlight                                CmdType = "DOM.hideHighlight"
	DOMPushNodeByPathToFrontend                     CmdType = "DOM.pushNodeByPathToFrontend"
	DOMPushNodesByBackendIdsToFrontend              CmdType = "DOM.pushNodesByBackendIdsToFrontend"
	DOMSetInspectedNode                             CmdType = "DOM.setInspectedNode"
	DOMResolveNode                                  CmdType = "DOM.resolveNode"
	DOMGetAttributes                                CmdType = "DOM.getAttributes"
	DOMCopyTo                                       CmdType = "DOM.copyTo"
	DOMMoveTo                                       CmdType = "DOM.moveTo"
	DOMUndo                                         CmdType = "DOM.undo"
	DOMRedo                                         CmdType = "DOM.redo"
	DOMMarkUndoableState                            CmdType = "DOM.markUndoableState"
	DOMFocus                                        CmdType = "DOM.focus"
	DOMSetFileInputFiles                            CmdType = "DOM.setFileInputFiles"
	DOMGetBoxModel                                  CmdType = "DOM.getBoxModel"
	DOMGetNodeForLocation                           CmdType = "DOM.getNodeForLocation"
	DOMGetRelayoutBoundary                          CmdType = "DOM.getRelayoutBoundary"
	DOMDebuggerSetDOMBreakpoint                     CmdType = "DOMDebugger.setDOMBreakpoint"
	DOMDebuggerRemoveDOMBreakpoint                  CmdType = "DOMDebugger.removeDOMBreakpoint"
	DOMDebuggerSetEventListenerBreakpoint           CmdType = "DOMDebugger.setEventListenerBreakpoint"
	DOMDebuggerRemoveEventListenerBreakpoint        CmdType = "DOMDebugger.removeEventListenerBreakpoint"
	DOMDebuggerSetInstrumentationBreakpoint         CmdType = "DOMDebugger.setInstrumentationBreakpoint"
	DOMDebuggerRemoveInstrumentationBreakpoint      CmdType = "DOMDebugger.removeInstrumentationBreakpoint"
	DOMDebuggerSetXHRBreakpoint                     CmdType = "DOMDebugger.setXHRBreakpoint"
	DOMDebuggerRemoveXHRBreakpoint                  CmdType = "DOMDebugger.removeXHRBreakpoint"
	DOMDebuggerGetEventListeners                    CmdType = "DOMDebugger.getEventListeners"
	DOMSnapshotGetSnapshot                          CmdType = "DOMSnapshot.getSnapshot"
	DOMStorageEnable                                CmdType = "DOMStorage.enable"
	DOMStorageDisable                               CmdType = "DOMStorage.disable"
	DOMStorageClear                                 CmdType = "DOMStorage.clear"
	DOMStorageGetDOMStorageItems                    CmdType = "DOMStorage.getDOMStorageItems"
	DOMStorageSetDOMStorageItem                     CmdType = "DOMStorage.setDOMStorageItem"
	DOMStorageRemoveDOMStorageItem                  CmdType = "DOMStorage.removeDOMStorageItem"
	DatabaseEnable                                  CmdType = "Database.enable"
	DatabaseDisable                                 CmdType = "Database.disable"
	DatabaseGetDatabaseTableNames                   CmdType = "Database.getDatabaseTableNames"
	DatabaseExecuteSQL                              CmdType = "Database.executeSQL"
	DebuggerEnable                                  CmdType = "Debugger.enable"
	DebuggerDisable                                 CmdType = "Debugger.disable"
	DebuggerSetBreakpointsActive                    CmdType = "Debugger.setBreakpointsActive"
	DebuggerSetSkipAllPauses                        CmdType = "Debugger.setSkipAllPauses"
	DebuggerSetBreakpointByURL                      CmdType = "Debugger.setBreakpointByUrl"
	DebuggerSetBreakpoint                           CmdType = "Debugger.setBreakpoint"
	DebuggerRemoveBreakpoint                        CmdType = "Debugger.removeBreakpoint"
	DebuggerGetPossibleBreakpoints                  CmdType = "Debugger.getPossibleBreakpoints"
	DebuggerContinueToLocation                      CmdType = "Debugger.continueToLocation"
	DebuggerStepOver                                CmdType = "Debugger.stepOver"
	DebuggerStepInto                                CmdType = "Debugger.stepInto"
	DebuggerStepOut                                 CmdType = "Debugger.stepOut"
	DebuggerPause                                   CmdType = "Debugger.pause"
	DebuggerScheduleStepIntoAsync                   CmdType = "Debugger.scheduleStepIntoAsync"
	DebuggerResume                                  CmdType = "Debugger.resume"
	DebuggerSearchInContent                         CmdType = "Debugger.searchInContent"
	DebuggerSetScriptSource                         CmdType = "Debugger.setScriptSource"
	DebuggerRestartFrame                            CmdType = "Debugger.restartFrame"
	DebuggerGetScriptSource                         CmdType = "Debugger.getScriptSource"
	DebuggerSetPauseOnExceptions                    CmdType = "Debugger.setPauseOnExceptions"
	DebuggerEvaluateOnCallFrame                     CmdType = "Debugger.evaluateOnCallFrame"
	DebuggerSetVariableValue                        CmdType = "Debugger.setVariableValue"
	DebuggerSetAsyncCallStackDepth                  CmdType = "Debugger.setAsyncCallStackDepth"
	DebuggerSetBlackboxPatterns                     CmdType = "Debugger.setBlackboxPatterns"
	DebuggerSetBlackboxedRanges                     CmdType = "Debugger.setBlackboxedRanges"
	DeviceOrientationSetDeviceOrientationOverride   CmdType = "DeviceOrientation.setDeviceOrientationOverride"
	DeviceOrientationClearDeviceOrientationOverride CmdType = "DeviceOrientation.clearDeviceOrientationOverride"
	EmulationSetDeviceMetricsOverride               CmdType = "Emulation.setDeviceMetricsOverride"
	EmulationClearDeviceMetricsOverride             CmdType = "Emulation.clearDeviceMetricsOverride"
	EmulationForceViewport                          CmdType = "Emulation.forceViewport"
	EmulationResetViewport                          CmdType = "Emulation.resetViewport"
	EmulationResetPageScaleFactor                   CmdType = "Emulation.resetPageScaleFactor"
	EmulationSetPageScaleFactor                     CmdType = "Emulation.setPageScaleFactor"
	EmulationSetVisibleSize                         CmdType = "Emulation.setVisibleSize"
	EmulationSetScriptExecutionDisabled             CmdType = "Emulation.setScriptExecutionDisabled"
	EmulationSetGeolocationOverride                 CmdType = "Emulation.setGeolocationOverride"
	EmulationClearGeolocationOverride               CmdType = "Emulation.clearGeolocationOverride"
	EmulationSetTouchEmulationEnabled               CmdType = "Emulation.setTouchEmulationEnabled"
	EmulationSetEmulatedMedia                       CmdType = "Emulation.setEmulatedMedia"
	EmulationSetCPUThrottlingRate                   CmdType = "Emulation.setCPUThrottlingRate"
	EmulationCanEmulate                             CmdType = "Emulation.canEmulate"
	EmulationSetVirtualTimePolicy                   CmdType = "Emulation.setVirtualTimePolicy"
	EmulationSetDefaultBackgroundColorOverride      CmdType = "Emulation.setDefaultBackgroundColorOverride"
	HeapProfilerEnable                              CmdType = "HeapProfiler.enable"
	HeapProfilerDisable                             CmdType = "HeapProfiler.disable"
	HeapProfilerStartTrackingHeapObjects            CmdType = "HeapProfiler.startTrackingHeapObjects"
	HeapProfilerStopTrackingHeapObjects             CmdType = "HeapProfiler.stopTrackingHeapObjects"
	HeapProfilerTakeHeapSnapshot                    CmdType = "HeapProfiler.takeHeapSnapshot"
	HeapProfilerCollectGarbage                      CmdType = "HeapProfiler.collectGarbage"
	HeapProfilerGetObjectByHeapObjectID             CmdType = "HeapProfiler.getObjectByHeapObjectId"
	HeapProfilerAddInspectedHeapObject              CmdType = "HeapProfiler.addInspectedHeapObject"
	HeapProfilerGetHeapObjectID                     CmdType = "HeapProfiler.getHeapObjectId"
	HeapProfilerStartSampling                       CmdType = "HeapProfiler.startSampling"
	HeapProfilerStopSampling                        CmdType = "HeapProfiler.stopSampling"
	IORead                                          CmdType = "IO.read"
	IOClose                                         CmdType = "IO.close"
	IndexedDBEnable                                 CmdType = "IndexedDB.enable"
	IndexedDBDisable                                CmdType = "IndexedDB.disable"
	IndexedDBRequestDatabaseNames                   CmdType = "IndexedDB.requestDatabaseNames"
	IndexedDBRequestDatabase                        CmdType = "IndexedDB.requestDatabase"
	IndexedDBRequestData                            CmdType = "IndexedDB.requestData"
	IndexedDBClearObjectStore                       CmdType = "IndexedDB.clearObjectStore"
	IndexedDBDeleteDatabase                         CmdType = "IndexedDB.deleteDatabase"
	InputSetIgnoreInputEvents                       CmdType = "Input.setIgnoreInputEvents"
	InputDispatchKeyEvent                           CmdType = "Input.dispatchKeyEvent"
	InputDispatchMouseEvent                         CmdType = "Input.dispatchMouseEvent"
	InputDispatchTouchEvent                         CmdType = "Input.dispatchTouchEvent"
	InputEmulateTouchFromMouseEvent                 CmdType = "Input.emulateTouchFromMouseEvent"
	InputSynthesizePinchGesture                     CmdType = "Input.synthesizePinchGesture"
	InputSynthesizeScrollGesture                    CmdType = "Input.synthesizeScrollGesture"
	InputSynthesizeTapGesture                       CmdType = "Input.synthesizeTapGesture"
	InspectorEnable                                 CmdType = "Inspector.enable"
	InspectorDisable                                CmdType = "Inspector.disable"
	LayerTreeEnable                                 CmdType = "LayerTree.enable"
	LayerTreeDisable                                CmdType = "LayerTree.disable"
	LayerTreeCompositingReasons                     CmdType = "LayerTree.compositingReasons"
	LayerTreeMakeSnapshot                           CmdType = "LayerTree.makeSnapshot"
	LayerTreeLoadSnapshot                           CmdType = "LayerTree.loadSnapshot"
	LayerTreeReleaseSnapshot                        CmdType = "LayerTree.releaseSnapshot"
	LayerTreeProfileSnapshot                        CmdType = "LayerTree.profileSnapshot"
	LayerTreeReplaySnapshot                         CmdType = "LayerTree.replaySnapshot"
	LayerTreeSnapshotCommandLog                     CmdType = "LayerTree.snapshotCommandLog"
	LogEnable                                       CmdType = "Log.enable"
	LogDisable                                      CmdType = "Log.disable"
	LogClear                                        CmdType = "Log.clear"
	LogStartViolationsReport                        CmdType = "Log.startViolationsReport"
	LogStopViolationsReport                         CmdType = "Log.stopViolationsReport"
	MemoryGetDOMCounters                            CmdType = "Memory.getDOMCounters"
	MemorySetPressureNotificationsSuppressed        CmdType = "Memory.setPressureNotificationsSuppressed"
	MemorySimulatePressureNotification              CmdType = "Memory.simulatePressureNotification"
	NetworkEnable                                   CmdType = "Network.enable"
	NetworkDisable                                  CmdType = "Network.disable"
	NetworkSetUserAgentOverride                     CmdType = "Network.setUserAgentOverride"
	NetworkSetExtraHTTPHeaders                      CmdType = "Network.setExtraHTTPHeaders"
	NetworkGetResponseBody                          CmdType = "Network.getResponseBody"
	NetworkSetBlockedURLs                           CmdType = "Network.setBlockedURLs"
	NetworkReplayXHR                                CmdType = "Network.replayXHR"
	NetworkCanClearBrowserCache                     CmdType = "Network.canClearBrowserCache"
	NetworkClearBrowserCache                        CmdType = "Network.clearBrowserCache"
	NetworkCanClearBrowserCookies                   CmdType = "Network.canClearBrowserCookies"
	NetworkClearBrowserCookies                      CmdType = "Network.clearBrowserCookies"
	NetworkGetCookies                               CmdType = "Network.getCookies"
	NetworkGetAllCookies                            CmdType = "Network.getAllCookies"
	NetworkDeleteCookie                             CmdType = "Network.deleteCookie"
	NetworkSetCookie                                CmdType = "Network.setCookie"
	NetworkCanEmulateNetworkConditions              CmdType = "Network.canEmulateNetworkConditions"
	NetworkEmulateNetworkConditions                 CmdType = "Network.emulateNetworkConditions"
	NetworkSetCacheDisabled                         CmdType = "Network.setCacheDisabled"
	NetworkSetBypassServiceWorker                   CmdType = "Network.setBypassServiceWorker"
	NetworkSetDataSizeLimitsForTest                 CmdType = "Network.setDataSizeLimitsForTest"
	NetworkGetCertificate                           CmdType = "Network.getCertificate"
	NetworkEnableRequestInterception                CmdType = "Network.enableRequestInterception"
	NetworkContinueInterceptedRequest               CmdType = "Network.continueInterceptedRequest"
	OverlayEnable                                   CmdType = "Overlay.enable"
	OverlayDisable                                  CmdType = "Overlay.disable"
	OverlaySetShowPaintRects                        CmdType = "Overlay.setShowPaintRects"
	OverlaySetShowDebugBorders                      CmdType = "Overlay.setShowDebugBorders"
	OverlaySetShowFPSCounter                        CmdType = "Overlay.setShowFPSCounter"
	OverlaySetShowScrollBottleneckRects             CmdType = "Overlay.setShowScrollBottleneckRects"
	OverlaySetShowViewportSizeOnResize              CmdType = "Overlay.setShowViewportSizeOnResize"
	OverlaySetPausedInDebuggerMessage               CmdType = "Overlay.setPausedInDebuggerMessage"
	OverlaySetSuspended                             CmdType = "Overlay.setSuspended"
	OverlaySetInspectMode                           CmdType = "Overlay.setInspectMode"
	OverlayHighlightRect                            CmdType = "Overlay.highlightRect"
	OverlayHighlightQuad                            CmdType = "Overlay.highlightQuad"
	OverlayHighlightNode                            CmdType = "Overlay.highlightNode"
	OverlayHighlightFrame                           CmdType = "Overlay.highlightFrame"
	OverlayHideHighlight                            CmdType = "Overlay.hideHighlight"
	OverlayGetHighlightObjectForTest                CmdType = "Overlay.getHighlightObjectForTest"
	PageEnable                                      CmdType = "Page.enable"
	PageDisable                                     CmdType = "Page.disable"
	PageAddScriptToEvaluateOnLoad                   CmdType = "Page.addScriptToEvaluateOnLoad"
	PageRemoveScriptToEvaluateOnLoad                CmdType = "Page.removeScriptToEvaluateOnLoad"
	PageSetAutoAttachToCreatedPages                 CmdType = "Page.setAutoAttachToCreatedPages"
	PageReload                                      CmdType = "Page.reload"
	PageNavigate                                    CmdType = "Page.navigate"
	PageStopLoading                                 CmdType = "Page.stopLoading"
	PageGetNavigationHistory                        CmdType = "Page.getNavigationHistory"
	PageNavigateToHistoryEntry                      CmdType = "Page.navigateToHistoryEntry"
	PageGetCookies                                  CmdType = "Page.getCookies"
	PageDeleteCookie                                CmdType = "Page.deleteCookie"
	PageGetResourceTree                             CmdType = "Page.getResourceTree"
	PageGetResourceContent                          CmdType = "Page.getResourceContent"
	PageSearchInResource                            CmdType = "Page.searchInResource"
	PageSetDocumentContent                          CmdType = "Page.setDocumentContent"
	PageSetDeviceMetricsOverride                    CmdType = "Page.setDeviceMetricsOverride"
	PageClearDeviceMetricsOverride                  CmdType = "Page.clearDeviceMetricsOverride"
	PageSetGeolocationOverride                      CmdType = "Page.setGeolocationOverride"
	PageClearGeolocationOverride                    CmdType = "Page.clearGeolocationOverride"
	PageSetDeviceOrientationOverride                CmdType = "Page.setDeviceOrientationOverride"
	PageClearDeviceOrientationOverride              CmdType = "Page.clearDeviceOrientationOverride"
	PageSetTouchEmulationEnabled                    CmdType = "Page.setTouchEmulationEnabled"
	PageCaptureScreenshot                           CmdType = "Page.captureScreenshot"
	PagePrintToPDF                                  CmdType = "Page.printToPDF"
	PageStartScreencast                             CmdType = "Page.startScreencast"
	PageStopScreencast                              CmdType = "Page.stopScreencast"
	PageScreencastFrameAck                          CmdType = "Page.screencastFrameAck"
	PageHandleJavaScriptDialog                      CmdType = "Page.handleJavaScriptDialog"
	PageGetAppManifest                              CmdType = "Page.getAppManifest"
	PageRequestAppBanner                            CmdType = "Page.requestAppBanner"
	PageSetControlNavigations                       CmdType = "Page.setControlNavigations"
	PageProcessNavigation                           CmdType = "Page.processNavigation"
	PageGetLayoutMetrics                            CmdType = "Page.getLayoutMetrics"
	PageCreateIsolatedWorld                         CmdType = "Page.createIsolatedWorld"
	ProfilerEnable                                  CmdType = "Profiler.enable"
	ProfilerDisable                                 CmdType = "Profiler.disable"
	ProfilerSetSamplingInterval                     CmdType = "Profiler.setSamplingInterval"
	ProfilerStart                                   CmdType = "Profiler.start"
	ProfilerStop                                    CmdType = "Profiler.stop"
	ProfilerStartPreciseCoverage                    CmdType = "Profiler.startPreciseCoverage"
	ProfilerStopPreciseCoverage                     CmdType = "Profiler.stopPreciseCoverage"
	ProfilerTakePreciseCoverage                     CmdType = "Profiler.takePreciseCoverage"
	ProfilerGetBestEffortCoverage                   CmdType = "Profiler.getBestEffortCoverage"
	RuntimeEvaluate                                 CmdType = "Runtime.evaluate"
	RuntimeAwaitPromise                             CmdType = "Runtime.awaitPromise"
	RuntimeCallFunctionOn                           CmdType = "Runtime.callFunctionOn"
	RuntimeGetProperties                            CmdType = "Runtime.getProperties"
	RuntimeReleaseObject                            CmdType = "Runtime.releaseObject"
	RuntimeReleaseObjectGroup                       CmdType = "Runtime.releaseObjectGroup"
	RuntimeRunIfWaitingForDebugger                  CmdType = "Runtime.runIfWaitingForDebugger"
	RuntimeEnable                                   CmdType = "Runtime.enable"
	RuntimeDisable                                  CmdType = "Runtime.disable"
	RuntimeDiscardConsoleEntries                    CmdType = "Runtime.discardConsoleEntries"
	RuntimeSetCustomObjectFormatterEnabled          CmdType = "Runtime.setCustomObjectFormatterEnabled"
	RuntimeCompileScript                            CmdType = "Runtime.compileScript"
	RuntimeRunScript                                CmdType = "Runtime.runScript"
	SchemaGetDomains                                CmdType = "Schema.getDomains"
	SecurityEnable                                  CmdType = "Security.enable"
	SecurityDisable                                 CmdType = "Security.disable"
	SecurityShowCertificateViewer                   CmdType = "Security.showCertificateViewer"
	SecurityHandleCertificateError                  CmdType = "Security.handleCertificateError"
	SecuritySetOverrideCertificateErrors            CmdType = "Security.setOverrideCertificateErrors"
	ServiceWorkerEnable                             CmdType = "ServiceWorker.enable"
	ServiceWorkerDisable                            CmdType = "ServiceWorker.disable"
	ServiceWorkerUnregister                         CmdType = "ServiceWorker.unregister"
	ServiceWorkerUpdateRegistration                 CmdType = "ServiceWorker.updateRegistration"
	ServiceWorkerStartWorker                        CmdType = "ServiceWorker.startWorker"
	ServiceWorkerSkipWaiting                        CmdType = "ServiceWorker.skipWaiting"
	ServiceWorkerStopWorker                         CmdType = "ServiceWorker.stopWorker"
	ServiceWorkerInspectWorker                      CmdType = "ServiceWorker.inspectWorker"
	ServiceWorkerSetForceUpdateOnPageLoad           CmdType = "ServiceWorker.setForceUpdateOnPageLoad"
	ServiceWorkerDeliverPushMessage                 CmdType = "ServiceWorker.deliverPushMessage"
	ServiceWorkerDispatchSyncEvent                  CmdType = "ServiceWorker.dispatchSyncEvent"
	StorageClearDataForOrigin                       CmdType = "Storage.clearDataForOrigin"
	StorageGetUsageAndQuota                         CmdType = "Storage.getUsageAndQuota"
	SystemInfoGetInfo                               CmdType = "SystemInfo.getInfo"
	TargetSetDiscoverTargets                        CmdType = "Target.setDiscoverTargets"
	TargetSetAutoAttach                             CmdType = "Target.setAutoAttach"
	TargetSetAttachToFrames                         CmdType = "Target.setAttachToFrames"
	TargetSetRemoteLocations                        CmdType = "Target.setRemoteLocations"
	TargetSendMessageToTarget                       CmdType = "Target.sendMessageToTarget"
	TargetGetTargetInfo                             CmdType = "Target.getTargetInfo"
	TargetActivateTarget                            CmdType = "Target.activateTarget"
	TargetCloseTarget                               CmdType = "Target.closeTarget"
	TargetAttachToTarget                            CmdType = "Target.attachToTarget"
	TargetDetachFromTarget                          CmdType = "Target.detachFromTarget"
	TargetCreateBrowserContext                      CmdType = "Target.createBrowserContext"
	TargetDisposeBrowserContext                     CmdType = "Target.disposeBrowserContext"
	TargetCreateTarget                              CmdType = "Target.createTarget"
	TargetGetTargets                                CmdType = "Target.getTargets"
	TetheringBind                                   CmdType = "Tethering.bind"
	TetheringUnbind                                 CmdType = "Tethering.unbind"
	TracingStart                                    CmdType = "Tracing.start"
	TracingEnd                                      CmdType = "Tracing.end"
	TracingGetCategories                            CmdType = "Tracing.getCategories"
	TracingRequestMemoryDump                        CmdType = "Tracing.requestMemoryDump"
	TracingRecordClockSyncMarker                    CmdType = "Tracing.recordClockSyncMarker"
)

Cmd methods.

func (CmdType) String 

func (c CmdType) String() string

type DOMCollectClassNamesFromSubtreeArgs 

type DOMCollectClassNamesFromSubtreeArgs struct {
	NodeID cdptype.DOMNodeID `json:"nodeId"` // Id of the node to collect class names.
}

DOMCollectClassNamesFromSubtreeArgs represents the arguments for CollectClassNamesFromSubtree in the DOM domain.

func NewDOMCollectClassNamesFromSubtreeArgs 

func NewDOMCollectClassNamesFromSubtreeArgs(nodeID cdptype.DOMNodeID) *DOMCollectClassNamesFromSubtreeArgs

NewDOMCollectClassNamesFromSubtreeArgs initializes DOMCollectClassNamesFromSubtreeArgs with the required arguments.

type DOMCollectClassNamesFromSubtreeReply 

type DOMCollectClassNamesFromSubtreeReply struct {
	ClassNames []string `json:"classNames"` // Class name list.
}

DOMCollectClassNamesFromSubtreeReply represents the return values for CollectClassNamesFromSubtree in the DOM domain.

type DOMCopyToArgs 

type DOMCopyToArgs struct {
	NodeID             cdptype.DOMNodeID  `json:"nodeId"`                       // Id of the node to copy.
	TargetNodeID       cdptype.DOMNodeID  `json:"targetNodeId"`                 // Id of the element to drop the copy into.
	InsertBeforeNodeID *cdptype.DOMNodeID `json:"insertBeforeNodeId,omitempty"` // Drop the copy before this node (if absent, the copy becomes the last child of targetNodeId).
}

DOMCopyToArgs represents the arguments for CopyTo in the DOM domain.

func NewDOMCopyToArgs 

func NewDOMCopyToArgs(nodeID cdptype.DOMNodeID, targetNodeID cdptype.DOMNodeID) *DOMCopyToArgs

NewDOMCopyToArgs initializes DOMCopyToArgs with the required arguments.

func (*DOMCopyToArgs) SetInsertBeforeNodeID 

func (a *DOMCopyToArgs) SetInsertBeforeNodeID(insertBeforeNodeID cdptype.DOMNodeID) *DOMCopyToArgs

SetInsertBeforeNodeID sets the InsertBeforeNodeID optional argument. Drop the copy before this node (if absent, the copy becomes the last child of targetNodeId).

type DOMCopyToReply 

type DOMCopyToReply struct {
	NodeID cdptype.DOMNodeID `json:"nodeId"` // Id of the node clone.
}

DOMCopyToReply represents the return values for CopyTo in the DOM domain.

type DOMDebuggerGetEventListenersArgs 

type DOMDebuggerGetEventListenersArgs struct {
	ObjectID cdptype.RuntimeRemoteObjectID `json:"objectId"`         // Identifier of the object to return listeners for.
	Depth    *int                          `json:"depth,omitempty"`  // 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.
	Pierce   *bool                         `json:"pierce,omitempty"` // Whether or not iframes and shadow roots should be traversed when returning the subtree (default is false). Reports listeners for all contexts if pierce is enabled.
}

DOMDebuggerGetEventListenersArgs represents the arguments for GetEventListeners in the DOMDebugger domain.

func NewDOMDebuggerGetEventListenersArgs 

func NewDOMDebuggerGetEventListenersArgs(objectID cdptype.RuntimeRemoteObjectID) *DOMDebuggerGetEventListenersArgs

NewDOMDebuggerGetEventListenersArgs initializes DOMDebuggerGetEventListenersArgs with the required arguments.

func (*DOMDebuggerGetEventListenersArgs) SetDepth 

func (a *DOMDebuggerGetEventListenersArgs) SetDepth(depth int) *DOMDebuggerGetEventListenersArgs

SetDepth sets the Depth optional argument. 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 (*DOMDebuggerGetEventListenersArgs) SetPierce 

func (a *DOMDebuggerGetEventListenersArgs) SetPierce(pierce bool) *DOMDebuggerGetEventListenersArgs

SetPierce sets the Pierce optional argument. Whether or not iframes and shadow roots should be traversed when returning the subtree (default is false). Reports listeners for all contexts if pierce is enabled.

type DOMDebuggerGetEventListenersReply 

type DOMDebuggerGetEventListenersReply struct {
	Listeners []cdptype.DOMDebuggerEventListener `json:"listeners"` // Array of relevant listeners.
}

DOMDebuggerGetEventListenersReply represents the return values for GetEventListeners in the DOMDebugger domain.

type DOMDebuggerRemoveDOMBreakpointArgs 

type DOMDebuggerRemoveDOMBreakpointArgs struct {
	NodeID cdptype.DOMNodeID                    `json:"nodeId"` // Identifier of the node to remove breakpoint from.
	Type   cdptype.DOMDebuggerDOMBreakpointType `json:"type"`   // Type of the breakpoint to remove.
}

DOMDebuggerRemoveDOMBreakpointArgs represents the arguments for RemoveDOMBreakpoint in the DOMDebugger domain.

func NewDOMDebuggerRemoveDOMBreakpointArgs 

func NewDOMDebuggerRemoveDOMBreakpointArgs(nodeID cdptype.DOMNodeID, typ cdptype.DOMDebuggerDOMBreakpointType) *DOMDebuggerRemoveDOMBreakpointArgs

NewDOMDebuggerRemoveDOMBreakpointArgs initializes DOMDebuggerRemoveDOMBreakpointArgs with the required arguments.

type DOMDebuggerRemoveEventListenerBreakpointArgs 

type DOMDebuggerRemoveEventListenerBreakpointArgs struct {
	EventName  string  `json:"eventName"`            // Event name.
	TargetName *string `json:"targetName,omitempty"` // EventTarget interface name.
}

DOMDebuggerRemoveEventListenerBreakpointArgs represents the arguments for RemoveEventListenerBreakpoint in the DOMDebugger domain.

func NewDOMDebuggerRemoveEventListenerBreakpointArgs 

func NewDOMDebuggerRemoveEventListenerBreakpointArgs(eventName string) *DOMDebuggerRemoveEventListenerBreakpointArgs

NewDOMDebuggerRemoveEventListenerBreakpointArgs initializes DOMDebuggerRemoveEventListenerBreakpointArgs with the required arguments.

func (*DOMDebuggerRemoveEventListenerBreakpointArgs) SetTargetName 

func (a *DOMDebuggerRemoveEventListenerBreakpointArgs) SetTargetName(targetName string) *DOMDebuggerRemoveEventListenerBreakpointArgs

SetTargetName sets the TargetName optional argument. EventTarget interface name.

type DOMDebuggerRemoveInstrumentationBreakpointArgs 

type DOMDebuggerRemoveInstrumentationBreakpointArgs struct {
	EventName string `json:"eventName"` // Instrumentation name to stop on.
}

DOMDebuggerRemoveInstrumentationBreakpointArgs represents the arguments for RemoveInstrumentationBreakpoint in the DOMDebugger domain.

func NewDOMDebuggerRemoveInstrumentationBreakpointArgs 

func NewDOMDebuggerRemoveInstrumentationBreakpointArgs(eventName string) *DOMDebuggerRemoveInstrumentationBreakpointArgs

NewDOMDebuggerRemoveInstrumentationBreakpointArgs initializes DOMDebuggerRemoveInstrumentationBreakpointArgs with the required arguments.

type DOMDebuggerRemoveXHRBreakpointArgs 

type DOMDebuggerRemoveXHRBreakpointArgs struct {
	URL string `json:"url"` // Resource URL substring.
}

DOMDebuggerRemoveXHRBreakpointArgs represents the arguments for RemoveXHRBreakpoint in the DOMDebugger domain.

func NewDOMDebuggerRemoveXHRBreakpointArgs 

func NewDOMDebuggerRemoveXHRBreakpointArgs(url string) *DOMDebuggerRemoveXHRBreakpointArgs

NewDOMDebuggerRemoveXHRBreakpointArgs initializes DOMDebuggerRemoveXHRBreakpointArgs with the required arguments.

type DOMDebuggerSetDOMBreakpointArgs 

type DOMDebuggerSetDOMBreakpointArgs struct {
	NodeID cdptype.DOMNodeID                    `json:"nodeId"` // Identifier of the node to set breakpoint on.
	Type   cdptype.DOMDebuggerDOMBreakpointType `json:"type"`   // Type of the operation to stop upon.
}

DOMDebuggerSetDOMBreakpointArgs represents the arguments for SetDOMBreakpoint in the DOMDebugger domain.

func NewDOMDebuggerSetDOMBreakpointArgs 

func NewDOMDebuggerSetDOMBreakpointArgs(nodeID cdptype.DOMNodeID, typ cdptype.DOMDebuggerDOMBreakpointType) *DOMDebuggerSetDOMBreakpointArgs

NewDOMDebuggerSetDOMBreakpointArgs initializes DOMDebuggerSetDOMBreakpointArgs with the required arguments.

type DOMDebuggerSetEventListenerBreakpointArgs 

type DOMDebuggerSetEventListenerBreakpointArgs struct {
	EventName  string  `json:"eventName"`            // DOM Event name to stop on (any DOM event will do).
	TargetName *string `json:"targetName,omitempty"` // EventTarget interface name to stop on. If equal to "*" or not provided, will stop on any EventTarget.
}

DOMDebuggerSetEventListenerBreakpointArgs represents the arguments for SetEventListenerBreakpoint in the DOMDebugger domain.

func NewDOMDebuggerSetEventListenerBreakpointArgs 

func NewDOMDebuggerSetEventListenerBreakpointArgs(eventName string) *DOMDebuggerSetEventListenerBreakpointArgs

NewDOMDebuggerSetEventListenerBreakpointArgs initializes DOMDebuggerSetEventListenerBreakpointArgs with the required arguments.

func (*DOMDebuggerSetEventListenerBreakpointArgs) SetTargetName 

func (a *DOMDebuggerSetEventListenerBreakpointArgs) SetTargetName(targetName string) *DOMDebuggerSetEventListenerBreakpointArgs

SetTargetName sets the TargetName optional argument. EventTarget interface name to stop on. If equal to "*" or not provided, will stop on any EventTarget.

type DOMDebuggerSetInstrumentationBreakpointArgs 

type DOMDebuggerSetInstrumentationBreakpointArgs struct {
	EventName string `json:"eventName"` // Instrumentation name to stop on.
}

DOMDebuggerSetInstrumentationBreakpointArgs represents the arguments for SetInstrumentationBreakpoint in the DOMDebugger domain.

func NewDOMDebuggerSetInstrumentationBreakpointArgs 

func NewDOMDebuggerSetInstrumentationBreakpointArgs(eventName string) *DOMDebuggerSetInstrumentationBreakpointArgs

NewDOMDebuggerSetInstrumentationBreakpointArgs initializes DOMDebuggerSetInstrumentationBreakpointArgs with the required arguments.

type DOMDebuggerSetXHRBreakpointArgs 

type DOMDebuggerSetXHRBreakpointArgs struct {
	URL string `json:"url"` // Resource URL substring. All XHRs having this substring in the URL will get stopped upon.
}

DOMDebuggerSetXHRBreakpointArgs represents the arguments for SetXHRBreakpoint in the DOMDebugger domain.

func NewDOMDebuggerSetXHRBreakpointArgs 

func NewDOMDebuggerSetXHRBreakpointArgs(url string) *DOMDebuggerSetXHRBreakpointArgs

NewDOMDebuggerSetXHRBreakpointArgs initializes DOMDebuggerSetXHRBreakpointArgs with the required arguments.

type DOMDiscardSearchResultsArgs 

type DOMDiscardSearchResultsArgs struct {
	SearchID string `json:"searchId"` // Unique search session identifier.
}

DOMDiscardSearchResultsArgs represents the arguments for DiscardSearchResults in the DOM domain.

func NewDOMDiscardSearchResultsArgs 

func NewDOMDiscardSearchResultsArgs(searchID string) *DOMDiscardSearchResultsArgs

NewDOMDiscardSearchResultsArgs initializes DOMDiscardSearchResultsArgs with the required arguments.

type DOMFocusArgs 

type DOMFocusArgs struct {
	NodeID cdptype.DOMNodeID `json:"nodeId"` // Id of the node to focus.
}

DOMFocusArgs represents the arguments for Focus in the DOM domain.

func NewDOMFocusArgs 

func NewDOMFocusArgs(nodeID cdptype.DOMNodeID) *DOMFocusArgs

NewDOMFocusArgs initializes DOMFocusArgs with the required arguments.

type DOMGetAttributesArgs 

type DOMGetAttributesArgs struct {
	NodeID cdptype.DOMNodeID `json:"nodeId"` // Id of the node to retrieve attibutes for.
}

DOMGetAttributesArgs represents the arguments for GetAttributes in the DOM domain.

func NewDOMGetAttributesArgs 

func NewDOMGetAttributesArgs(nodeID cdptype.DOMNodeID) *DOMGetAttributesArgs

NewDOMGetAttributesArgs initializes DOMGetAttributesArgs with the required arguments.

type DOMGetAttributesReply 

type DOMGetAttributesReply struct {
	Attributes []string `json:"attributes"` // An interleaved array of node attribute names and values.
}

DOMGetAttributesReply represents the return values for GetAttributes in the DOM domain.

type DOMGetBoxModelArgs 

type DOMGetBoxModelArgs struct {
	NodeID cdptype.DOMNodeID `json:"nodeId"` // Id of the node to get box model for.
}

DOMGetBoxModelArgs represents the arguments for GetBoxModel in the DOM domain.

func NewDOMGetBoxModelArgs 

func NewDOMGetBoxModelArgs(nodeID cdptype.DOMNodeID) *DOMGetBoxModelArgs

NewDOMGetBoxModelArgs initializes DOMGetBoxModelArgs with the required arguments.

type DOMGetBoxModelReply 

type DOMGetBoxModelReply struct {
	Model cdptype.DOMBoxModel `json:"model"` // Box model for the node.
}

DOMGetBoxModelReply represents the return values for GetBoxModel in the DOM domain.

type DOMGetDocumentArgs 

type DOMGetDocumentArgs struct {
	Depth  *int  `json:"depth,omitempty"`  // The maximum depth at which children should be retrieved, defaults to 1. Use -1 for the entire subtree or provide an integer larger than 0.
	Pierce *bool `json:"pierce,omitempty"` // Whether or not iframes and shadow roots should be traversed when returning the subtree (default is false).
}

DOMGetDocumentArgs represents the arguments for GetDocument in the DOM domain.

func NewDOMGetDocumentArgs 

func NewDOMGetDocumentArgs() *DOMGetDocumentArgs

NewDOMGetDocumentArgs initializes DOMGetDocumentArgs with the required arguments.

func (*DOMGetDocumentArgs) SetDepth 

func (a *DOMGetDocumentArgs) SetDepth(depth int) *DOMGetDocumentArgs

SetDepth sets the Depth optional argument. The maximum depth at which children should be retrieved, defaults to 1. Use -1 for the entire subtree or provide an integer larger than 0.

func (*DOMGetDocumentArgs) SetPierce 

func (a *DOMGetDocumentArgs) SetPierce(pierce bool) *DOMGetDocumentArgs

SetPierce sets the Pierce optional argument. Whether or not iframes and shadow roots should be traversed when returning the subtree (default is false).

type DOMGetDocumentReply 

type DOMGetDocumentReply struct {
	Root cdptype.DOMNode `json:"root"` // Resulting node.
}

DOMGetDocumentReply represents the return values for GetDocument in the DOM domain.

type DOMGetFlattenedDocumentArgs 

type DOMGetFlattenedDocumentArgs struct {
	Depth  *int  `json:"depth,omitempty"`  // The maximum depth at which children should be retrieved, defaults to 1. Use -1 for the entire subtree or provide an integer larger than 0.
	Pierce *bool `json:"pierce,omitempty"` // Whether or not iframes and shadow roots should be traversed when returning the subtree (default is false).
}

DOMGetFlattenedDocumentArgs represents the arguments for GetFlattenedDocument in the DOM domain.

func NewDOMGetFlattenedDocumentArgs 

func NewDOMGetFlattenedDocumentArgs() *DOMGetFlattenedDocumentArgs

NewDOMGetFlattenedDocumentArgs initializes DOMGetFlattenedDocumentArgs with the required arguments.

func (*DOMGetFlattenedDocumentArgs) SetDepth 

func (a *DOMGetFlattenedDocumentArgs) SetDepth(depth int) *DOMGetFlattenedDocumentArgs

SetDepth sets the Depth optional argument. The maximum depth at which children should be retrieved, defaults to 1. Use -1 for the entire subtree or provide an integer larger than 0.

func (*DOMGetFlattenedDocumentArgs) SetPierce 

func (a *DOMGetFlattenedDocumentArgs) SetPierce(pierce bool) *DOMGetFlattenedDocumentArgs

SetPierce sets the Pierce optional argument. Whether or not iframes and shadow roots should be traversed when returning the subtree (default is false).

type DOMGetFlattenedDocumentReply 

type DOMGetFlattenedDocumentReply struct {
	Nodes []cdptype.DOMNode `json:"nodes"` // Resulting node.
}

DOMGetFlattenedDocumentReply represents the return values for GetFlattenedDocument in the DOM domain.

type DOMGetNodeForLocationArgs 

type DOMGetNodeForLocationArgs struct {
	X                         int   `json:"x"`                                   // X coordinate.
	Y                         int   `json:"y"`                                   // Y coordinate.
	IncludeUserAgentShadowDOM *bool `json:"includeUserAgentShadowDOM,omitempty"` // False to skip to the nearest non-UA shadow root ancestor (default: false).
}

DOMGetNodeForLocationArgs represents the arguments for GetNodeForLocation in the DOM domain.

func NewDOMGetNodeForLocationArgs 

func NewDOMGetNodeForLocationArgs(x int, y int) *DOMGetNodeForLocationArgs

NewDOMGetNodeForLocationArgs initializes DOMGetNodeForLocationArgs with the required arguments.

func (*DOMGetNodeForLocationArgs) SetIncludeUserAgentShadowDOM 

func (a *DOMGetNodeForLocationArgs) SetIncludeUserAgentShadowDOM(includeUserAgentShadowDOM bool) *DOMGetNodeForLocationArgs

SetIncludeUserAgentShadowDOM sets the IncludeUserAgentShadowDOM optional argument. False to skip to the nearest non-UA shadow root ancestor (default: false).

type DOMGetNodeForLocationReply 

type DOMGetNodeForLocationReply struct {
	NodeID cdptype.DOMNodeID `json:"nodeId"` // Id of the node at given coordinates.
}

DOMGetNodeForLocationReply represents the return values for GetNodeForLocation in the DOM domain.

type DOMGetOuterHTMLArgs 

type DOMGetOuterHTMLArgs struct {
	NodeID cdptype.DOMNodeID `json:"nodeId"` // Id of the node to get markup for.
}

DOMGetOuterHTMLArgs represents the arguments for GetOuterHTML in the DOM domain.

func NewDOMGetOuterHTMLArgs 

func NewDOMGetOuterHTMLArgs(nodeID cdptype.DOMNodeID) *DOMGetOuterHTMLArgs

NewDOMGetOuterHTMLArgs initializes DOMGetOuterHTMLArgs with the required arguments.

type DOMGetOuterHTMLReply 

type DOMGetOuterHTMLReply struct {
	OuterHTML string `json:"outerHTML"` // Outer HTML markup.
}

DOMGetOuterHTMLReply represents the return values for GetOuterHTML in the DOM domain.

type DOMGetRelayoutBoundaryArgs 

type DOMGetRelayoutBoundaryArgs struct {
	NodeID cdptype.DOMNodeID `json:"nodeId"` // Id of the node.
}

DOMGetRelayoutBoundaryArgs represents the arguments for GetRelayoutBoundary in the DOM domain.

func NewDOMGetRelayoutBoundaryArgs 

func NewDOMGetRelayoutBoundaryArgs(nodeID cdptype.DOMNodeID) *DOMGetRelayoutBoundaryArgs

NewDOMGetRelayoutBoundaryArgs initializes DOMGetRelayoutBoundaryArgs with the required arguments.

type DOMGetRelayoutBoundaryReply 

type DOMGetRelayoutBoundaryReply struct {
	NodeID cdptype.DOMNodeID `json:"nodeId"` // Relayout boundary node id for the given node.
}

DOMGetRelayoutBoundaryReply represents the return values for GetRelayoutBoundary in the DOM domain.

type DOMGetSearchResultsArgs 

type DOMGetSearchResultsArgs struct {
	SearchID  string `json:"searchId"`  // Unique search session identifier.
	FromIndex int    `json:"fromIndex"` // Start index of the search result to be returned.
	ToIndex   int    `json:"toIndex"`   // End index of the search result to be returned.
}

DOMGetSearchResultsArgs represents the arguments for GetSearchResults in the DOM domain.

func NewDOMGetSearchResultsArgs 

func NewDOMGetSearchResultsArgs(searchID string, fromIndex int, toIndex int) *DOMGetSearchResultsArgs

NewDOMGetSearchResultsArgs initializes DOMGetSearchResultsArgs with the required arguments.

type DOMGetSearchResultsReply 

type DOMGetSearchResultsReply struct {
	NodeIDs []cdptype.DOMNodeID `json:"nodeIds"` // Ids of the search result nodes.
}

DOMGetSearchResultsReply represents the return values for GetSearchResults in the DOM domain.

type DOMMoveToArgs 

type DOMMoveToArgs struct {
	NodeID             cdptype.DOMNodeID  `json:"nodeId"`                       // Id of the node to move.
	TargetNodeID       cdptype.DOMNodeID  `json:"targetNodeId"`                 // Id of the element to drop the moved node into.
	InsertBeforeNodeID *cdptype.DOMNodeID `json:"insertBeforeNodeId,omitempty"` // Drop node before this one (if absent, the moved node becomes the last child of targetNodeId).
}

DOMMoveToArgs represents the arguments for MoveTo in the DOM domain.

func NewDOMMoveToArgs 

func NewDOMMoveToArgs(nodeID cdptype.DOMNodeID, targetNodeID cdptype.DOMNodeID) *DOMMoveToArgs

NewDOMMoveToArgs initializes DOMMoveToArgs with the required arguments.

func (*DOMMoveToArgs) SetInsertBeforeNodeID 

func (a *DOMMoveToArgs) SetInsertBeforeNodeID(insertBeforeNodeID cdptype.DOMNodeID) *DOMMoveToArgs

SetInsertBeforeNodeID sets the InsertBeforeNodeID optional argument. Drop node before this one (if absent, the moved node becomes the last child of targetNodeId).

type DOMMoveToReply 

type DOMMoveToReply struct {
	NodeID cdptype.DOMNodeID `json:"nodeId"` // New id of the moved node.
}

DOMMoveToReply represents the return values for MoveTo in the DOM domain.

type DOMPerformSearchArgs 

type DOMPerformSearchArgs struct {
	Query                     string `json:"query"`                               // Plain text or query selector or XPath search query.
	IncludeUserAgentShadowDOM *bool  `json:"includeUserAgentShadowDOM,omitempty"` // True to search in user agent shadow DOM.
}

DOMPerformSearchArgs represents the arguments for PerformSearch in the DOM domain.

func NewDOMPerformSearchArgs 

func NewDOMPerformSearchArgs(query string) *DOMPerformSearchArgs

NewDOMPerformSearchArgs initializes DOMPerformSearchArgs with the required arguments.

func (*DOMPerformSearchArgs) SetIncludeUserAgentShadowDOM 

func (a *DOMPerformSearchArgs) SetIncludeUserAgentShadowDOM(includeUserAgentShadowDOM bool) *DOMPerformSearchArgs

SetIncludeUserAgentShadowDOM sets the IncludeUserAgentShadowDOM optional argument. True to search in user agent shadow DOM.

type DOMPerformSearchReply 

type DOMPerformSearchReply struct {
	SearchID    string `json:"searchId"`    // Unique search session identifier.
	ResultCount int    `json:"resultCount"` // Number of search results.
}

DOMPerformSearchReply represents the return values for PerformSearch in the DOM domain.

type DOMPushNodeByPathToFrontendArgs 

type DOMPushNodeByPathToFrontendArgs struct {
	Path string `json:"path"` // Path to node in the proprietary format.
}

DOMPushNodeByPathToFrontendArgs represents the arguments for PushNodeByPathToFrontend in the DOM domain.

func NewDOMPushNodeByPathToFrontendArgs 

func NewDOMPushNodeByPathToFrontendArgs(path string) *DOMPushNodeByPathToFrontendArgs

NewDOMPushNodeByPathToFrontendArgs initializes DOMPushNodeByPathToFrontendArgs with the required arguments.

type DOMPushNodeByPathToFrontendReply 

type DOMPushNodeByPathToFrontendReply struct {
	NodeID cdptype.DOMNodeID `json:"nodeId"` // Id of the node for given path.
}

DOMPushNodeByPathToFrontendReply represents the return values for PushNodeByPathToFrontend in the DOM domain.

type DOMPushNodesByBackendIdsToFrontendArgs 

type DOMPushNodesByBackendIdsToFrontendArgs struct {
	BackendNodeIDs []cdptype.DOMBackendNodeID `json:"backendNodeIds"` // The array of backend node ids.
}

DOMPushNodesByBackendIdsToFrontendArgs represents the arguments for PushNodesByBackendIdsToFrontend in the DOM domain.

func NewDOMPushNodesByBackendIdsToFrontendArgs 

func NewDOMPushNodesByBackendIdsToFrontendArgs(backendNodeIDs []cdptype.DOMBackendNodeID) *DOMPushNodesByBackendIdsToFrontendArgs

NewDOMPushNodesByBackendIdsToFrontendArgs initializes DOMPushNodesByBackendIdsToFrontendArgs with the required arguments.

type DOMPushNodesByBackendIdsToFrontendReply 

type DOMPushNodesByBackendIdsToFrontendReply struct {
	NodeIDs []cdptype.DOMNodeID `json:"nodeIds"` // The array of ids of pushed nodes that correspond to the backend ids specified in backendNodeIds.
}

DOMPushNodesByBackendIdsToFrontendReply represents the return values for PushNodesByBackendIdsToFrontend in the DOM domain.

type DOMQuerySelectorAllArgs 

type DOMQuerySelectorAllArgs struct {
	NodeID   cdptype.DOMNodeID `json:"nodeId"`   // Id of the node to query upon.
	Selector string            `json:"selector"` // Selector string.
}

DOMQuerySelectorAllArgs represents the arguments for QuerySelectorAll in the DOM domain.

func NewDOMQuerySelectorAllArgs 

func NewDOMQuerySelectorAllArgs(nodeID cdptype.DOMNodeID, selector string) *DOMQuerySelectorAllArgs

NewDOMQuerySelectorAllArgs initializes DOMQuerySelectorAllArgs with the required arguments.

type DOMQuerySelectorAllReply 

type DOMQuerySelectorAllReply struct {
	NodeIDs []cdptype.DOMNodeID `json:"nodeIds"` // Query selector result.
}

DOMQuerySelectorAllReply represents the return values for QuerySelectorAll in the DOM domain.

type DOMQuerySelectorArgs 

type DOMQuerySelectorArgs struct {
	NodeID   cdptype.DOMNodeID `json:"nodeId"`   // Id of the node to query upon.
	Selector string            `json:"selector"` // Selector string.
}

DOMQuerySelectorArgs represents the arguments for QuerySelector in the DOM domain.

func NewDOMQuerySelectorArgs 

func NewDOMQuerySelectorArgs(nodeID cdptype.DOMNodeID, selector string) *DOMQuerySelectorArgs

NewDOMQuerySelectorArgs initializes DOMQuerySelectorArgs with the required arguments.

type DOMQuerySelectorReply 

type DOMQuerySelectorReply struct {
	NodeID cdptype.DOMNodeID `json:"nodeId"` // Query selector result.
}

DOMQuerySelectorReply represents the return values for QuerySelector in the DOM domain.

type DOMRemoveAttributeArgs 

type DOMRemoveAttributeArgs struct {
	NodeID cdptype.DOMNodeID `json:"nodeId"` // Id of the element to remove attribute from.
	Name   string            `json:"name"`   // Name of the attribute to remove.
}

DOMRemoveAttributeArgs represents the arguments for RemoveAttribute in the DOM domain.

func NewDOMRemoveAttributeArgs 

func NewDOMRemoveAttributeArgs(nodeID cdptype.DOMNodeID, name string) *DOMRemoveAttributeArgs

NewDOMRemoveAttributeArgs initializes DOMRemoveAttributeArgs with the required arguments.

type DOMRemoveNodeArgs 

type DOMRemoveNodeArgs struct {
	NodeID cdptype.DOMNodeID `json:"nodeId"` // Id of the node to remove.
}

DOMRemoveNodeArgs represents the arguments for RemoveNode in the DOM domain.

func NewDOMRemoveNodeArgs 

func NewDOMRemoveNodeArgs(nodeID cdptype.DOMNodeID) *DOMRemoveNodeArgs

NewDOMRemoveNodeArgs initializes DOMRemoveNodeArgs with the required arguments.

type DOMRequestChildNodesArgs 

type DOMRequestChildNodesArgs struct {
	NodeID cdptype.DOMNodeID `json:"nodeId"`           // Id of the node to get children for.
	Depth  *int              `json:"depth,omitempty"`  // The maximum depth at which children should be retrieved, defaults to 1. Use -1 for the entire subtree or provide an integer larger than 0.
	Pierce *bool             `json:"pierce,omitempty"` // Whether or not iframes and shadow roots should be traversed when returning the sub-tree (default is false).
}

DOMRequestChildNodesArgs represents the arguments for RequestChildNodes in the DOM domain.

func NewDOMRequestChildNodesArgs 

func NewDOMRequestChildNodesArgs(nodeID cdptype.DOMNodeID) *DOMRequestChildNodesArgs

NewDOMRequestChildNodesArgs initializes DOMRequestChildNodesArgs with the required arguments.

func (*DOMRequestChildNodesArgs) SetDepth 

func (a *DOMRequestChildNodesArgs) SetDepth(depth int) *DOMRequestChildNodesArgs

SetDepth sets the Depth optional argument. The maximum depth at which children should be retrieved, defaults to 1. Use -1 for the entire subtree or provide an integer larger than 0.

func (*DOMRequestChildNodesArgs) SetPierce 

func (a *DOMRequestChildNodesArgs) SetPierce(pierce bool) *DOMRequestChildNodesArgs

SetPierce sets the Pierce optional argument. Whether or not iframes and shadow roots should be traversed when returning the sub-tree (default is false).

type DOMRequestNodeArgs 

type DOMRequestNodeArgs struct {
	ObjectID cdptype.RuntimeRemoteObjectID `json:"objectId"` // JavaScript object id to convert into node.
}

DOMRequestNodeArgs represents the arguments for RequestNode in the DOM domain.

func NewDOMRequestNodeArgs 

func NewDOMRequestNodeArgs(objectID cdptype.RuntimeRemoteObjectID) *DOMRequestNodeArgs

NewDOMRequestNodeArgs initializes DOMRequestNodeArgs with the required arguments.

type DOMRequestNodeReply 

type DOMRequestNodeReply struct {
	NodeID cdptype.DOMNodeID `json:"nodeId"` // Node id for given object.
}

DOMRequestNodeReply represents the return values for RequestNode in the DOM domain.

type DOMResolveNodeArgs 

type DOMResolveNodeArgs struct {
	NodeID      cdptype.DOMNodeID `json:"nodeId"`                // Id of the node to resolve.
	ObjectGroup *string           `json:"objectGroup,omitempty"` // Symbolic group name that can be used to release multiple objects.
}

DOMResolveNodeArgs represents the arguments for ResolveNode in the DOM domain.

func NewDOMResolveNodeArgs 

func NewDOMResolveNodeArgs(nodeID cdptype.DOMNodeID) *DOMResolveNodeArgs

NewDOMResolveNodeArgs initializes DOMResolveNodeArgs with the required arguments.

func (*DOMResolveNodeArgs) SetObjectGroup 

func (a *DOMResolveNodeArgs) SetObjectGroup(objectGroup string) *DOMResolveNodeArgs

SetObjectGroup sets the ObjectGroup optional argument. Symbolic group name that can be used to release multiple objects.

type DOMResolveNodeReply 

type DOMResolveNodeReply struct {
	Object cdptype.RuntimeRemoteObject `json:"object"` // JavaScript object wrapper for given node.
}

DOMResolveNodeReply represents the return values for ResolveNode in the DOM domain.

type DOMSetAttributeValueArgs 

type DOMSetAttributeValueArgs struct {
	NodeID cdptype.DOMNodeID `json:"nodeId"` // Id of the element to set attribute for.
	Name   string            `json:"name"`   // Attribute name.
	Value  string            `json:"value"`  // Attribute value.
}

DOMSetAttributeValueArgs represents the arguments for SetAttributeValue in the DOM domain.

func NewDOMSetAttributeValueArgs 

func NewDOMSetAttributeValueArgs(nodeID cdptype.DOMNodeID, name string, value string) *DOMSetAttributeValueArgs

NewDOMSetAttributeValueArgs initializes DOMSetAttributeValueArgs with the required arguments.

type DOMSetAttributesAsTextArgs 

type DOMSetAttributesAsTextArgs struct {
	NodeID cdptype.DOMNodeID `json:"nodeId"`         // Id of the element to set attributes for.
	Text   string            `json:"text"`           // Text with a number of attributes. Will parse this text using HTML parser.
	Name   *string           `json:"name,omitempty"` // Attribute name to replace with new attributes derived from text in case text parsed successfully.
}

DOMSetAttributesAsTextArgs represents the arguments for SetAttributesAsText in the DOM domain.

func NewDOMSetAttributesAsTextArgs 

func NewDOMSetAttributesAsTextArgs(nodeID cdptype.DOMNodeID, text string) *DOMSetAttributesAsTextArgs

NewDOMSetAttributesAsTextArgs initializes DOMSetAttributesAsTextArgs with the required arguments.

func (*DOMSetAttributesAsTextArgs) SetName 

func (a *DOMSetAttributesAsTextArgs) SetName(name string) *DOMSetAttributesAsTextArgs

SetName sets the Name optional argument. Attribute name to replace with new attributes derived from text in case text parsed successfully.

type DOMSetFileInputFilesArgs 

type DOMSetFileInputFilesArgs struct {
	NodeID cdptype.DOMNodeID `json:"nodeId"` // Id of the file input node to set files for.
	Files  []string          `json:"files"`  // Array of file paths to set.
}

DOMSetFileInputFilesArgs represents the arguments for SetFileInputFiles in the DOM domain.

func NewDOMSetFileInputFilesArgs 

func NewDOMSetFileInputFilesArgs(nodeID cdptype.DOMNodeID, files []string) *DOMSetFileInputFilesArgs

NewDOMSetFileInputFilesArgs initializes DOMSetFileInputFilesArgs with the required arguments.

type DOMSetInspectedNodeArgs 

type DOMSetInspectedNodeArgs struct {
	NodeID cdptype.DOMNodeID `json:"nodeId"` // DOM node id to be accessible by means of $x command line API.
}

DOMSetInspectedNodeArgs represents the arguments for SetInspectedNode in the DOM domain.

func NewDOMSetInspectedNodeArgs 

func NewDOMSetInspectedNodeArgs(nodeID cdptype.DOMNodeID) *DOMSetInspectedNodeArgs

NewDOMSetInspectedNodeArgs initializes DOMSetInspectedNodeArgs with the required arguments.

type DOMSetNodeNameArgs 

type DOMSetNodeNameArgs struct {
	NodeID cdptype.DOMNodeID `json:"nodeId"` // Id of the node to set name for.
	Name   string            `json:"name"`   // New node's name.
}

DOMSetNodeNameArgs represents the arguments for SetNodeName in the DOM domain.

func NewDOMSetNodeNameArgs 

func NewDOMSetNodeNameArgs(nodeID cdptype.DOMNodeID, name string) *DOMSetNodeNameArgs

NewDOMSetNodeNameArgs initializes DOMSetNodeNameArgs with the required arguments.

type DOMSetNodeNameReply 

type DOMSetNodeNameReply struct {
	NodeID cdptype.DOMNodeID `json:"nodeId"` // New node's id.
}

DOMSetNodeNameReply represents the return values for SetNodeName in the DOM domain.

type DOMSetNodeValueArgs 

type DOMSetNodeValueArgs struct {
	NodeID cdptype.DOMNodeID `json:"nodeId"` // Id of the node to set value for.
	Value  string            `json:"value"`  // New node's value.
}

DOMSetNodeValueArgs represents the arguments for SetNodeValue in the DOM domain.

func NewDOMSetNodeValueArgs 

func NewDOMSetNodeValueArgs(nodeID cdptype.DOMNodeID, value string) *DOMSetNodeValueArgs

NewDOMSetNodeValueArgs initializes DOMSetNodeValueArgs with the required arguments.

type DOMSetOuterHTMLArgs 

type DOMSetOuterHTMLArgs struct {
	NodeID    cdptype.DOMNodeID `json:"nodeId"`    // Id of the node to set markup for.
	OuterHTML string            `json:"outerHTML"` // Outer HTML markup to set.
}

DOMSetOuterHTMLArgs represents the arguments for SetOuterHTML in the DOM domain.

func NewDOMSetOuterHTMLArgs 

func NewDOMSetOuterHTMLArgs(nodeID cdptype.DOMNodeID, outerHTML string) *DOMSetOuterHTMLArgs

NewDOMSetOuterHTMLArgs initializes DOMSetOuterHTMLArgs with the required arguments.

type DOMSnapshotGetSnapshotArgs 

type DOMSnapshotGetSnapshotArgs struct {
	ComputedStyleWhitelist []string `json:"computedStyleWhitelist"` // Whitelist of computed styles to return.
}

DOMSnapshotGetSnapshotArgs represents the arguments for GetSnapshot in the DOMSnapshot domain.

func NewDOMSnapshotGetSnapshotArgs 

func NewDOMSnapshotGetSnapshotArgs(computedStyleWhitelist []string) *DOMSnapshotGetSnapshotArgs

NewDOMSnapshotGetSnapshotArgs initializes DOMSnapshotGetSnapshotArgs with the required arguments.

type DOMSnapshotGetSnapshotReply 

type DOMSnapshotGetSnapshotReply struct {
	DOMNodes        []cdptype.DOMSnapshotDOMNode        `json:"domNodes"`        // The nodes in the DOM tree. The DOMNode at index 0 corresponds to the root document.
	LayoutTreeNodes []cdptype.DOMSnapshotLayoutTreeNode `json:"layoutTreeNodes"` // The nodes in the layout tree.
	ComputedStyles  []cdptype.DOMSnapshotComputedStyle  `json:"computedStyles"`  // Whitelisted ComputedStyle properties for each node in the layout tree.
}

DOMSnapshotGetSnapshotReply represents the return values for GetSnapshot in the DOMSnapshot domain.

type DOMStorageClearArgs 

type DOMStorageClearArgs struct {
	StorageID cdptype.DOMStorageStorageID `json:"storageId"` //
}

DOMStorageClearArgs represents the arguments for Clear in the DOMStorage domain.

func NewDOMStorageClearArgs 

func NewDOMStorageClearArgs(storageID cdptype.DOMStorageStorageID) *DOMStorageClearArgs

NewDOMStorageClearArgs initializes DOMStorageClearArgs with the required arguments.

type DOMStorageGetDOMStorageItemsArgs 

type DOMStorageGetDOMStorageItemsArgs struct {
	StorageID cdptype.DOMStorageStorageID `json:"storageId"` //
}

DOMStorageGetDOMStorageItemsArgs represents the arguments for GetDOMStorageItems in the DOMStorage domain.

func NewDOMStorageGetDOMStorageItemsArgs 

func NewDOMStorageGetDOMStorageItemsArgs(storageID cdptype.DOMStorageStorageID) *DOMStorageGetDOMStorageItemsArgs

NewDOMStorageGetDOMStorageItemsArgs initializes DOMStorageGetDOMStorageItemsArgs with the required arguments.

type DOMStorageGetDOMStorageItemsReply 

type DOMStorageGetDOMStorageItemsReply struct {
	Entries []cdptype.DOMStorageItem `json:"entries"` //
}

DOMStorageGetDOMStorageItemsReply represents the return values for GetDOMStorageItems in the DOMStorage domain.

type DOMStorageRemoveDOMStorageItemArgs 

type DOMStorageRemoveDOMStorageItemArgs struct {
	StorageID cdptype.DOMStorageStorageID `json:"storageId"` //
	Key       string                      `json:"key"`       //
}

DOMStorageRemoveDOMStorageItemArgs represents the arguments for RemoveDOMStorageItem in the DOMStorage domain.

func NewDOMStorageRemoveDOMStorageItemArgs 

func NewDOMStorageRemoveDOMStorageItemArgs(storageID cdptype.DOMStorageStorageID, key string) *DOMStorageRemoveDOMStorageItemArgs

NewDOMStorageRemoveDOMStorageItemArgs initializes DOMStorageRemoveDOMStorageItemArgs with the required arguments.

type DOMStorageSetDOMStorageItemArgs 

type DOMStorageSetDOMStorageItemArgs struct {
	StorageID cdptype.DOMStorageStorageID `json:"storageId"` //
	Key       string                      `json:"key"`       //
	Value     string                      `json:"value"`     //
}

DOMStorageSetDOMStorageItemArgs represents the arguments for SetDOMStorageItem in the DOMStorage domain.

func NewDOMStorageSetDOMStorageItemArgs 

func NewDOMStorageSetDOMStorageItemArgs(storageID cdptype.DOMStorageStorageID, key string, value string) *DOMStorageSetDOMStorageItemArgs

NewDOMStorageSetDOMStorageItemArgs initializes DOMStorageSetDOMStorageItemArgs with the required arguments.

type DatabaseExecuteSQLArgs 

type DatabaseExecuteSQLArgs struct {
	DatabaseID cdptype.DatabaseID `json:"databaseId"` //
	Query      string             `json:"query"`      //
}

DatabaseExecuteSQLArgs represents the arguments for ExecuteSQL in the Database domain.

func NewDatabaseExecuteSQLArgs 

func NewDatabaseExecuteSQLArgs(databaseID cdptype.DatabaseID, query string) *DatabaseExecuteSQLArgs

NewDatabaseExecuteSQLArgs initializes DatabaseExecuteSQLArgs with the required arguments.

type DatabaseExecuteSQLReply 

type DatabaseExecuteSQLReply struct {
	ColumnNames []string               `json:"columnNames,omitempty"` //
	Values      []json.RawMessage      `json:"values,omitempty"`      //
	SQLError    *cdptype.DatabaseError `json:"sqlError,omitempty"`    //
}

DatabaseExecuteSQLReply represents the return values for ExecuteSQL in the Database domain.

type DatabaseGetDatabaseTableNamesArgs 

type DatabaseGetDatabaseTableNamesArgs struct {
	DatabaseID cdptype.DatabaseID `json:"databaseId"` //
}

DatabaseGetDatabaseTableNamesArgs represents the arguments for GetDatabaseTableNames in the Database domain.

func NewDatabaseGetDatabaseTableNamesArgs 

func NewDatabaseGetDatabaseTableNamesArgs(databaseID cdptype.DatabaseID) *DatabaseGetDatabaseTableNamesArgs

NewDatabaseGetDatabaseTableNamesArgs initializes DatabaseGetDatabaseTableNamesArgs with the required arguments.

type DatabaseGetDatabaseTableNamesReply 

type DatabaseGetDatabaseTableNamesReply struct {
	TableNames []string `json:"tableNames"` //
}

DatabaseGetDatabaseTableNamesReply represents the return values for GetDatabaseTableNames in the Database domain.

type DebuggerContinueToLocationArgs 

type DebuggerContinueToLocationArgs struct {
	Location         cdptype.DebuggerLocation `json:"location"`                   // Location to continue to.
	TargetCallFrames *string                  `json:"targetCallFrames,omitempty"` //
}

DebuggerContinueToLocationArgs represents the arguments for ContinueToLocation in the Debugger domain.

func NewDebuggerContinueToLocationArgs 

func NewDebuggerContinueToLocationArgs(location cdptype.DebuggerLocation) *DebuggerContinueToLocationArgs

NewDebuggerContinueToLocationArgs initializes DebuggerContinueToLocationArgs with the required arguments.

func (*DebuggerContinueToLocationArgs) SetTargetCallFrames 

func (a *DebuggerContinueToLocationArgs) SetTargetCallFrames(targetCallFrames string) *DebuggerContinueToLocationArgs

SetTargetCallFrames sets the TargetCallFrames optional argument.

type DebuggerEvaluateOnCallFrameArgs 

type DebuggerEvaluateOnCallFrameArgs struct {
	CallFrameID           cdptype.DebuggerCallFrameID `json:"callFrameId"`                     // Call frame identifier to evaluate on.
	Expression            string                      `json:"expression"`                      // Expression to evaluate.
	ObjectGroup           *string                     `json:"objectGroup,omitempty"`           // String object group name to put result into (allows rapid releasing resulting object handles using releaseObjectGroup).
	IncludeCommandLineAPI *bool                       `json:"includeCommandLineAPI,omitempty"` // Specifies whether command line API should be available to the evaluated expression, defaults to false.
	Silent                *bool                       `json:"silent,omitempty"`                // In silent mode exceptions thrown during evaluation are not reported and do not pause execution. Overrides setPauseOnException state.
	ReturnByValue         *bool                       `json:"returnByValue,omitempty"`         // Whether the result is expected to be a JSON object that should be sent by value.
	GeneratePreview       *bool                       `json:"generatePreview,omitempty"`       // Whether preview should be generated for the result.
	ThrowOnSideEffect     *bool                       `json:"throwOnSideEffect,omitempty"`     // Whether to throw an exception if side effect cannot be ruled out during evaluation.
}

DebuggerEvaluateOnCallFrameArgs represents the arguments for EvaluateOnCallFrame in the Debugger domain.

func NewDebuggerEvaluateOnCallFrameArgs 

func NewDebuggerEvaluateOnCallFrameArgs(callFrameID cdptype.DebuggerCallFrameID, expression string) *DebuggerEvaluateOnCallFrameArgs

NewDebuggerEvaluateOnCallFrameArgs initializes DebuggerEvaluateOnCallFrameArgs with the required arguments.

func (*DebuggerEvaluateOnCallFrameArgs) SetGeneratePreview 

func (a *DebuggerEvaluateOnCallFrameArgs) SetGeneratePreview(generatePreview bool) *DebuggerEvaluateOnCallFrameArgs

SetGeneratePreview sets the GeneratePreview optional argument. Whether preview should be generated for the result.

func (*DebuggerEvaluateOnCallFrameArgs) SetIncludeCommandLineAPI 

func (a *DebuggerEvaluateOnCallFrameArgs) SetIncludeCommandLineAPI(includeCommandLineAPI bool) *DebuggerEvaluateOnCallFrameArgs

SetIncludeCommandLineAPI sets the IncludeCommandLineAPI optional argument. Specifies whether command line API should be available to the evaluated expression, defaults to false.

func (*DebuggerEvaluateOnCallFrameArgs) SetObjectGroup 

func (a *DebuggerEvaluateOnCallFrameArgs) SetObjectGroup(objectGroup string) *DebuggerEvaluateOnCallFrameArgs

SetObjectGroup sets the ObjectGroup optional argument. String object group name to put result into (allows rapid releasing resulting object handles using releaseObjectGroup).

func (*DebuggerEvaluateOnCallFrameArgs) SetReturnByValue 

func (a *DebuggerEvaluateOnCallFrameArgs) SetReturnByValue(returnByValue bool) *DebuggerEvaluateOnCallFrameArgs

SetReturnByValue sets the ReturnByValue optional argument. Whether the result is expected to be a JSON object that should be sent by value.

func (*DebuggerEvaluateOnCallFrameArgs) SetSilent 

func (a *DebuggerEvaluateOnCallFrameArgs) SetSilent(silent bool) *DebuggerEvaluateOnCallFrameArgs

SetSilent sets the Silent optional argument. In silent mode exceptions thrown during evaluation are not reported and do not pause execution. Overrides setPauseOnException state.

func (*DebuggerEvaluateOnCallFrameArgs) SetThrowOnSideEffect 

func (a *DebuggerEvaluateOnCallFrameArgs) SetThrowOnSideEffect(throwOnSideEffect bool) *DebuggerEvaluateOnCallFrameArgs

SetThrowOnSideEffect sets the ThrowOnSideEffect optional argument. Whether to throw an exception if side effect cannot be ruled out during evaluation.

type DebuggerEvaluateOnCallFrameReply 

type DebuggerEvaluateOnCallFrameReply struct {
	Result           cdptype.RuntimeRemoteObject      `json:"result"`                     // Object wrapper for the evaluation result.
	ExceptionDetails *cdptype.RuntimeExceptionDetails `json:"exceptionDetails,omitempty"` // Exception details.
}

DebuggerEvaluateOnCallFrameReply represents the return values for EvaluateOnCallFrame in the Debugger domain.

type DebuggerGetPossibleBreakpointsArgs 

type DebuggerGetPossibleBreakpointsArgs struct {
	Start              cdptype.DebuggerLocation  `json:"start"`                        // Start of range to search possible breakpoint locations in.
	End                *cdptype.DebuggerLocation `json:"end,omitempty"`                // End of range to search possible breakpoint locations in (excluding). When not specified, end of scripts is used as end of range.
	RestrictToFunction *bool                     `json:"restrictToFunction,omitempty"` // Only consider locations which are in the same (non-nested) function as start.
}

DebuggerGetPossibleBreakpointsArgs represents the arguments for GetPossibleBreakpoints in the Debugger domain.

func NewDebuggerGetPossibleBreakpointsArgs 

func NewDebuggerGetPossibleBreakpointsArgs(start cdptype.DebuggerLocation) *DebuggerGetPossibleBreakpointsArgs

NewDebuggerGetPossibleBreakpointsArgs initializes DebuggerGetPossibleBreakpointsArgs with the required arguments.

func (*DebuggerGetPossibleBreakpointsArgs) SetEnd 

func (a *DebuggerGetPossibleBreakpointsArgs) SetEnd(end cdptype.DebuggerLocation) *DebuggerGetPossibleBreakpointsArgs

SetEnd sets the End optional argument. End of range to search possible breakpoint locations in (excluding). When not specified, end of scripts is used as end of range.

func (*DebuggerGetPossibleBreakpointsArgs) SetRestrictToFunction 

func (a *DebuggerGetPossibleBreakpointsArgs) SetRestrictToFunction(restrictToFunction bool) *DebuggerGetPossibleBreakpointsArgs

SetRestrictToFunction sets the RestrictToFunction optional argument. Only consider locations which are in the same (non-nested) function as start.

type DebuggerGetPossibleBreakpointsReply 

type DebuggerGetPossibleBreakpointsReply struct {
	Locations []cdptype.DebuggerBreakLocation `json:"locations"` // List of the possible breakpoint locations.
}

DebuggerGetPossibleBreakpointsReply represents the return values for GetPossibleBreakpoints in the Debugger domain.

type DebuggerGetScriptSourceArgs 

type DebuggerGetScriptSourceArgs struct {
	ScriptID cdptype.RuntimeScriptID `json:"scriptId"` // Id of the script to get source for.
}

DebuggerGetScriptSourceArgs represents the arguments for GetScriptSource in the Debugger domain.

func NewDebuggerGetScriptSourceArgs 

func NewDebuggerGetScriptSourceArgs(scriptID cdptype.RuntimeScriptID) *DebuggerGetScriptSourceArgs

NewDebuggerGetScriptSourceArgs initializes DebuggerGetScriptSourceArgs with the required arguments.

type DebuggerGetScriptSourceReply 

type DebuggerGetScriptSourceReply struct {
	ScriptSource string `json:"scriptSource"` // Script source.
}

DebuggerGetScriptSourceReply represents the return values for GetScriptSource in the Debugger domain.

type DebuggerRemoveBreakpointArgs 

type DebuggerRemoveBreakpointArgs struct {
	BreakpointID cdptype.DebuggerBreakpointID `json:"breakpointId"` //
}

DebuggerRemoveBreakpointArgs represents the arguments for RemoveBreakpoint in the Debugger domain.

func NewDebuggerRemoveBreakpointArgs 

func NewDebuggerRemoveBreakpointArgs(breakpointID cdptype.DebuggerBreakpointID) *DebuggerRemoveBreakpointArgs

NewDebuggerRemoveBreakpointArgs initializes DebuggerRemoveBreakpointArgs with the required arguments.

type DebuggerRestartFrameArgs 

type DebuggerRestartFrameArgs struct {
	CallFrameID cdptype.DebuggerCallFrameID `json:"callFrameId"` // Call frame identifier to evaluate on.
}

DebuggerRestartFrameArgs represents the arguments for RestartFrame in the Debugger domain.

func NewDebuggerRestartFrameArgs 

func NewDebuggerRestartFrameArgs(callFrameID cdptype.DebuggerCallFrameID) *DebuggerRestartFrameArgs

NewDebuggerRestartFrameArgs initializes DebuggerRestartFrameArgs with the required arguments.

type DebuggerRestartFrameReply 

type DebuggerRestartFrameReply struct {
	CallFrames      []cdptype.DebuggerCallFrame `json:"callFrames"`                // New stack trace.
	AsyncStackTrace *cdptype.RuntimeStackTrace  `json:"asyncStackTrace,omitempty"` // Async stack trace, if any.
}

DebuggerRestartFrameReply represents the return values for RestartFrame in the Debugger domain.

type DebuggerSearchInContentArgs 

type DebuggerSearchInContentArgs struct {
	ScriptID      cdptype.RuntimeScriptID `json:"scriptId"`                // Id of the script to search in.
	Query         string                  `json:"query"`                   // String to search for.
	CaseSensitive *bool                   `json:"caseSensitive,omitempty"` // If true, search is case sensitive.
	IsRegex       *bool                   `json:"isRegex,omitempty"`       // If true, treats string parameter as regex.
}

DebuggerSearchInContentArgs represents the arguments for SearchInContent in the Debugger domain.

func NewDebuggerSearchInContentArgs 

func NewDebuggerSearchInContentArgs(scriptID cdptype.RuntimeScriptID, query string) *DebuggerSearchInContentArgs

NewDebuggerSearchInContentArgs initializes DebuggerSearchInContentArgs with the required arguments.

func (*DebuggerSearchInContentArgs) SetCaseSensitive 

func (a *DebuggerSearchInContentArgs) SetCaseSensitive(caseSensitive bool) *DebuggerSearchInContentArgs

SetCaseSensitive sets the CaseSensitive optional argument. If true, search is case sensitive.

func (*DebuggerSearchInContentArgs) SetIsRegex 

func (a *DebuggerSearchInContentArgs) SetIsRegex(isRegex bool) *DebuggerSearchInContentArgs

SetIsRegex sets the IsRegex optional argument. If true, treats string parameter as regex.

type DebuggerSearchInContentReply 

type DebuggerSearchInContentReply struct {
	Result []cdptype.DebuggerSearchMatch `json:"result"` // List of search matches.
}

DebuggerSearchInContentReply represents the return values for SearchInContent in the Debugger domain.

type DebuggerSetAsyncCallStackDepthArgs 

type DebuggerSetAsyncCallStackDepthArgs struct {
	MaxDepth int `json:"maxDepth"` // Maximum depth of async call stacks. Setting to 0 will effectively disable collecting async call stacks (default).
}

DebuggerSetAsyncCallStackDepthArgs represents the arguments for SetAsyncCallStackDepth in the Debugger domain.

func NewDebuggerSetAsyncCallStackDepthArgs 

func NewDebuggerSetAsyncCallStackDepthArgs(maxDepth int) *DebuggerSetAsyncCallStackDepthArgs

NewDebuggerSetAsyncCallStackDepthArgs initializes DebuggerSetAsyncCallStackDepthArgs with the required arguments.

type DebuggerSetBlackboxPatternsArgs 

type DebuggerSetBlackboxPatternsArgs struct {
	Patterns []string `json:"patterns"` // Array of regexps that will be used to check script url for blackbox state.
}

DebuggerSetBlackboxPatternsArgs represents the arguments for SetBlackboxPatterns in the Debugger domain.

func NewDebuggerSetBlackboxPatternsArgs 

func NewDebuggerSetBlackboxPatternsArgs(patterns []string) *DebuggerSetBlackboxPatternsArgs

NewDebuggerSetBlackboxPatternsArgs initializes DebuggerSetBlackboxPatternsArgs with the required arguments.

type DebuggerSetBlackboxedRangesArgs 

type DebuggerSetBlackboxedRangesArgs struct {
	ScriptID  cdptype.RuntimeScriptID          `json:"scriptId"`  // Id of the script.
	Positions []cdptype.DebuggerScriptPosition `json:"positions"` //
}

DebuggerSetBlackboxedRangesArgs represents the arguments for SetBlackboxedRanges in the Debugger domain.

func NewDebuggerSetBlackboxedRangesArgs 

func NewDebuggerSetBlackboxedRangesArgs(scriptID cdptype.RuntimeScriptID, positions []cdptype.DebuggerScriptPosition) *DebuggerSetBlackboxedRangesArgs

NewDebuggerSetBlackboxedRangesArgs initializes DebuggerSetBlackboxedRangesArgs with the required arguments.

type DebuggerSetBreakpointArgs 

type DebuggerSetBreakpointArgs struct {
	Location  cdptype.DebuggerLocation `json:"location"`            // Location to set breakpoint in.
	Condition *string                  `json:"condition,omitempty"` // Expression to use as a breakpoint condition. When specified, debugger will only stop on the breakpoint if this expression evaluates to true.
}

DebuggerSetBreakpointArgs represents the arguments for SetBreakpoint in the Debugger domain.

func NewDebuggerSetBreakpointArgs 

func NewDebuggerSetBreakpointArgs(location cdptype.DebuggerLocation) *DebuggerSetBreakpointArgs

NewDebuggerSetBreakpointArgs initializes DebuggerSetBreakpointArgs with the required arguments.

func (*DebuggerSetBreakpointArgs) SetCondition 

func (a *DebuggerSetBreakpointArgs) SetCondition(condition string) *DebuggerSetBreakpointArgs

SetCondition sets the Condition optional argument. Expression to use as a breakpoint condition. When specified, debugger will only stop on the breakpoint if this expression evaluates to true.

type DebuggerSetBreakpointByURLArgs 

type DebuggerSetBreakpointByURLArgs struct {
	LineNumber   int     `json:"lineNumber"`             // Line number to set breakpoint at.
	URL          *string `json:"url,omitempty"`          // URL of the resources to set breakpoint on.
	URLRegex     *string `json:"urlRegex,omitempty"`     // Regex pattern for the URLs of the resources to set breakpoints on. Either url or urlRegex must be specified.
	ColumnNumber *int    `json:"columnNumber,omitempty"` // Offset in the line to set breakpoint at.
	Condition    *string `json:"condition,omitempty"`    // Expression to use as a breakpoint condition. When specified, debugger will only stop on the breakpoint if this expression evaluates to true.
}

DebuggerSetBreakpointByURLArgs represents the arguments for SetBreakpointByURL in the Debugger domain.

func NewDebuggerSetBreakpointByURLArgs 

func NewDebuggerSetBreakpointByURLArgs(lineNumber int) *DebuggerSetBreakpointByURLArgs

NewDebuggerSetBreakpointByURLArgs initializes DebuggerSetBreakpointByURLArgs with the required arguments.

func (*DebuggerSetBreakpointByURLArgs) SetColumnNumber 

func (a *DebuggerSetBreakpointByURLArgs) SetColumnNumber(columnNumber int) *DebuggerSetBreakpointByURLArgs

SetColumnNumber sets the ColumnNumber optional argument. Offset in the line to set breakpoint at.

func (*DebuggerSetBreakpointByURLArgs) SetCondition 

func (a *DebuggerSetBreakpointByURLArgs) SetCondition(condition string) *DebuggerSetBreakpointByURLArgs

SetCondition sets the Condition optional argument. Expression to use as a breakpoint condition. When specified, debugger will only stop on the breakpoint if this expression evaluates to true.

func (*DebuggerSetBreakpointByURLArgs) SetURL 

func (a *DebuggerSetBreakpointByURLArgs) SetURL(url string) *DebuggerSetBreakpointByURLArgs

SetURL sets the URL optional argument. URL of the resources to set breakpoint on.

func (*DebuggerSetBreakpointByURLArgs) SetURLRegex 

func (a *DebuggerSetBreakpointByURLArgs) SetURLRegex(urlRegex string) *DebuggerSetBreakpointByURLArgs

SetURLRegex sets the URLRegex optional argument. Regex pattern for the URLs of the resources to set breakpoints on. Either url or urlRegex must be specified.

type DebuggerSetBreakpointByURLReply 

type DebuggerSetBreakpointByURLReply struct {
	BreakpointID cdptype.DebuggerBreakpointID `json:"breakpointId"` // Id of the created breakpoint for further reference.
	Locations    []cdptype.DebuggerLocation   `json:"locations"`    // List of the locations this breakpoint resolved into upon addition.
}

DebuggerSetBreakpointByURLReply represents the return values for SetBreakpointByURL in the Debugger domain.

type DebuggerSetBreakpointReply 

type DebuggerSetBreakpointReply struct {
	BreakpointID   cdptype.DebuggerBreakpointID `json:"breakpointId"`   // Id of the created breakpoint for further reference.
	ActualLocation cdptype.DebuggerLocation     `json:"actualLocation"` // Location this breakpoint resolved into.
}

DebuggerSetBreakpointReply represents the return values for SetBreakpoint in the Debugger domain.

type DebuggerSetBreakpointsActiveArgs 

type DebuggerSetBreakpointsActiveArgs struct {
	Active bool `json:"active"` // New value for breakpoints active state.
}

DebuggerSetBreakpointsActiveArgs represents the arguments for SetBreakpointsActive in the Debugger domain.

func NewDebuggerSetBreakpointsActiveArgs 

func NewDebuggerSetBreakpointsActiveArgs(active bool) *DebuggerSetBreakpointsActiveArgs

NewDebuggerSetBreakpointsActiveArgs initializes DebuggerSetBreakpointsActiveArgs with the required arguments.

type DebuggerSetPauseOnExceptionsArgs 

type DebuggerSetPauseOnExceptionsArgs struct {
	State string `json:"state"` // Pause on exceptions mode.
}

DebuggerSetPauseOnExceptionsArgs represents the arguments for SetPauseOnExceptions in the Debugger domain.

func NewDebuggerSetPauseOnExceptionsArgs 

func NewDebuggerSetPauseOnExceptionsArgs(state string) *DebuggerSetPauseOnExceptionsArgs

NewDebuggerSetPauseOnExceptionsArgs initializes DebuggerSetPauseOnExceptionsArgs with the required arguments.

type DebuggerSetScriptSourceArgs 

type DebuggerSetScriptSourceArgs struct {
	ScriptID     cdptype.RuntimeScriptID `json:"scriptId"`         // Id of the script to edit.
	ScriptSource string                  `json:"scriptSource"`     // New content of the script.
	DryRun       *bool                   `json:"dryRun,omitempty"` //  If true the change will not actually be applied. Dry run may be used to get result description without actually modifying the code.
}

DebuggerSetScriptSourceArgs represents the arguments for SetScriptSource in the Debugger domain.

func NewDebuggerSetScriptSourceArgs 

func NewDebuggerSetScriptSourceArgs(scriptID cdptype.RuntimeScriptID, scriptSource string) *DebuggerSetScriptSourceArgs

NewDebuggerSetScriptSourceArgs initializes DebuggerSetScriptSourceArgs with the required arguments.

func (*DebuggerSetScriptSourceArgs) SetDryRun 

func (a *DebuggerSetScriptSourceArgs) SetDryRun(dryRun bool) *DebuggerSetScriptSourceArgs

SetDryRun sets the DryRun optional argument. If true the change will not actually be applied. Dry run may be used to get result description without actually modifying the code.

type DebuggerSetScriptSourceReply 

type DebuggerSetScriptSourceReply struct {
	CallFrames       []cdptype.DebuggerCallFrame      `json:"callFrames,omitempty"`       // New stack trace in case editing has happened while VM was stopped.
	StackChanged     *bool                            `json:"stackChanged,omitempty"`     // Whether current call stack  was modified after applying the changes.
	AsyncStackTrace  *cdptype.RuntimeStackTrace       `json:"asyncStackTrace,omitempty"`  // Async stack trace, if any.
	ExceptionDetails *cdptype.RuntimeExceptionDetails `json:"exceptionDetails,omitempty"` // Exception details if any.
}

DebuggerSetScriptSourceReply represents the return values for SetScriptSource in the Debugger domain.

type DebuggerSetSkipAllPausesArgs 

type DebuggerSetSkipAllPausesArgs struct {
	Skip bool `json:"skip"` // New value for skip pauses state.
}

DebuggerSetSkipAllPausesArgs represents the arguments for SetSkipAllPauses in the Debugger domain.

func NewDebuggerSetSkipAllPausesArgs 

func NewDebuggerSetSkipAllPausesArgs(skip bool) *DebuggerSetSkipAllPausesArgs

NewDebuggerSetSkipAllPausesArgs initializes DebuggerSetSkipAllPausesArgs with the required arguments.

type DebuggerSetVariableValueArgs 

type DebuggerSetVariableValueArgs struct {
	ScopeNumber  int                         `json:"scopeNumber"`  // 0-based number of scope as was listed in scope chain. Only 'local', 'closure' and 'catch' scope types are allowed. Other scopes could be manipulated manually.
	VariableName string                      `json:"variableName"` // Variable name.
	NewValue     cdptype.RuntimeCallArgument `json:"newValue"`     // New variable value.
	CallFrameID  cdptype.DebuggerCallFrameID `json:"callFrameId"`  // Id of callframe that holds variable.
}

DebuggerSetVariableValueArgs represents the arguments for SetVariableValue in the Debugger domain.

func NewDebuggerSetVariableValueArgs 

func NewDebuggerSetVariableValueArgs(scopeNumber int, variableName string, newValue cdptype.RuntimeCallArgument, callFrameID cdptype.DebuggerCallFrameID) *DebuggerSetVariableValueArgs

NewDebuggerSetVariableValueArgs initializes DebuggerSetVariableValueArgs with the required arguments.

type DeviceOrientationSetDeviceOrientationOverrideArgs 

type DeviceOrientationSetDeviceOrientationOverrideArgs struct {
	Alpha float64 `json:"alpha"` // Mock alpha
	Beta  float64 `json:"beta"`  // Mock beta
	Gamma float64 `json:"gamma"` // Mock gamma
}

DeviceOrientationSetDeviceOrientationOverrideArgs represents the arguments for SetDeviceOrientationOverride in the DeviceOrientation domain.

func NewDeviceOrientationSetDeviceOrientationOverrideArgs 

func NewDeviceOrientationSetDeviceOrientationOverrideArgs(alpha float64, beta float64, gamma float64) *DeviceOrientationSetDeviceOrientationOverrideArgs

NewDeviceOrientationSetDeviceOrientationOverrideArgs initializes DeviceOrientationSetDeviceOrientationOverrideArgs with the required arguments.

type EmulationCanEmulateReply 

type EmulationCanEmulateReply struct {
	Result bool `json:"result"` // True if emulation is supported.
}

EmulationCanEmulateReply represents the return values for CanEmulate in the Emulation domain.

type EmulationForceViewportArgs 

type EmulationForceViewportArgs struct {
	X     float64 `json:"x"`     // X coordinate of top-left corner of the area (CSS pixels).
	Y     float64 `json:"y"`     // Y coordinate of top-left corner of the area (CSS pixels).
	Scale float64 `json:"scale"` // Scale to apply to the area (relative to a page scale of 1.0).
}

EmulationForceViewportArgs represents the arguments for ForceViewport in the Emulation domain.

func NewEmulationForceViewportArgs 

func NewEmulationForceViewportArgs(x float64, y float64, scale float64) *EmulationForceViewportArgs

NewEmulationForceViewportArgs initializes EmulationForceViewportArgs with the required arguments.

type EmulationSetCPUThrottlingRateArgs 

type EmulationSetCPUThrottlingRateArgs struct {
	Rate float64 `json:"rate"` // Throttling rate as a slowdown factor (1 is no throttle, 2 is 2x slowdown, etc).
}

EmulationSetCPUThrottlingRateArgs represents the arguments for SetCPUThrottlingRate in the Emulation domain.

func NewEmulationSetCPUThrottlingRateArgs 

func NewEmulationSetCPUThrottlingRateArgs(rate float64) *EmulationSetCPUThrottlingRateArgs

NewEmulationSetCPUThrottlingRateArgs initializes EmulationSetCPUThrottlingRateArgs with the required arguments.

type EmulationSetDefaultBackgroundColorOverrideArgs 

type EmulationSetDefaultBackgroundColorOverrideArgs struct {
	Color *cdptype.DOMRGBA `json:"color,omitempty"` // RGBA of the default background color. If not specified, any existing override will be cleared.
}

EmulationSetDefaultBackgroundColorOverrideArgs represents the arguments for SetDefaultBackgroundColorOverride in the Emulation domain.

func NewEmulationSetDefaultBackgroundColorOverrideArgs 

func NewEmulationSetDefaultBackgroundColorOverrideArgs() *EmulationSetDefaultBackgroundColorOverrideArgs

NewEmulationSetDefaultBackgroundColorOverrideArgs initializes EmulationSetDefaultBackgroundColorOverrideArgs with the required arguments.

func (*EmulationSetDefaultBackgroundColorOverrideArgs) SetColor 

func (a *EmulationSetDefaultBackgroundColorOverrideArgs) SetColor(color cdptype.DOMRGBA) *EmulationSetDefaultBackgroundColorOverrideArgs

SetColor sets the Color optional argument. RGBA of the default background color. If not specified, any existing override will be cleared.

type EmulationSetDeviceMetricsOverrideArgs 

type EmulationSetDeviceMetricsOverrideArgs struct {
	Width             int                                 `json:"width"`                       // Overriding width value in pixels (minimum 0, maximum 10000000). 0 disables the override.
	Height            int                                 `json:"height"`                      // Overriding height value in pixels (minimum 0, maximum 10000000). 0 disables the override.
	DeviceScaleFactor float64                             `json:"deviceScaleFactor"`           // Overriding device scale factor value. 0 disables the override.
	Mobile            bool                                `json:"mobile"`                      // Whether to emulate mobile device. This includes viewport meta tag, overlay scrollbars, text autosizing and more.
	FitWindow         bool                                `json:"fitWindow"`                   // Whether a view that exceeds the available browser window area should be scaled down to fit.
	Scale             *float64                            `json:"scale,omitempty"`             // Scale to apply to resulting view image. Ignored in |fitWindow| mode.
	OffsetX           *float64                            `json:"offsetX,omitempty"`           // Not used.
	OffsetY           *float64                            `json:"offsetY,omitempty"`           // Not used.
	ScreenWidth       *int                                `json:"screenWidth,omitempty"`       // Overriding screen width value in pixels (minimum 0, maximum 10000000). Only used for |mobile==true|.
	ScreenHeight      *int                                `json:"screenHeight,omitempty"`      // Overriding screen height value in pixels (minimum 0, maximum 10000000). Only used for |mobile==true|.
	PositionX         *int                                `json:"positionX,omitempty"`         // Overriding view X position on screen in pixels (minimum 0, maximum 10000000). Only used for |mobile==true|.
	PositionY         *int                                `json:"positionY,omitempty"`         // Overriding view Y position on screen in pixels (minimum 0, maximum 10000000). Only used for |mobile==true|.
	ScreenOrientation *cdptype.EmulationScreenOrientation `json:"screenOrientation,omitempty"` // Screen orientation override.
}

EmulationSetDeviceMetricsOverrideArgs represents the arguments for SetDeviceMetricsOverride in the Emulation domain.

func NewEmulationSetDeviceMetricsOverrideArgs 

func NewEmulationSetDeviceMetricsOverrideArgs(width int, height int, deviceScaleFactor float64, mobile bool, fitWindow bool) *EmulationSetDeviceMetricsOverrideArgs

NewEmulationSetDeviceMetricsOverrideArgs initializes EmulationSetDeviceMetricsOverrideArgs with the required arguments.

func (*EmulationSetDeviceMetricsOverrideArgs) SetOffsetX 

func (a *EmulationSetDeviceMetricsOverrideArgs) SetOffsetX(offsetX float64) *EmulationSetDeviceMetricsOverrideArgs

SetOffsetX sets the OffsetX optional argument. Not used.

func (*EmulationSetDeviceMetricsOverrideArgs) SetOffsetY 

func (a *EmulationSetDeviceMetricsOverrideArgs) SetOffsetY(offsetY float64) *EmulationSetDeviceMetricsOverrideArgs

SetOffsetY sets the OffsetY optional argument. Not used.

func (*EmulationSetDeviceMetricsOverrideArgs) SetPositionX 

func (a *EmulationSetDeviceMetricsOverrideArgs) SetPositionX(positionX int) *EmulationSetDeviceMetricsOverrideArgs

SetPositionX sets the PositionX optional argument. Overriding view X position on screen in pixels (minimum 0, maximum 10000000). Only used for |mobile==true|.

func (*EmulationSetDeviceMetricsOverrideArgs) SetPositionY 

func (a *EmulationSetDeviceMetricsOverrideArgs) SetPositionY(positionY int) *EmulationSetDeviceMetricsOverrideArgs

SetPositionY sets the PositionY optional argument. Overriding view Y position on screen in pixels (minimum 0, maximum 10000000). Only used for |mobile==true|.

func (*EmulationSetDeviceMetricsOverrideArgs) SetScale 

func (a *EmulationSetDeviceMetricsOverrideArgs) SetScale(scale float64) *EmulationSetDeviceMetricsOverrideArgs

SetScale sets the Scale optional argument. Scale to apply to resulting view image. Ignored in |fitWindow| mode.

func (*EmulationSetDeviceMetricsOverrideArgs) SetScreenHeight 

func (a *EmulationSetDeviceMetricsOverrideArgs) SetScreenHeight(screenHeight int) *EmulationSetDeviceMetricsOverrideArgs

SetScreenHeight sets the ScreenHeight optional argument. Overriding screen height value in pixels (minimum 0, maximum 10000000). Only used for |mobile==true|.

func (*EmulationSetDeviceMetricsOverrideArgs) SetScreenOrientation 

func (a *EmulationSetDeviceMetricsOverrideArgs) SetScreenOrientation(screenOrientation cdptype.EmulationScreenOrientation) *EmulationSetDeviceMetricsOverrideArgs

SetScreenOrientation sets the ScreenOrientation optional argument. Screen orientation override.

func (*EmulationSetDeviceMetricsOverrideArgs) SetScreenWidth 

func (a *EmulationSetDeviceMetricsOverrideArgs) SetScreenWidth(screenWidth int) *EmulationSetDeviceMetricsOverrideArgs

SetScreenWidth sets the ScreenWidth optional argument. Overriding screen width value in pixels (minimum 0, maximum 10000000). Only used for |mobile==true|.

type EmulationSetEmulatedMediaArgs 

type EmulationSetEmulatedMediaArgs struct {
	Media string `json:"media"` // Media type to emulate. Empty string disables the override.
}

EmulationSetEmulatedMediaArgs represents the arguments for SetEmulatedMedia in the Emulation domain.

func NewEmulationSetEmulatedMediaArgs 

func NewEmulationSetEmulatedMediaArgs(media string) *EmulationSetEmulatedMediaArgs

NewEmulationSetEmulatedMediaArgs initializes EmulationSetEmulatedMediaArgs with the required arguments.

type EmulationSetGeolocationOverrideArgs 

type EmulationSetGeolocationOverrideArgs struct {
	Latitude  *float64 `json:"latitude,omitempty"`  // Mock latitude
	Longitude *float64 `json:"longitude,omitempty"` // Mock longitude
	Accuracy  *float64 `json:"accuracy,omitempty"`  // Mock accuracy
}

EmulationSetGeolocationOverrideArgs represents the arguments for SetGeolocationOverride in the Emulation domain.

func NewEmulationSetGeolocationOverrideArgs 

func NewEmulationSetGeolocationOverrideArgs() *EmulationSetGeolocationOverrideArgs

NewEmulationSetGeolocationOverrideArgs initializes EmulationSetGeolocationOverrideArgs with the required arguments.

func (*EmulationSetGeolocationOverrideArgs) SetAccuracy 

func (a *EmulationSetGeolocationOverrideArgs) SetAccuracy(accuracy float64) *EmulationSetGeolocationOverrideArgs

SetAccuracy sets the Accuracy optional argument. Mock accuracy

func (*EmulationSetGeolocationOverrideArgs) SetLatitude 

func (a *EmulationSetGeolocationOverrideArgs) SetLatitude(latitude float64) *EmulationSetGeolocationOverrideArgs

SetLatitude sets the Latitude optional argument. Mock latitude

func (*EmulationSetGeolocationOverrideArgs) SetLongitude 

func (a *EmulationSetGeolocationOverrideArgs) SetLongitude(longitude float64) *EmulationSetGeolocationOverrideArgs

SetLongitude sets the Longitude optional argument. Mock longitude

type EmulationSetPageScaleFactorArgs 

type EmulationSetPageScaleFactorArgs struct {
	PageScaleFactor float64 `json:"pageScaleFactor"` // Page scale factor.
}

EmulationSetPageScaleFactorArgs represents the arguments for SetPageScaleFactor in the Emulation domain.

func NewEmulationSetPageScaleFactorArgs 

func NewEmulationSetPageScaleFactorArgs(pageScaleFactor float64) *EmulationSetPageScaleFactorArgs

NewEmulationSetPageScaleFactorArgs initializes EmulationSetPageScaleFactorArgs with the required arguments.

type EmulationSetScriptExecutionDisabledArgs 

type EmulationSetScriptExecutionDisabledArgs struct {
	Value bool `json:"value"` // Whether script execution should be disabled in the page.
}

EmulationSetScriptExecutionDisabledArgs represents the arguments for SetScriptExecutionDisabled in the Emulation domain.

func NewEmulationSetScriptExecutionDisabledArgs 

func NewEmulationSetScriptExecutionDisabledArgs(value bool) *EmulationSetScriptExecutionDisabledArgs

NewEmulationSetScriptExecutionDisabledArgs initializes EmulationSetScriptExecutionDisabledArgs with the required arguments.

type EmulationSetTouchEmulationEnabledArgs 

type EmulationSetTouchEmulationEnabledArgs struct {
	Enabled       bool    `json:"enabled"`                 // Whether the touch event emulation should be enabled.
	Configuration *string `json:"configuration,omitempty"` // Touch/gesture events configuration. Default: current platform.
}

EmulationSetTouchEmulationEnabledArgs represents the arguments for SetTouchEmulationEnabled in the Emulation domain.

func NewEmulationSetTouchEmulationEnabledArgs 

func NewEmulationSetTouchEmulationEnabledArgs(enabled bool) *EmulationSetTouchEmulationEnabledArgs

NewEmulationSetTouchEmulationEnabledArgs initializes EmulationSetTouchEmulationEnabledArgs with the required arguments.

func (*EmulationSetTouchEmulationEnabledArgs) SetConfiguration 

func (a *EmulationSetTouchEmulationEnabledArgs) SetConfiguration(configuration string) *EmulationSetTouchEmulationEnabledArgs

SetConfiguration sets the Configuration optional argument. Touch/gesture events configuration. Default: current platform.

type EmulationSetVirtualTimePolicyArgs 

type EmulationSetVirtualTimePolicyArgs struct {
	Policy cdptype.EmulationVirtualTimePolicy `json:"policy"`           //
	Budget *int                               `json:"budget,omitempty"` // If set, after this many virtual milliseconds have elapsed virtual time will be paused and a virtualTimeBudgetExpired event is sent.
}

EmulationSetVirtualTimePolicyArgs represents the arguments for SetVirtualTimePolicy in the Emulation domain.

func NewEmulationSetVirtualTimePolicyArgs 

func NewEmulationSetVirtualTimePolicyArgs(policy cdptype.EmulationVirtualTimePolicy) *EmulationSetVirtualTimePolicyArgs

NewEmulationSetVirtualTimePolicyArgs initializes EmulationSetVirtualTimePolicyArgs with the required arguments.

func (*EmulationSetVirtualTimePolicyArgs) SetBudget 

func (a *EmulationSetVirtualTimePolicyArgs) SetBudget(budget int) *EmulationSetVirtualTimePolicyArgs

SetBudget sets the Budget optional argument. If set, after this many virtual milliseconds have elapsed virtual time will be paused and a virtualTimeBudgetExpired event is sent.

type EmulationSetVisibleSizeArgs 

type EmulationSetVisibleSizeArgs struct {
	Width  int `json:"width"`  // Frame width (DIP).
	Height int `json:"height"` // Frame height (DIP).
}

EmulationSetVisibleSizeArgs represents the arguments for SetVisibleSize in the Emulation domain.

func NewEmulationSetVisibleSizeArgs 

func NewEmulationSetVisibleSizeArgs(width int, height int) *EmulationSetVisibleSizeArgs

NewEmulationSetVisibleSizeArgs initializes EmulationSetVisibleSizeArgs with the required arguments.

type HeapProfilerAddInspectedHeapObjectArgs 

type HeapProfilerAddInspectedHeapObjectArgs struct {
	HeapObjectID cdptype.HeapProfilerHeapSnapshotObjectID `json:"heapObjectId"` // Heap snapshot object id to be accessible by means of $x command line API.
}

HeapProfilerAddInspectedHeapObjectArgs represents the arguments for AddInspectedHeapObject in the HeapProfiler domain.

func NewHeapProfilerAddInspectedHeapObjectArgs 

func NewHeapProfilerAddInspectedHeapObjectArgs(heapObjectID cdptype.HeapProfilerHeapSnapshotObjectID) *HeapProfilerAddInspectedHeapObjectArgs

NewHeapProfilerAddInspectedHeapObjectArgs initializes HeapProfilerAddInspectedHeapObjectArgs with the required arguments.

type HeapProfilerGetHeapObjectIDArgs 

type HeapProfilerGetHeapObjectIDArgs struct {
	ObjectID cdptype.RuntimeRemoteObjectID `json:"objectId"` // Identifier of the object to get heap object id for.
}

HeapProfilerGetHeapObjectIDArgs represents the arguments for GetHeapObjectID in the HeapProfiler domain.

func NewHeapProfilerGetHeapObjectIDArgs 

func NewHeapProfilerGetHeapObjectIDArgs(objectID cdptype.RuntimeRemoteObjectID) *HeapProfilerGetHeapObjectIDArgs

NewHeapProfilerGetHeapObjectIDArgs initializes HeapProfilerGetHeapObjectIDArgs with the required arguments.

type HeapProfilerGetHeapObjectIDReply 

type HeapProfilerGetHeapObjectIDReply struct {
	HeapSnapshotObjectID cdptype.HeapProfilerHeapSnapshotObjectID `json:"heapSnapshotObjectId"` // Id of the heap snapshot object corresponding to the passed remote object id.
}

HeapProfilerGetHeapObjectIDReply represents the return values for GetHeapObjectID in the HeapProfiler domain.

type HeapProfilerGetObjectByHeapObjectIDArgs 

type HeapProfilerGetObjectByHeapObjectIDArgs struct {
	ObjectID    cdptype.HeapProfilerHeapSnapshotObjectID `json:"objectId"`              //
	ObjectGroup *string                                  `json:"objectGroup,omitempty"` // Symbolic group name that can be used to release multiple objects.
}

HeapProfilerGetObjectByHeapObjectIDArgs represents the arguments for GetObjectByHeapObjectID in the HeapProfiler domain.

func NewHeapProfilerGetObjectByHeapObjectIDArgs 

func NewHeapProfilerGetObjectByHeapObjectIDArgs(objectID cdptype.HeapProfilerHeapSnapshotObjectID) *HeapProfilerGetObjectByHeapObjectIDArgs

NewHeapProfilerGetObjectByHeapObjectIDArgs initializes HeapProfilerGetObjectByHeapObjectIDArgs with the required arguments.

func (*HeapProfilerGetObjectByHeapObjectIDArgs) SetObjectGroup 

func (a *HeapProfilerGetObjectByHeapObjectIDArgs) SetObjectGroup(objectGroup string) *HeapProfilerGetObjectByHeapObjectIDArgs

SetObjectGroup sets the ObjectGroup optional argument. Symbolic group name that can be used to release multiple objects.

type HeapProfilerGetObjectByHeapObjectIDReply 

type HeapProfilerGetObjectByHeapObjectIDReply struct {
	Result cdptype.RuntimeRemoteObject `json:"result"` // Evaluation result.
}

HeapProfilerGetObjectByHeapObjectIDReply represents the return values for GetObjectByHeapObjectID in the HeapProfiler domain.

type HeapProfilerStartSamplingArgs 

type HeapProfilerStartSamplingArgs struct {
	SamplingInterval *float64 `json:"samplingInterval,omitempty"` // Average sample interval in bytes. Poisson distribution is used for the intervals. The default value is 32768 bytes.
}

HeapProfilerStartSamplingArgs represents the arguments for StartSampling in the HeapProfiler domain.

func NewHeapProfilerStartSamplingArgs 

func NewHeapProfilerStartSamplingArgs() *HeapProfilerStartSamplingArgs

NewHeapProfilerStartSamplingArgs initializes HeapProfilerStartSamplingArgs with the required arguments.

func (*HeapProfilerStartSamplingArgs) SetSamplingInterval 

func (a *HeapProfilerStartSamplingArgs) SetSamplingInterval(samplingInterval float64) *HeapProfilerStartSamplingArgs

SetSamplingInterval sets the SamplingInterval optional argument. Average sample interval in bytes. Poisson distribution is used for the intervals. The default value is 32768 bytes.

type HeapProfilerStartTrackingHeapObjectsArgs 

type HeapProfilerStartTrackingHeapObjectsArgs struct {
	TrackAllocations *bool `json:"trackAllocations,omitempty"` //
}

HeapProfilerStartTrackingHeapObjectsArgs represents the arguments for StartTrackingHeapObjects in the HeapProfiler domain.

func NewHeapProfilerStartTrackingHeapObjectsArgs 

func NewHeapProfilerStartTrackingHeapObjectsArgs() *HeapProfilerStartTrackingHeapObjectsArgs

NewHeapProfilerStartTrackingHeapObjectsArgs initializes HeapProfilerStartTrackingHeapObjectsArgs with the required arguments.

func (*HeapProfilerStartTrackingHeapObjectsArgs) SetTrackAllocations 

func (a *HeapProfilerStartTrackingHeapObjectsArgs) SetTrackAllocations(trackAllocations bool) *HeapProfilerStartTrackingHeapObjectsArgs

SetTrackAllocations sets the TrackAllocations optional argument.

type HeapProfilerStopSamplingReply 

type HeapProfilerStopSamplingReply struct {
	Profile cdptype.HeapProfilerSamplingHeapProfile `json:"profile"` // Recorded sampling heap profile.
}

HeapProfilerStopSamplingReply represents the return values for StopSampling in the HeapProfiler domain.

type HeapProfilerStopTrackingHeapObjectsArgs 

type HeapProfilerStopTrackingHeapObjectsArgs struct {
	ReportProgress *bool `json:"reportProgress,omitempty"` // If true 'reportHeapSnapshotProgress' events will be generated while snapshot is being taken when the tracking is stopped.
}

HeapProfilerStopTrackingHeapObjectsArgs represents the arguments for StopTrackingHeapObjects in the HeapProfiler domain.

func NewHeapProfilerStopTrackingHeapObjectsArgs 

func NewHeapProfilerStopTrackingHeapObjectsArgs() *HeapProfilerStopTrackingHeapObjectsArgs

NewHeapProfilerStopTrackingHeapObjectsArgs initializes HeapProfilerStopTrackingHeapObjectsArgs with the required arguments.

func (*HeapProfilerStopTrackingHeapObjectsArgs) SetReportProgress 

func (a *HeapProfilerStopTrackingHeapObjectsArgs) SetReportProgress(reportProgress bool) *HeapProfilerStopTrackingHeapObjectsArgs

SetReportProgress sets the ReportProgress optional argument. If true 'reportHeapSnapshotProgress' events will be generated while snapshot is being taken when the tracking is stopped.

type HeapProfilerTakeHeapSnapshotArgs 

type HeapProfilerTakeHeapSnapshotArgs struct {
	ReportProgress *bool `json:"reportProgress,omitempty"` // If true 'reportHeapSnapshotProgress' events will be generated while snapshot is being taken.
}

HeapProfilerTakeHeapSnapshotArgs represents the arguments for TakeHeapSnapshot in the HeapProfiler domain.

func NewHeapProfilerTakeHeapSnapshotArgs 

func NewHeapProfilerTakeHeapSnapshotArgs() *HeapProfilerTakeHeapSnapshotArgs

NewHeapProfilerTakeHeapSnapshotArgs initializes HeapProfilerTakeHeapSnapshotArgs with the required arguments.

func (*HeapProfilerTakeHeapSnapshotArgs) SetReportProgress 

func (a *HeapProfilerTakeHeapSnapshotArgs) SetReportProgress(reportProgress bool) *HeapProfilerTakeHeapSnapshotArgs

SetReportProgress sets the ReportProgress optional argument. If true 'reportHeapSnapshotProgress' events will be generated while snapshot is being taken.

type IOCloseArgs 

type IOCloseArgs struct {
	Handle cdptype.IOStreamHandle `json:"handle"` // Handle of the stream to close.
}

IOCloseArgs represents the arguments for Close in the IO domain.

func NewIOCloseArgs 

func NewIOCloseArgs(handle cdptype.IOStreamHandle) *IOCloseArgs

NewIOCloseArgs initializes IOCloseArgs with the required arguments.

type IOReadArgs 

type IOReadArgs struct {
	Handle cdptype.IOStreamHandle `json:"handle"`           // Handle of the stream to read.
	Offset *int                   `json:"offset,omitempty"` // Seek to the specified offset before reading (if not specificed, proceed with offset following the last read).
	Size   *int                   `json:"size,omitempty"`   // Maximum number of bytes to read (left upon the agent discretion if not specified).
}

IOReadArgs represents the arguments for Read in the IO domain.

func NewIOReadArgs 

func NewIOReadArgs(handle cdptype.IOStreamHandle) *IOReadArgs

NewIOReadArgs initializes IOReadArgs with the required arguments.

func (*IOReadArgs) SetOffset 

func (a *IOReadArgs) SetOffset(offset int) *IOReadArgs

SetOffset sets the Offset optional argument. Seek to the specified offset before reading (if not specificed, proceed with offset following the last read).

func (*IOReadArgs) SetSize 

func (a *IOReadArgs) SetSize(size int) *IOReadArgs

SetSize sets the Size optional argument. Maximum number of bytes to read (left upon the agent discretion if not specified).

type IOReadReply 

type IOReadReply struct {
	Data string `json:"data"` // Data that were read.
	EOF  bool   `json:"eof"`  // Set if the end-of-file condition occurred while reading.
}

IOReadReply represents the return values for Read in the IO domain.

type IndexedDBClearObjectStoreArgs 

type IndexedDBClearObjectStoreArgs struct {
	SecurityOrigin  string `json:"securityOrigin"`  // Security origin.
	DatabaseName    string `json:"databaseName"`    // Database name.
	ObjectStoreName string `json:"objectStoreName"` // Object store name.
}

IndexedDBClearObjectStoreArgs represents the arguments for ClearObjectStore in the IndexedDB domain.

func NewIndexedDBClearObjectStoreArgs 

func NewIndexedDBClearObjectStoreArgs(securityOrigin string, databaseName string, objectStoreName string) *IndexedDBClearObjectStoreArgs

NewIndexedDBClearObjectStoreArgs initializes IndexedDBClearObjectStoreArgs with the required arguments.

type IndexedDBDeleteDatabaseArgs 

type IndexedDBDeleteDatabaseArgs struct {
	SecurityOrigin string `json:"securityOrigin"` // Security origin.
	DatabaseName   string `json:"databaseName"`   // Database name.
}

IndexedDBDeleteDatabaseArgs represents the arguments for DeleteDatabase in the IndexedDB domain.

func NewIndexedDBDeleteDatabaseArgs 

func NewIndexedDBDeleteDatabaseArgs(securityOrigin string, databaseName string) *IndexedDBDeleteDatabaseArgs

NewIndexedDBDeleteDatabaseArgs initializes IndexedDBDeleteDatabaseArgs with the required arguments.

type IndexedDBRequestDataArgs 

type IndexedDBRequestDataArgs struct {
	SecurityOrigin  string                     `json:"securityOrigin"`     // Security origin.
	DatabaseName    string                     `json:"databaseName"`       // Database name.
	ObjectStoreName string                     `json:"objectStoreName"`    // Object store name.
	IndexName       string                     `json:"indexName"`          // Index name, empty string for object store data requests.
	SkipCount       int                        `json:"skipCount"`          // Number of records to skip.
	PageSize        int                        `json:"pageSize"`           // Number of records to fetch.
	KeyRange        *cdptype.IndexedDBKeyRange `json:"keyRange,omitempty"` // Key range.
}

IndexedDBRequestDataArgs represents the arguments for RequestData in the IndexedDB domain.

func NewIndexedDBRequestDataArgs 

func NewIndexedDBRequestDataArgs(securityOrigin string, databaseName string, objectStoreName string, indexName string, skipCount int, pageSize int) *IndexedDBRequestDataArgs

NewIndexedDBRequestDataArgs initializes IndexedDBRequestDataArgs with the required arguments.

func (*IndexedDBRequestDataArgs) SetKeyRange 

func (a *IndexedDBRequestDataArgs) SetKeyRange(keyRange cdptype.IndexedDBKeyRange) *IndexedDBRequestDataArgs

SetKeyRange sets the KeyRange optional argument. Key range.

type IndexedDBRequestDataReply 

type IndexedDBRequestDataReply struct {
	ObjectStoreDataEntries []cdptype.IndexedDBDataEntry `json:"objectStoreDataEntries"` // Array of object store data entries.
	HasMore                bool                         `json:"hasMore"`                // If true, there are more entries to fetch in the given range.
}

IndexedDBRequestDataReply represents the return values for RequestData in the IndexedDB domain.

type IndexedDBRequestDatabaseArgs 

type IndexedDBRequestDatabaseArgs struct {
	SecurityOrigin string `json:"securityOrigin"` // Security origin.
	DatabaseName   string `json:"databaseName"`   // Database name.
}

IndexedDBRequestDatabaseArgs represents the arguments for RequestDatabase in the IndexedDB domain.

func NewIndexedDBRequestDatabaseArgs 

func NewIndexedDBRequestDatabaseArgs(securityOrigin string, databaseName string) *IndexedDBRequestDatabaseArgs

NewIndexedDBRequestDatabaseArgs initializes IndexedDBRequestDatabaseArgs with the required arguments.

type IndexedDBRequestDatabaseNamesArgs 

type IndexedDBRequestDatabaseNamesArgs struct {
	SecurityOrigin string `json:"securityOrigin"` // Security origin.
}

IndexedDBRequestDatabaseNamesArgs represents the arguments for RequestDatabaseNames in the IndexedDB domain.

func NewIndexedDBRequestDatabaseNamesArgs 

func NewIndexedDBRequestDatabaseNamesArgs(securityOrigin string) *IndexedDBRequestDatabaseNamesArgs

NewIndexedDBRequestDatabaseNamesArgs initializes IndexedDBRequestDatabaseNamesArgs with the required arguments.

type IndexedDBRequestDatabaseNamesReply 

type IndexedDBRequestDatabaseNamesReply struct {
	DatabaseNames []string `json:"databaseNames"` // Database names for origin.
}

IndexedDBRequestDatabaseNamesReply represents the return values for RequestDatabaseNames in the IndexedDB domain.

type IndexedDBRequestDatabaseReply 

type IndexedDBRequestDatabaseReply struct {
	DatabaseWithObjectStores cdptype.IndexedDBDatabaseWithObjectStores `json:"databaseWithObjectStores"` // Database with an array of object stores.
}

IndexedDBRequestDatabaseReply represents the return values for RequestDatabase in the IndexedDB domain.

type InputDispatchKeyEventArgs 

type InputDispatchKeyEventArgs struct {
	Type                  string            `json:"type"`                            // Type of the key event.
	Modifiers             *int              `json:"modifiers,omitempty"`             // Bit field representing pressed modifier keys. Alt=1, Ctrl=2, Meta/Command=4, Shift=8 (default: 0).
	Timestamp             cdptype.Timestamp `json:"timestamp,omitempty"`             // Time at which the event occurred. Measured in UTC time in seconds since January 1, 1970 (default: current time).
	Text                  *string           `json:"text,omitempty"`                  // Text as generated by processing a virtual key code with a keyboard layout. Not needed for for keyUp and rawKeyDown events (default: "")
	UnmodifiedText        *string           `json:"unmodifiedText,omitempty"`        // Text that would have been generated by the keyboard if no modifiers were pressed (except for shift). Useful for shortcut (accelerator) key handling (default: "").
	KeyIdentifier         *string           `json:"keyIdentifier,omitempty"`         // Unique key identifier (e.g., 'U+0041') (default: "").
	Code                  *string           `json:"code,omitempty"`                  // Unique DOM defined string value for each physical key (e.g., 'KeyA') (default: "").
	Key                   *string           `json:"key,omitempty"`                   // Unique DOM defined string value describing the meaning of the key in the context of active modifiers, keyboard layout, etc (e.g., 'AltGr') (default: "").
	WindowsVirtualKeyCode *int              `json:"windowsVirtualKeyCode,omitempty"` // Windows virtual key code (default: 0).
	NativeVirtualKeyCode  *int              `json:"nativeVirtualKeyCode,omitempty"`  // Native virtual key code (default: 0).
	AutoRepeat            *bool             `json:"autoRepeat,omitempty"`            // Whether the event was generated from auto repeat (default: false).
	IsKeypad              *bool             `json:"isKeypad,omitempty"`              // Whether the event was generated from the keypad (default: false).
	IsSystemKey           *bool             `json:"isSystemKey,omitempty"`           // Whether the event was a system key event (default: false).
}

InputDispatchKeyEventArgs represents the arguments for DispatchKeyEvent in the Input domain.

func NewInputDispatchKeyEventArgs 

func NewInputDispatchKeyEventArgs(typ string) *InputDispatchKeyEventArgs

NewInputDispatchKeyEventArgs initializes InputDispatchKeyEventArgs with the required arguments.

func (*InputDispatchKeyEventArgs) SetAutoRepeat 

func (a *InputDispatchKeyEventArgs) SetAutoRepeat(autoRepeat bool) *InputDispatchKeyEventArgs

SetAutoRepeat sets the AutoRepeat optional argument. Whether the event was generated from auto repeat (default: false).

func (*InputDispatchKeyEventArgs) SetCode 

func (a *InputDispatchKeyEventArgs) SetCode(code string) *InputDispatchKeyEventArgs

SetCode sets the Code optional argument. Unique DOM defined string value for each physical key (e.g., 'KeyA') (default: "").

func (*InputDispatchKeyEventArgs) SetIsKeypad 

func (a *InputDispatchKeyEventArgs) SetIsKeypad(isKeypad bool) *InputDispatchKeyEventArgs

SetIsKeypad sets the IsKeypad optional argument. Whether the event was generated from the keypad (default: false).

func (*InputDispatchKeyEventArgs) SetIsSystemKey 

func (a *InputDispatchKeyEventArgs) SetIsSystemKey(isSystemKey bool) *InputDispatchKeyEventArgs

SetIsSystemKey sets the IsSystemKey optional argument. Whether the event was a system key event (default: false).

func (*InputDispatchKeyEventArgs) SetKey 

func (a *InputDispatchKeyEventArgs) SetKey(key string) *InputDispatchKeyEventArgs

SetKey sets the Key optional argument. Unique DOM defined string value describing the meaning of the key in the context of active modifiers, keyboard layout, etc (e.g., 'AltGr') (default: "").

func (*InputDispatchKeyEventArgs) SetKeyIdentifier 

func (a *InputDispatchKeyEventArgs) SetKeyIdentifier(keyIdentifier string) *InputDispatchKeyEventArgs

SetKeyIdentifier sets the KeyIdentifier optional argument. Unique key identifier (e.g., 'U+0041') (default: "").

func (*InputDispatchKeyEventArgs) SetModifiers 

func (a *InputDispatchKeyEventArgs) SetModifiers(modifiers int) *InputDispatchKeyEventArgs

SetModifiers sets the Modifiers optional argument. Bit field representing pressed modifier keys. Alt=1, Ctrl=2, Meta/Command=4, Shift=8 (default: 0).

func (*InputDispatchKeyEventArgs) SetNativeVirtualKeyCode 

func (a *InputDispatchKeyEventArgs) SetNativeVirtualKeyCode(nativeVirtualKeyCode int) *InputDispatchKeyEventArgs

SetNativeVirtualKeyCode sets the NativeVirtualKeyCode optional argument. Native virtual key code (default: 0).

func (*InputDispatchKeyEventArgs) SetText 

func (a *InputDispatchKeyEventArgs) SetText(text string) *InputDispatchKeyEventArgs

SetText sets the Text optional argument. Text as generated by processing a virtual key code with a keyboard layout. Not needed for for keyUp and rawKeyDown events (default: "")

func (*InputDispatchKeyEventArgs) SetTimestamp 

func (a *InputDispatchKeyEventArgs) SetTimestamp(timestamp cdptype.Timestamp) *InputDispatchKeyEventArgs

SetTimestamp sets the Timestamp optional argument. Time at which the event occurred. Measured in UTC time in seconds since January 1, 1970 (default: current time).

func (*InputDispatchKeyEventArgs) SetUnmodifiedText 

func (a *InputDispatchKeyEventArgs) SetUnmodifiedText(unmodifiedText string) *InputDispatchKeyEventArgs

SetUnmodifiedText sets the UnmodifiedText optional argument. Text that would have been generated by the keyboard if no modifiers were pressed (except for shift). Useful for shortcut (accelerator) key handling (default: "").

func (*InputDispatchKeyEventArgs) SetWindowsVirtualKeyCode 

func (a *InputDispatchKeyEventArgs) SetWindowsVirtualKeyCode(windowsVirtualKeyCode int) *InputDispatchKeyEventArgs

SetWindowsVirtualKeyCode sets the WindowsVirtualKeyCode optional argument. Windows virtual key code (default: 0).

type InputDispatchMouseEventArgs 

type InputDispatchMouseEventArgs struct {
	Type       string            `json:"type"`                 // Type of the mouse event.
	X          int               `json:"x"`                    // X coordinate of the event relative to the main frame's viewport.
	Y          int               `json:"y"`                    // Y coordinate of the event relative to the main frame's viewport. 0 refers to the top of the viewport and Y increases as it proceeds towards the bottom of the viewport.
	Modifiers  *int              `json:"modifiers,omitempty"`  // Bit field representing pressed modifier keys. Alt=1, Ctrl=2, Meta/Command=4, Shift=8 (default: 0).
	Timestamp  cdptype.Timestamp `json:"timestamp,omitempty"`  // Time at which the event occurred. Measured in UTC time in seconds since January 1, 1970 (default: current time).
	Button     *string           `json:"button,omitempty"`     // Mouse button (default: "none").
	ClickCount *int              `json:"clickCount,omitempty"` // Number of times the mouse button was clicked (default: 0).
}

InputDispatchMouseEventArgs represents the arguments for DispatchMouseEvent in the Input domain.

func NewInputDispatchMouseEventArgs 

func NewInputDispatchMouseEventArgs(typ string, x int, y int) *InputDispatchMouseEventArgs

NewInputDispatchMouseEventArgs initializes InputDispatchMouseEventArgs with the required arguments.

func (*InputDispatchMouseEventArgs) SetButton 

func (a *InputDispatchMouseEventArgs) SetButton(button string) *InputDispatchMouseEventArgs

SetButton sets the Button optional argument. Mouse button (default: "none").

func (*InputDispatchMouseEventArgs) SetClickCount 

func (a *InputDispatchMouseEventArgs) SetClickCount(clickCount int) *InputDispatchMouseEventArgs

SetClickCount sets the ClickCount optional argument. Number of times the mouse button was clicked (default: 0).

func (*InputDispatchMouseEventArgs) SetModifiers 

func (a *InputDispatchMouseEventArgs) SetModifiers(modifiers int) *InputDispatchMouseEventArgs

SetModifiers sets the Modifiers optional argument. Bit field representing pressed modifier keys. Alt=1, Ctrl=2, Meta/Command=4, Shift=8 (default: 0).

func (*InputDispatchMouseEventArgs) SetTimestamp 

func (a *InputDispatchMouseEventArgs) SetTimestamp(timestamp cdptype.Timestamp) *InputDispatchMouseEventArgs

SetTimestamp sets the Timestamp optional argument. Time at which the event occurred. Measured in UTC time in seconds since January 1, 1970 (default: current time).

type InputDispatchTouchEventArgs 

type InputDispatchTouchEventArgs struct {
	Type        string                    `json:"type"`                // Type of the touch event.
	TouchPoints []cdptype.InputTouchPoint `json:"touchPoints"`         // Touch points.
	Modifiers   *int                      `json:"modifiers,omitempty"` // Bit field representing pressed modifier keys. Alt=1, Ctrl=2, Meta/Command=4, Shift=8 (default: 0).
	Timestamp   cdptype.Timestamp         `json:"timestamp,omitempty"` // Time at which the event occurred. Measured in UTC time in seconds since January 1, 1970 (default: current time).
}

InputDispatchTouchEventArgs represents the arguments for DispatchTouchEvent in the Input domain.

func NewInputDispatchTouchEventArgs 

func NewInputDispatchTouchEventArgs(typ string, touchPoints []cdptype.InputTouchPoint) *InputDispatchTouchEventArgs

NewInputDispatchTouchEventArgs initializes InputDispatchTouchEventArgs with the required arguments.

func (*InputDispatchTouchEventArgs) SetModifiers 

func (a *InputDispatchTouchEventArgs) SetModifiers(modifiers int) *InputDispatchTouchEventArgs

SetModifiers sets the Modifiers optional argument. Bit field representing pressed modifier keys. Alt=1, Ctrl=2, Meta/Command=4, Shift=8 (default: 0).

func (*InputDispatchTouchEventArgs) SetTimestamp 

func (a *InputDispatchTouchEventArgs) SetTimestamp(timestamp cdptype.Timestamp) *InputDispatchTouchEventArgs

SetTimestamp sets the Timestamp optional argument. Time at which the event occurred. Measured in UTC time in seconds since January 1, 1970 (default: current time).

type InputEmulateTouchFromMouseEventArgs 

type InputEmulateTouchFromMouseEventArgs struct {
	Type       string            `json:"type"`                 // Type of the mouse event.
	X          int               `json:"x"`                    // X coordinate of the mouse pointer in DIP.
	Y          int               `json:"y"`                    // Y coordinate of the mouse pointer in DIP.
	Timestamp  cdptype.Timestamp `json:"timestamp"`            // Time at which the event occurred. Measured in UTC time in seconds since January 1, 1970.
	Button     string            `json:"button"`               // Mouse button.
	DeltaX     *float64          `json:"deltaX,omitempty"`     // X delta in DIP for mouse wheel event (default: 0).
	DeltaY     *float64          `json:"deltaY,omitempty"`     // Y delta in DIP for mouse wheel event (default: 0).
	Modifiers  *int              `json:"modifiers,omitempty"`  // Bit field representing pressed modifier keys. Alt=1, Ctrl=2, Meta/Command=4, Shift=8 (default: 0).
	ClickCount *int              `json:"clickCount,omitempty"` // Number of times the mouse button was clicked (default: 0).
}

InputEmulateTouchFromMouseEventArgs represents the arguments for EmulateTouchFromMouseEvent in the Input domain.

func NewInputEmulateTouchFromMouseEventArgs 

func NewInputEmulateTouchFromMouseEventArgs(typ string, x int, y int, timestamp cdptype.Timestamp, button string) *InputEmulateTouchFromMouseEventArgs

NewInputEmulateTouchFromMouseEventArgs initializes InputEmulateTouchFromMouseEventArgs with the required arguments.

func (*InputEmulateTouchFromMouseEventArgs) SetClickCount 

func (a *InputEmulateTouchFromMouseEventArgs) SetClickCount(clickCount int) *InputEmulateTouchFromMouseEventArgs

SetClickCount sets the ClickCount optional argument. Number of times the mouse button was clicked (default: 0).

func (*InputEmulateTouchFromMouseEventArgs) SetDeltaX 

func (a *InputEmulateTouchFromMouseEventArgs) SetDeltaX(deltaX float64) *InputEmulateTouchFromMouseEventArgs

SetDeltaX sets the DeltaX optional argument. X delta in DIP for mouse wheel event (default: 0).

func (*InputEmulateTouchFromMouseEventArgs) SetDeltaY 

func (a *InputEmulateTouchFromMouseEventArgs) SetDeltaY(deltaY float64) *InputEmulateTouchFromMouseEventArgs

SetDeltaY sets the DeltaY optional argument. Y delta in DIP for mouse wheel event (default: 0).

func (*InputEmulateTouchFromMouseEventArgs) SetModifiers 

func (a *InputEmulateTouchFromMouseEventArgs) SetModifiers(modifiers int) *InputEmulateTouchFromMouseEventArgs

SetModifiers sets the Modifiers optional argument. Bit field representing pressed modifier keys. Alt=1, Ctrl=2, Meta/Command=4, Shift=8 (default: 0).

type InputSetIgnoreInputEventsArgs 

type InputSetIgnoreInputEventsArgs struct {
	Ignore bool `json:"ignore"` // Ignores input events processing when set to true.
}

InputSetIgnoreInputEventsArgs represents the arguments for SetIgnoreInputEvents in the Input domain.

func NewInputSetIgnoreInputEventsArgs 

func NewInputSetIgnoreInputEventsArgs(ignore bool) *InputSetIgnoreInputEventsArgs

NewInputSetIgnoreInputEventsArgs initializes InputSetIgnoreInputEventsArgs with the required arguments.

type InputSynthesizePinchGestureArgs 

type InputSynthesizePinchGestureArgs struct {
	X                 int                            `json:"x"`                           // X coordinate of the start of the gesture in CSS pixels.
	Y                 int                            `json:"y"`                           // Y coordinate of the start of the gesture in CSS pixels.
	ScaleFactor       float64                        `json:"scaleFactor"`                 // Relative scale factor after zooming (>1.0 zooms in, <1.0 zooms out).
	RelativeSpeed     *int                           `json:"relativeSpeed,omitempty"`     // Relative pointer speed in pixels per second (default: 800).
	GestureSourceType cdptype.InputGestureSourceType `json:"gestureSourceType,omitempty"` // Which type of input events to be generated (default: 'default', which queries the platform for the preferred input type).
}

InputSynthesizePinchGestureArgs represents the arguments for SynthesizePinchGesture in the Input domain.

func NewInputSynthesizePinchGestureArgs 

func NewInputSynthesizePinchGestureArgs(x int, y int, scaleFactor float64) *InputSynthesizePinchGestureArgs

NewInputSynthesizePinchGestureArgs initializes InputSynthesizePinchGestureArgs with the required arguments.

func (*InputSynthesizePinchGestureArgs) SetGestureSourceType 

func (a *InputSynthesizePinchGestureArgs) SetGestureSourceType(gestureSourceType cdptype.InputGestureSourceType) *InputSynthesizePinchGestureArgs

SetGestureSourceType sets the GestureSourceType optional argument. Which type of input events to be generated (default: 'default', which queries the platform for the preferred input type).

func (*InputSynthesizePinchGestureArgs) SetRelativeSpeed 

func (a *InputSynthesizePinchGestureArgs) SetRelativeSpeed(relativeSpeed int) *InputSynthesizePinchGestureArgs

SetRelativeSpeed sets the RelativeSpeed optional argument. Relative pointer speed in pixels per second (default: 800).

type InputSynthesizeScrollGestureArgs 

type InputSynthesizeScrollGestureArgs struct {
	X                     int                            `json:"x"`                               // X coordinate of the start of the gesture in CSS pixels.
	Y                     int                            `json:"y"`                               // Y coordinate of the start of the gesture in CSS pixels.
	XDistance             *int                           `json:"xDistance,omitempty"`             // The distance to scroll along the X axis (positive to scroll left).
	YDistance             *int                           `json:"yDistance,omitempty"`             // The distance to scroll along the Y axis (positive to scroll up).
	XOverscroll           *int                           `json:"xOverscroll,omitempty"`           // The number of additional pixels to scroll back along the X axis, in addition to the given distance.
	YOverscroll           *int                           `json:"yOverscroll,omitempty"`           // The number of additional pixels to scroll back along the Y axis, in addition to the given distance.
	PreventFling          *bool                          `json:"preventFling,omitempty"`          // Prevent fling (default: true).
	Speed                 *int                           `json:"speed,omitempty"`                 // Swipe speed in pixels per second (default: 800).
	GestureSourceType     cdptype.InputGestureSourceType `json:"gestureSourceType,omitempty"`     // Which type of input events to be generated (default: 'default', which queries the platform for the preferred input type).
	RepeatCount           *int                           `json:"repeatCount,omitempty"`           // The number of times to repeat the gesture (default: 0).
	RepeatDelayMs         *int                           `json:"repeatDelayMs,omitempty"`         // The number of milliseconds delay between each repeat. (default: 250).
	InteractionMarkerName *string                        `json:"interactionMarkerName,omitempty"` // The name of the interaction markers to generate, if not empty (default: "").
}

InputSynthesizeScrollGestureArgs represents the arguments for SynthesizeScrollGesture in the Input domain.

func NewInputSynthesizeScrollGestureArgs 

func NewInputSynthesizeScrollGestureArgs(x int, y int) *InputSynthesizeScrollGestureArgs

NewInputSynthesizeScrollGestureArgs initializes InputSynthesizeScrollGestureArgs with the required arguments.

func (*InputSynthesizeScrollGestureArgs) SetGestureSourceType 

func (a *InputSynthesizeScrollGestureArgs) SetGestureSourceType(gestureSourceType cdptype.InputGestureSourceType) *InputSynthesizeScrollGestureArgs

SetGestureSourceType sets the GestureSourceType optional argument. Which type of input events to be generated (default: 'default', which queries the platform for the preferred input type).

func (*InputSynthesizeScrollGestureArgs) SetInteractionMarkerName 

func (a *InputSynthesizeScrollGestureArgs) SetInteractionMarkerName(interactionMarkerName string) *InputSynthesizeScrollGestureArgs

SetInteractionMarkerName sets the InteractionMarkerName optional argument. The name of the interaction markers to generate, if not empty (default: "").

func (*InputSynthesizeScrollGestureArgs) SetPreventFling 

func (a *InputSynthesizeScrollGestureArgs) SetPreventFling(preventFling bool) *InputSynthesizeScrollGestureArgs

SetPreventFling sets the PreventFling optional argument. Prevent fling (default: true).

func (*InputSynthesizeScrollGestureArgs) SetRepeatCount 

func (a *InputSynthesizeScrollGestureArgs) SetRepeatCount(repeatCount int) *InputSynthesizeScrollGestureArgs

SetRepeatCount sets the RepeatCount optional argument. The number of times to repeat the gesture (default: 0).

func (*InputSynthesizeScrollGestureArgs) SetRepeatDelayMs 

func (a *InputSynthesizeScrollGestureArgs) SetRepeatDelayMs(repeatDelayMs int) *InputSynthesizeScrollGestureArgs

SetRepeatDelayMs sets the RepeatDelayMs optional argument. The number of milliseconds delay between each repeat. (default: 250).

func (*InputSynthesizeScrollGestureArgs) SetSpeed 

func (a *InputSynthesizeScrollGestureArgs) SetSpeed(speed int) *InputSynthesizeScrollGestureArgs

SetSpeed sets the Speed optional argument. Swipe speed in pixels per second (default: 800).

func (*InputSynthesizeScrollGestureArgs) SetXDistance 

func (a *InputSynthesizeScrollGestureArgs) SetXDistance(xDistance int) *InputSynthesizeScrollGestureArgs

SetXDistance sets the XDistance optional argument. The distance to scroll along the X axis (positive to scroll left).

func (*InputSynthesizeScrollGestureArgs) SetXOverscroll 

func (a *InputSynthesizeScrollGestureArgs) SetXOverscroll(xOverscroll int) *InputSynthesizeScrollGestureArgs

SetXOverscroll sets the XOverscroll optional argument. The number of additional pixels to scroll back along the X axis, in addition to the given distance.

func (*InputSynthesizeScrollGestureArgs) SetYDistance 

func (a *InputSynthesizeScrollGestureArgs) SetYDistance(yDistance int) *InputSynthesizeScrollGestureArgs

SetYDistance sets the YDistance optional argument. The distance to scroll along the Y axis (positive to scroll up).

func (*InputSynthesizeScrollGestureArgs) SetYOverscroll 

func (a *InputSynthesizeScrollGestureArgs) SetYOverscroll(yOverscroll int) *InputSynthesizeScrollGestureArgs

SetYOverscroll sets the YOverscroll optional argument. The number of additional pixels to scroll back along the Y axis, in addition to the given distance.

type InputSynthesizeTapGestureArgs 

type InputSynthesizeTapGestureArgs struct {
	X                 int                            `json:"x"`                           // X coordinate of the start of the gesture in CSS pixels.
	Y                 int                            `json:"y"`                           // Y coordinate of the start of the gesture in CSS pixels.
	Duration          *int                           `json:"duration,omitempty"`          // Duration between touchdown and touchup events in ms (default: 50).
	TapCount          *int                           `json:"tapCount,omitempty"`          // Number of times to perform the tap (e.g. 2 for double tap, default: 1).
	GestureSourceType cdptype.InputGestureSourceType `json:"gestureSourceType,omitempty"` // Which type of input events to be generated (default: 'default', which queries the platform for the preferred input type).
}

InputSynthesizeTapGestureArgs represents the arguments for SynthesizeTapGesture in the Input domain.

func NewInputSynthesizeTapGestureArgs 

func NewInputSynthesizeTapGestureArgs(x int, y int) *InputSynthesizeTapGestureArgs

NewInputSynthesizeTapGestureArgs initializes InputSynthesizeTapGestureArgs with the required arguments.

func (*InputSynthesizeTapGestureArgs) SetDuration 

func (a *InputSynthesizeTapGestureArgs) SetDuration(duration int) *InputSynthesizeTapGestureArgs

SetDuration sets the Duration optional argument. Duration between touchdown and touchup events in ms (default: 50).

func (*InputSynthesizeTapGestureArgs) SetGestureSourceType 

func (a *InputSynthesizeTapGestureArgs) SetGestureSourceType(gestureSourceType cdptype.InputGestureSourceType) *InputSynthesizeTapGestureArgs

SetGestureSourceType sets the GestureSourceType optional argument. Which type of input events to be generated (default: 'default', which queries the platform for the preferred input type).

func (*InputSynthesizeTapGestureArgs) SetTapCount 

func (a *InputSynthesizeTapGestureArgs) SetTapCount(tapCount int) *InputSynthesizeTapGestureArgs

SetTapCount sets the TapCount optional argument. Number of times to perform the tap (e.g. 2 for double tap, default: 1).

type LayerTreeCompositingReasonsArgs 

type LayerTreeCompositingReasonsArgs struct {
	LayerID cdptype.LayerTreeLayerID `json:"layerId"` // The id of the layer for which we want to get the reasons it was composited.
}

LayerTreeCompositingReasonsArgs represents the arguments for CompositingReasons in the LayerTree domain.

func NewLayerTreeCompositingReasonsArgs 

func NewLayerTreeCompositingReasonsArgs(layerID cdptype.LayerTreeLayerID) *LayerTreeCompositingReasonsArgs

NewLayerTreeCompositingReasonsArgs initializes LayerTreeCompositingReasonsArgs with the required arguments.

type LayerTreeCompositingReasonsReply 

type LayerTreeCompositingReasonsReply struct {
	CompositingReasons []string `json:"compositingReasons"` // A list of strings specifying reasons for the given layer to become composited.
}

LayerTreeCompositingReasonsReply represents the return values for CompositingReasons in the LayerTree domain.

type LayerTreeLoadSnapshotArgs 

type LayerTreeLoadSnapshotArgs struct {
	Tiles []cdptype.LayerTreePictureTile `json:"tiles"` // An array of tiles composing the snapshot.
}

LayerTreeLoadSnapshotArgs represents the arguments for LoadSnapshot in the LayerTree domain.

func NewLayerTreeLoadSnapshotArgs 

func NewLayerTreeLoadSnapshotArgs(tiles []cdptype.LayerTreePictureTile) *LayerTreeLoadSnapshotArgs

NewLayerTreeLoadSnapshotArgs initializes LayerTreeLoadSnapshotArgs with the required arguments.

type LayerTreeLoadSnapshotReply 

type LayerTreeLoadSnapshotReply struct {
	SnapshotID cdptype.LayerTreeSnapshotID `json:"snapshotId"` // The id of the snapshot.
}

LayerTreeLoadSnapshotReply represents the return values for LoadSnapshot in the LayerTree domain.

type LayerTreeMakeSnapshotArgs 

type LayerTreeMakeSnapshotArgs struct {
	LayerID cdptype.LayerTreeLayerID `json:"layerId"` // The id of the layer.
}

LayerTreeMakeSnapshotArgs represents the arguments for MakeSnapshot in the LayerTree domain.

func NewLayerTreeMakeSnapshotArgs 

func NewLayerTreeMakeSnapshotArgs(layerID cdptype.LayerTreeLayerID) *LayerTreeMakeSnapshotArgs

NewLayerTreeMakeSnapshotArgs initializes LayerTreeMakeSnapshotArgs with the required arguments.

type LayerTreeMakeSnapshotReply 

type LayerTreeMakeSnapshotReply struct {
	SnapshotID cdptype.LayerTreeSnapshotID `json:"snapshotId"` // The id of the layer snapshot.
}

LayerTreeMakeSnapshotReply represents the return values for MakeSnapshot in the LayerTree domain.

type LayerTreeProfileSnapshotArgs 

type LayerTreeProfileSnapshotArgs struct {
	SnapshotID     cdptype.LayerTreeSnapshotID `json:"snapshotId"`               // The id of the layer snapshot.
	MinRepeatCount *int                        `json:"minRepeatCount,omitempty"` // The maximum number of times to replay the snapshot (1, if not specified).
	MinDuration    *float64                    `json:"minDuration,omitempty"`    // The minimum duration (in seconds) to replay the snapshot.
	ClipRect       *cdptype.DOMRect            `json:"clipRect,omitempty"`       // The clip rectangle to apply when replaying the snapshot.
}

LayerTreeProfileSnapshotArgs represents the arguments for ProfileSnapshot in the LayerTree domain.

func NewLayerTreeProfileSnapshotArgs 

func NewLayerTreeProfileSnapshotArgs(snapshotID cdptype.LayerTreeSnapshotID) *LayerTreeProfileSnapshotArgs

NewLayerTreeProfileSnapshotArgs initializes LayerTreeProfileSnapshotArgs with the required arguments.

func (*LayerTreeProfileSnapshotArgs) SetClipRect 

func (a *LayerTreeProfileSnapshotArgs) SetClipRect(clipRect cdptype.DOMRect) *LayerTreeProfileSnapshotArgs

SetClipRect sets the ClipRect optional argument. The clip rectangle to apply when replaying the snapshot.

func (*LayerTreeProfileSnapshotArgs) SetMinDuration 

func (a *LayerTreeProfileSnapshotArgs) SetMinDuration(minDuration float64) *LayerTreeProfileSnapshotArgs

SetMinDuration sets the MinDuration optional argument. The minimum duration (in seconds) to replay the snapshot.

func (*LayerTreeProfileSnapshotArgs) SetMinRepeatCount 

func (a *LayerTreeProfileSnapshotArgs) SetMinRepeatCount(minRepeatCount int) *LayerTreeProfileSnapshotArgs

SetMinRepeatCount sets the MinRepeatCount optional argument. The maximum number of times to replay the snapshot (1, if not specified).

type LayerTreeProfileSnapshotReply 

type LayerTreeProfileSnapshotReply struct {
	Timings []cdptype.LayerTreePaintProfile `json:"timings"` // The array of paint profiles, one per run.
}

LayerTreeProfileSnapshotReply represents the return values for ProfileSnapshot in the LayerTree domain.

type LayerTreeReleaseSnapshotArgs 

type LayerTreeReleaseSnapshotArgs struct {
	SnapshotID cdptype.LayerTreeSnapshotID `json:"snapshotId"` // The id of the layer snapshot.
}

LayerTreeReleaseSnapshotArgs represents the arguments for ReleaseSnapshot in the LayerTree domain.

func NewLayerTreeReleaseSnapshotArgs 

func NewLayerTreeReleaseSnapshotArgs(snapshotID cdptype.LayerTreeSnapshotID) *LayerTreeReleaseSnapshotArgs

NewLayerTreeReleaseSnapshotArgs initializes LayerTreeReleaseSnapshotArgs with the required arguments.

type LayerTreeReplaySnapshotArgs 

type LayerTreeReplaySnapshotArgs struct {
	SnapshotID cdptype.LayerTreeSnapshotID `json:"snapshotId"`         // The id of the layer snapshot.
	FromStep   *int                        `json:"fromStep,omitempty"` // The first step to replay from (replay from the very start if not specified).
	ToStep     *int                        `json:"toStep,omitempty"`   // The last step to replay to (replay till the end if not specified).
	Scale      *float64                    `json:"scale,omitempty"`    // The scale to apply while replaying (defaults to 1).
}

LayerTreeReplaySnapshotArgs represents the arguments for ReplaySnapshot in the LayerTree domain.

func NewLayerTreeReplaySnapshotArgs 

func NewLayerTreeReplaySnapshotArgs(snapshotID cdptype.LayerTreeSnapshotID) *LayerTreeReplaySnapshotArgs

NewLayerTreeReplaySnapshotArgs initializes LayerTreeReplaySnapshotArgs with the required arguments.

func (*LayerTreeReplaySnapshotArgs) SetFromStep 

func (a *LayerTreeReplaySnapshotArgs) SetFromStep(fromStep int) *LayerTreeReplaySnapshotArgs

SetFromStep sets the FromStep optional argument. The first step to replay from (replay from the very start if not specified).

func (*LayerTreeReplaySnapshotArgs) SetScale 

func (a *LayerTreeReplaySnapshotArgs) SetScale(scale float64) *LayerTreeReplaySnapshotArgs

SetScale sets the Scale optional argument. The scale to apply while replaying (defaults to 1).

func (*LayerTreeReplaySnapshotArgs) SetToStep 

func (a *LayerTreeReplaySnapshotArgs) SetToStep(toStep int) *LayerTreeReplaySnapshotArgs

SetToStep sets the ToStep optional argument. The last step to replay to (replay till the end if not specified).

type LayerTreeReplaySnapshotReply 

type LayerTreeReplaySnapshotReply struct {
	DataURL string `json:"dataURL"` // A data: URL for resulting image.
}

LayerTreeReplaySnapshotReply represents the return values for ReplaySnapshot in the LayerTree domain.

type LayerTreeSnapshotCommandLogArgs 

type LayerTreeSnapshotCommandLogArgs struct {
	SnapshotID cdptype.LayerTreeSnapshotID `json:"snapshotId"` // The id of the layer snapshot.
}

LayerTreeSnapshotCommandLogArgs represents the arguments for SnapshotCommandLog in the LayerTree domain.

func NewLayerTreeSnapshotCommandLogArgs 

func NewLayerTreeSnapshotCommandLogArgs(snapshotID cdptype.LayerTreeSnapshotID) *LayerTreeSnapshotCommandLogArgs

NewLayerTreeSnapshotCommandLogArgs initializes LayerTreeSnapshotCommandLogArgs with the required arguments.

type LayerTreeSnapshotCommandLogReply 

type LayerTreeSnapshotCommandLogReply struct {
	CommandLog []json.RawMessage `json:"commandLog"` // The array of canvas function calls.
}

LayerTreeSnapshotCommandLogReply represents the return values for SnapshotCommandLog in the LayerTree domain.

type LogStartViolationsReportArgs 

type LogStartViolationsReportArgs struct {
	Config []cdptype.LogViolationSetting `json:"config"` // Configuration for violations.
}

LogStartViolationsReportArgs represents the arguments for StartViolationsReport in the Log domain.

func NewLogStartViolationsReportArgs 

func NewLogStartViolationsReportArgs(config []cdptype.LogViolationSetting) *LogStartViolationsReportArgs

NewLogStartViolationsReportArgs initializes LogStartViolationsReportArgs with the required arguments.

type MemoryGetDOMCountersReply 

type MemoryGetDOMCountersReply struct {
	Documents        int `json:"documents"`        //
	Nodes            int `json:"nodes"`            //
	JsEventListeners int `json:"jsEventListeners"` //
}

MemoryGetDOMCountersReply represents the return values for GetDOMCounters in the Memory domain.

type MemorySetPressureNotificationsSuppressedArgs 

type MemorySetPressureNotificationsSuppressedArgs struct {
	Suppressed bool `json:"suppressed"` // If true, memory pressure notifications will be suppressed.
}

MemorySetPressureNotificationsSuppressedArgs represents the arguments for SetPressureNotificationsSuppressed in the Memory domain.

func NewMemorySetPressureNotificationsSuppressedArgs 

func NewMemorySetPressureNotificationsSuppressedArgs(suppressed bool) *MemorySetPressureNotificationsSuppressedArgs

NewMemorySetPressureNotificationsSuppressedArgs initializes MemorySetPressureNotificationsSuppressedArgs with the required arguments.

type MemorySimulatePressureNotificationArgs 

type MemorySimulatePressureNotificationArgs struct {
	Level cdptype.MemoryPressureLevel `json:"level"` // Memory pressure level of the notification.
}

MemorySimulatePressureNotificationArgs represents the arguments for SimulatePressureNotification in the Memory domain.

func NewMemorySimulatePressureNotificationArgs 

func NewMemorySimulatePressureNotificationArgs(level cdptype.MemoryPressureLevel) *MemorySimulatePressureNotificationArgs

NewMemorySimulatePressureNotificationArgs initializes MemorySimulatePressureNotificationArgs with the required arguments.

type NetworkCanClearBrowserCacheReply 

type NetworkCanClearBrowserCacheReply struct {
	Result bool `json:"result"` // True if browser cache can be cleared.
}

NetworkCanClearBrowserCacheReply represents the return values for CanClearBrowserCache in the Network domain.

type NetworkCanClearBrowserCookiesReply 

type NetworkCanClearBrowserCookiesReply struct {
	Result bool `json:"result"` // True if browser cookies can be cleared.
}

NetworkCanClearBrowserCookiesReply represents the return values for CanClearBrowserCookies in the Network domain.

type NetworkCanEmulateNetworkConditionsReply 

type NetworkCanEmulateNetworkConditionsReply struct {
	Result bool `json:"result"` // True if emulation of network conditions is supported.
}

NetworkCanEmulateNetworkConditionsReply represents the return values for CanEmulateNetworkConditions in the Network domain.

type NetworkContinueInterceptedRequestArgs 

type NetworkContinueInterceptedRequestArgs struct {
	InterceptionID        cdptype.NetworkInterceptionID         `json:"interceptionId"`                  //
	ErrorReason           cdptype.NetworkErrorReason            `json:"errorReason,omitempty"`           // If set this causes the request to fail with the given reason. Must not be set in response to an authChallenge.
	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... Must not be set in response to an authChallenge.
	URL                   *string                               `json:"url,omitempty"`                   // 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.
	Method                *string                               `json:"method,omitempty"`                // If set this allows the request method to be overridden. Must not be set in response to an authChallenge.
	PostData              *string                               `json:"postData,omitempty"`              // If set this allows postData to be set. Must not be set in response to an authChallenge.
	Headers               cdptype.NetworkHeaders                `json:"headers,omitempty"`               // If set this allows the request headers to be changed. Must not be set in response to an authChallenge.
	AuthChallengeResponse *cdptype.NetworkAuthChallengeResponse `json:"authChallengeResponse,omitempty"` // Response to a requestIntercepted with an authChallenge. Must not be set otherwise.
}

NetworkContinueInterceptedRequestArgs represents the arguments for ContinueInterceptedRequest in the Network domain.

func NewNetworkContinueInterceptedRequestArgs 

func NewNetworkContinueInterceptedRequestArgs(interceptionID cdptype.NetworkInterceptionID) *NetworkContinueInterceptedRequestArgs

NewNetworkContinueInterceptedRequestArgs initializes NetworkContinueInterceptedRequestArgs with the required arguments.

func (*NetworkContinueInterceptedRequestArgs) SetAuthChallengeResponse 

func (a *NetworkContinueInterceptedRequestArgs) SetAuthChallengeResponse(authChallengeResponse cdptype.NetworkAuthChallengeResponse) *NetworkContinueInterceptedRequestArgs

SetAuthChallengeResponse sets the AuthChallengeResponse optional argument. Response to a requestIntercepted with an authChallenge. Must not be set otherwise.

func (*NetworkContinueInterceptedRequestArgs) SetErrorReason 

func (a *NetworkContinueInterceptedRequestArgs) SetErrorReason(errorReason cdptype.NetworkErrorReason) *NetworkContinueInterceptedRequestArgs

SetErrorReason sets the ErrorReason optional argument. If set this causes the request to fail with the given reason. Must not be set in response to an authChallenge.

func (*NetworkContinueInterceptedRequestArgs) SetHeaders 

func (a *NetworkContinueInterceptedRequestArgs) SetHeaders(headers cdptype.NetworkHeaders) *NetworkContinueInterceptedRequestArgs

SetHeaders sets the Headers optional argument. If set this allows the request headers to be changed. Must not be set in response to an authChallenge.

func (*NetworkContinueInterceptedRequestArgs) SetMethod 

func (a *NetworkContinueInterceptedRequestArgs) SetMethod(method string) *NetworkContinueInterceptedRequestArgs

SetMethod sets the Method optional argument. If set this allows the request method to be overridden. Must not be set in response to an authChallenge.

func (*NetworkContinueInterceptedRequestArgs) SetPostData 

func (a *NetworkContinueInterceptedRequestArgs) SetPostData(postData string) *NetworkContinueInterceptedRequestArgs

SetPostData sets the PostData optional argument. If set this allows postData to be set. Must not be set in response to an authChallenge.

func (*NetworkContinueInterceptedRequestArgs) SetRawResponse 

func (a *NetworkContinueInterceptedRequestArgs) SetRawResponse(rawResponse string) *NetworkContinueInterceptedRequestArgs

SetRawResponse sets the RawResponse optional argument. 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 (*NetworkContinueInterceptedRequestArgs) SetURL 

func (a *NetworkContinueInterceptedRequestArgs) SetURL(url string) *NetworkContinueInterceptedRequestArgs

SetURL sets the URL optional argument. 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.

type NetworkDeleteCookieArgs 

type NetworkDeleteCookieArgs struct {
	CookieName string `json:"cookieName"` // Name of the cookie to remove.
	URL        string `json:"url"`        // URL to match cooke domain and path.
}

NetworkDeleteCookieArgs represents the arguments for DeleteCookie in the Network domain.

func NewNetworkDeleteCookieArgs 

func NewNetworkDeleteCookieArgs(cookieName string, url string) *NetworkDeleteCookieArgs

NewNetworkDeleteCookieArgs initializes NetworkDeleteCookieArgs with the required arguments.

type NetworkEmulateNetworkConditionsArgs 

type NetworkEmulateNetworkConditionsArgs 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     cdptype.NetworkConnectionType `json:"connectionType,omitempty"` // Connection type if known.
}

NetworkEmulateNetworkConditionsArgs represents the arguments for EmulateNetworkConditions in the Network domain.

func NewNetworkEmulateNetworkConditionsArgs 

func NewNetworkEmulateNetworkConditionsArgs(offline bool, latency float64, downloadThroughput float64, uploadThroughput float64) *NetworkEmulateNetworkConditionsArgs

NewNetworkEmulateNetworkConditionsArgs initializes NetworkEmulateNetworkConditionsArgs with the required arguments.

func (*NetworkEmulateNetworkConditionsArgs) SetConnectionType 

func (a *NetworkEmulateNetworkConditionsArgs) SetConnectionType(connectionType cdptype.NetworkConnectionType) *NetworkEmulateNetworkConditionsArgs

SetConnectionType sets the ConnectionType optional argument. Connection type if known.

type NetworkEnableArgs 

type NetworkEnableArgs struct {
	MaxTotalBufferSize    *int `json:"maxTotalBufferSize,omitempty"`    // Buffer size in bytes to use when preserving network payloads (XHRs, etc).
	MaxResourceBufferSize *int `json:"maxResourceBufferSize,omitempty"` // Per-resource buffer size in bytes to use when preserving network payloads (XHRs, etc).
}

NetworkEnableArgs represents the arguments for Enable in the Network domain.

func NewNetworkEnableArgs 

func NewNetworkEnableArgs() *NetworkEnableArgs

NewNetworkEnableArgs initializes NetworkEnableArgs with the required arguments.

func (*NetworkEnableArgs) SetMaxResourceBufferSize 

func (a *NetworkEnableArgs) SetMaxResourceBufferSize(maxResourceBufferSize int) *NetworkEnableArgs

SetMaxResourceBufferSize sets the MaxResourceBufferSize optional argument. Per-resource buffer size in bytes to use when preserving network payloads (XHRs, etc).

func (*NetworkEnableArgs) SetMaxTotalBufferSize 

func (a *NetworkEnableArgs) SetMaxTotalBufferSize(maxTotalBufferSize int) *NetworkEnableArgs

SetMaxTotalBufferSize sets the MaxTotalBufferSize optional argument. Buffer size in bytes to use when preserving network payloads (XHRs, etc).

type NetworkEnableRequestInterceptionArgs 

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

NetworkEnableRequestInterceptionArgs represents the arguments for EnableRequestInterception in the Network domain.

func NewNetworkEnableRequestInterceptionArgs 

func NewNetworkEnableRequestInterceptionArgs(enabled bool) *NetworkEnableRequestInterceptionArgs

NewNetworkEnableRequestInterceptionArgs initializes NetworkEnableRequestInterceptionArgs with the required arguments.

type NetworkGetAllCookiesReply 

type NetworkGetAllCookiesReply struct {
	Cookies []cdptype.NetworkCookie `json:"cookies"` // Array of cookie objects.
}

NetworkGetAllCookiesReply represents the return values for GetAllCookies in the Network domain.

type NetworkGetCertificateArgs 

type NetworkGetCertificateArgs struct {
	Origin string `json:"origin"` // Origin to get certificate for.
}

NetworkGetCertificateArgs represents the arguments for GetCertificate in the Network domain.

func NewNetworkGetCertificateArgs 

func NewNetworkGetCertificateArgs(origin string) *NetworkGetCertificateArgs

NewNetworkGetCertificateArgs initializes NetworkGetCertificateArgs with the required arguments.

type NetworkGetCertificateReply 

type NetworkGetCertificateReply struct {
	TableNames []string `json:"tableNames"` //
}

NetworkGetCertificateReply represents the return values for GetCertificate in the Network domain.

type NetworkGetCookiesArgs 

type NetworkGetCookiesArgs struct {
	URLs []string `json:"urls,omitempty"` // The list of URLs for which applicable cookies will be fetched
}

NetworkGetCookiesArgs represents the arguments for GetCookies in the Network domain.

func NewNetworkGetCookiesArgs 

func NewNetworkGetCookiesArgs() *NetworkGetCookiesArgs

NewNetworkGetCookiesArgs initializes NetworkGetCookiesArgs with the required arguments.

func (*NetworkGetCookiesArgs) SetURLs 

func (a *NetworkGetCookiesArgs) SetURLs(urls []string) *NetworkGetCookiesArgs

SetURLs sets the URLs optional argument. The list of URLs for which applicable cookies will be fetched

type NetworkGetCookiesReply 

type NetworkGetCookiesReply struct {
	Cookies []cdptype.NetworkCookie `json:"cookies"` // Array of cookie objects.
}

NetworkGetCookiesReply represents the return values for GetCookies in the Network domain.

type NetworkGetResponseBodyArgs 

type NetworkGetResponseBodyArgs struct {
	RequestID cdptype.NetworkRequestID `json:"requestId"` // Identifier of the network request to get content for.
}

NetworkGetResponseBodyArgs represents the arguments for GetResponseBody in the Network domain.

func NewNetworkGetResponseBodyArgs 

func NewNetworkGetResponseBodyArgs(requestID cdptype.NetworkRequestID) *NetworkGetResponseBodyArgs

NewNetworkGetResponseBodyArgs initializes NetworkGetResponseBodyArgs with the required arguments.

type NetworkGetResponseBodyReply 

type NetworkGetResponseBodyReply struct {
	Body          string `json:"body"`          // Response body.
	Base64Encoded bool   `json:"base64Encoded"` // True, if content was sent as base64.
}

NetworkGetResponseBodyReply represents the return values for GetResponseBody in the Network domain.

type NetworkReplayXHRArgs 

type NetworkReplayXHRArgs struct {
	RequestID cdptype.NetworkRequestID `json:"requestId"` // Identifier of XHR to replay.
}

NetworkReplayXHRArgs represents the arguments for ReplayXHR in the Network domain.

func NewNetworkReplayXHRArgs 

func NewNetworkReplayXHRArgs(requestID cdptype.NetworkRequestID) *NetworkReplayXHRArgs

NewNetworkReplayXHRArgs initializes NetworkReplayXHRArgs with the required arguments.

type NetworkSetBlockedURLsArgs 

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

NetworkSetBlockedURLsArgs represents the arguments for SetBlockedURLs in the Network domain.

func NewNetworkSetBlockedURLsArgs 

func NewNetworkSetBlockedURLsArgs(urls []string) *NetworkSetBlockedURLsArgs

NewNetworkSetBlockedURLsArgs initializes NetworkSetBlockedURLsArgs with the required arguments.

type NetworkSetBypassServiceWorkerArgs 

type NetworkSetBypassServiceWorkerArgs struct {
	Bypass bool `json:"bypass"` // Bypass service worker and load from network.
}

NetworkSetBypassServiceWorkerArgs represents the arguments for SetBypassServiceWorker in the Network domain.

func NewNetworkSetBypassServiceWorkerArgs 

func NewNetworkSetBypassServiceWorkerArgs(bypass bool) *NetworkSetBypassServiceWorkerArgs

NewNetworkSetBypassServiceWorkerArgs initializes NetworkSetBypassServiceWorkerArgs with the required arguments.

type NetworkSetCacheDisabledArgs 

type NetworkSetCacheDisabledArgs struct {
	CacheDisabled bool `json:"cacheDisabled"` // Cache disabled state.
}

NetworkSetCacheDisabledArgs represents the arguments for SetCacheDisabled in the Network domain.

func NewNetworkSetCacheDisabledArgs 

func NewNetworkSetCacheDisabledArgs(cacheDisabled bool) *NetworkSetCacheDisabledArgs

NewNetworkSetCacheDisabledArgs initializes NetworkSetCacheDisabledArgs with the required arguments.

type NetworkSetCookieArgs 

type NetworkSetCookieArgs 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       cdptype.NetworkCookieSameSite `json:"sameSite,omitempty"`       // Defaults to browser default behavior.
	ExpirationDate cdptype.NetworkTimestamp      `json:"expirationDate,omitempty"` // If omitted, the cookie becomes a session cookie.
}

NetworkSetCookieArgs represents the arguments for SetCookie in the Network domain.

func NewNetworkSetCookieArgs 

func NewNetworkSetCookieArgs(url string, name string, value string) *NetworkSetCookieArgs

NewNetworkSetCookieArgs initializes NetworkSetCookieArgs with the required arguments.

func (*NetworkSetCookieArgs) SetDomain 

func (a *NetworkSetCookieArgs) SetDomain(domain string) *NetworkSetCookieArgs

SetDomain sets the Domain optional argument. If omitted, the cookie becomes a host-only cookie.

func (*NetworkSetCookieArgs) SetExpirationDate 

func (a *NetworkSetCookieArgs) SetExpirationDate(expirationDate cdptype.NetworkTimestamp) *NetworkSetCookieArgs

SetExpirationDate sets the ExpirationDate optional argument. If omitted, the cookie becomes a session cookie.

func (*NetworkSetCookieArgs) SetHTTPOnly 

func (a *NetworkSetCookieArgs) SetHTTPOnly(httpOnly bool) *NetworkSetCookieArgs

SetHTTPOnly sets the HTTPOnly optional argument. Defaults to false.

func (*NetworkSetCookieArgs) SetPath 

func (a *NetworkSetCookieArgs) SetPath(path string) *NetworkSetCookieArgs

SetPath sets the Path optional argument. Defaults to the path portion of the url parameter.

func (*NetworkSetCookieArgs) SetSameSite 

func (a *NetworkSetCookieArgs) SetSameSite(sameSite cdptype.NetworkCookieSameSite) *NetworkSetCookieArgs

SetSameSite sets the SameSite optional argument. Defaults to browser default behavior.

func (*NetworkSetCookieArgs) SetSecure 

func (a *NetworkSetCookieArgs) SetSecure(secure bool) *NetworkSetCookieArgs

SetSecure sets the Secure optional argument. Defaults ot false.

type NetworkSetCookieReply 

type NetworkSetCookieReply struct {
	Success bool `json:"success"` // True if successfully set cookie.
}

NetworkSetCookieReply represents the return values for SetCookie in the Network domain.

type NetworkSetDataSizeLimitsForTestArgs 

type NetworkSetDataSizeLimitsForTestArgs struct {
	MaxTotalSize    int `json:"maxTotalSize"`    // Maximum total buffer size.
	MaxResourceSize int `json:"maxResourceSize"` // Maximum per-resource size.
}

NetworkSetDataSizeLimitsForTestArgs represents the arguments for SetDataSizeLimitsForTest in the Network domain.

func NewNetworkSetDataSizeLimitsForTestArgs 

func NewNetworkSetDataSizeLimitsForTestArgs(maxTotalSize int, maxResourceSize int) *NetworkSetDataSizeLimitsForTestArgs

NewNetworkSetDataSizeLimitsForTestArgs initializes NetworkSetDataSizeLimitsForTestArgs with the required arguments.

type NetworkSetExtraHTTPHeadersArgs 

type NetworkSetExtraHTTPHeadersArgs struct {
	Headers cdptype.NetworkHeaders `json:"headers"` // Map with extra HTTP headers.
}

NetworkSetExtraHTTPHeadersArgs represents the arguments for SetExtraHTTPHeaders in the Network domain.

func NewNetworkSetExtraHTTPHeadersArgs 

func NewNetworkSetExtraHTTPHeadersArgs(headers cdptype.NetworkHeaders) *NetworkSetExtraHTTPHeadersArgs

NewNetworkSetExtraHTTPHeadersArgs initializes NetworkSetExtraHTTPHeadersArgs with the required arguments.

type NetworkSetUserAgentOverrideArgs 

type NetworkSetUserAgentOverrideArgs struct {
	UserAgent string `json:"userAgent"` // User agent to use.
}

NetworkSetUserAgentOverrideArgs represents the arguments for SetUserAgentOverride in the Network domain.

func NewNetworkSetUserAgentOverrideArgs 

func NewNetworkSetUserAgentOverrideArgs(userAgent string) *NetworkSetUserAgentOverrideArgs

NewNetworkSetUserAgentOverrideArgs initializes NetworkSetUserAgentOverrideArgs with the required arguments.

type OverlayGetHighlightObjectForTestArgs 

type OverlayGetHighlightObjectForTestArgs struct {
	NodeID cdptype.DOMNodeID `json:"nodeId"` // Id of the node to get highlight object for.
}

OverlayGetHighlightObjectForTestArgs represents the arguments for GetHighlightObjectForTest in the Overlay domain.

func NewOverlayGetHighlightObjectForTestArgs 

func NewOverlayGetHighlightObjectForTestArgs(nodeID cdptype.DOMNodeID) *OverlayGetHighlightObjectForTestArgs

NewOverlayGetHighlightObjectForTestArgs initializes OverlayGetHighlightObjectForTestArgs with the required arguments.

type OverlayGetHighlightObjectForTestReply 

type OverlayGetHighlightObjectForTestReply struct {
	Highlight json.RawMessage `json:"highlight"` // Highlight data for the node.
}

OverlayGetHighlightObjectForTestReply represents the return values for GetHighlightObjectForTest in the Overlay domain.

type OverlayHighlightFrameArgs 

type OverlayHighlightFrameArgs struct {
	FrameID             cdptype.PageFrameID `json:"frameId"`                       // Identifier of the frame to highlight.
	ContentColor        *cdptype.DOMRGBA    `json:"contentColor,omitempty"`        // The content box highlight fill color (default: transparent).
	ContentOutlineColor *cdptype.DOMRGBA    `json:"contentOutlineColor,omitempty"` // The content box highlight outline color (default: transparent).
}

OverlayHighlightFrameArgs represents the arguments for HighlightFrame in the Overlay domain.

func NewOverlayHighlightFrameArgs 

func NewOverlayHighlightFrameArgs(frameID cdptype.PageFrameID) *OverlayHighlightFrameArgs

NewOverlayHighlightFrameArgs initializes OverlayHighlightFrameArgs with the required arguments.

func (*OverlayHighlightFrameArgs) SetContentColor 

func (a *OverlayHighlightFrameArgs) SetContentColor(contentColor cdptype.DOMRGBA) *OverlayHighlightFrameArgs

SetContentColor sets the ContentColor optional argument. The content box highlight fill color (default: transparent).

func (*OverlayHighlightFrameArgs) SetContentOutlineColor 

func (a *OverlayHighlightFrameArgs) SetContentOutlineColor(contentOutlineColor cdptype.DOMRGBA) *OverlayHighlightFrameArgs

SetContentOutlineColor sets the ContentOutlineColor optional argument. The content box highlight outline color (default: transparent).

type OverlayHighlightNodeArgs 

type OverlayHighlightNodeArgs struct {
	HighlightConfig cdptype.OverlayHighlightConfig `json:"highlightConfig"`         // A descriptor for the highlight appearance.
	NodeID          *cdptype.DOMNodeID             `json:"nodeId,omitempty"`        // Identifier of the node to highlight.
	BackendNodeID   *cdptype.DOMBackendNodeID      `json:"backendNodeId,omitempty"` // Identifier of the backend node to highlight.
	ObjectID        *cdptype.RuntimeRemoteObjectID `json:"objectId,omitempty"`      // JavaScript object id of the node to be highlighted.
}

OverlayHighlightNodeArgs represents the arguments for HighlightNode in the Overlay domain.

func NewOverlayHighlightNodeArgs 

func NewOverlayHighlightNodeArgs(highlightConfig cdptype.OverlayHighlightConfig) *OverlayHighlightNodeArgs

NewOverlayHighlightNodeArgs initializes OverlayHighlightNodeArgs with the required arguments.

func (*OverlayHighlightNodeArgs) SetBackendNodeID 

func (a *OverlayHighlightNodeArgs) SetBackendNodeID(backendNodeID cdptype.DOMBackendNodeID) *OverlayHighlightNodeArgs

SetBackendNodeID sets the BackendNodeID optional argument. Identifier of the backend node to highlight.

func (*OverlayHighlightNodeArgs) SetNodeID 

func (a *OverlayHighlightNodeArgs) SetNodeID(nodeID cdptype.DOMNodeID) *OverlayHighlightNodeArgs

SetNodeID sets the NodeID optional argument. Identifier of the node to highlight.

func (*OverlayHighlightNodeArgs) SetObjectID 

func (a *OverlayHighlightNodeArgs) SetObjectID(objectID cdptype.RuntimeRemoteObjectID) *OverlayHighlightNodeArgs

SetObjectID sets the ObjectID optional argument. JavaScript object id of the node to be highlighted.

type OverlayHighlightQuadArgs 

type OverlayHighlightQuadArgs struct {
	Quad         cdptype.DOMQuad  `json:"quad"`                   // Quad to highlight
	Color        *cdptype.DOMRGBA `json:"color,omitempty"`        // The highlight fill color (default: transparent).
	OutlineColor *cdptype.DOMRGBA `json:"outlineColor,omitempty"` // The highlight outline color (default: transparent).
}

OverlayHighlightQuadArgs represents the arguments for HighlightQuad in the Overlay domain.

func NewOverlayHighlightQuadArgs 

func NewOverlayHighlightQuadArgs(quad cdptype.DOMQuad) *OverlayHighlightQuadArgs

NewOverlayHighlightQuadArgs initializes OverlayHighlightQuadArgs with the required arguments.

func (*OverlayHighlightQuadArgs) SetColor 

func (a *OverlayHighlightQuadArgs) SetColor(color cdptype.DOMRGBA) *OverlayHighlightQuadArgs

SetColor sets the Color optional argument. The highlight fill color (default: transparent).

func (*OverlayHighlightQuadArgs) SetOutlineColor 

func (a *OverlayHighlightQuadArgs) SetOutlineColor(outlineColor cdptype.DOMRGBA) *OverlayHighlightQuadArgs

SetOutlineColor sets the OutlineColor optional argument. The highlight outline color (default: transparent).

type OverlayHighlightRectArgs 

type OverlayHighlightRectArgs struct {
	X            int              `json:"x"`                      // X coordinate
	Y            int              `json:"y"`                      // Y coordinate
	Width        int              `json:"width"`                  // Rectangle width
	Height       int              `json:"height"`                 // Rectangle height
	Color        *cdptype.DOMRGBA `json:"color,omitempty"`        // The highlight fill color (default: transparent).
	OutlineColor *cdptype.DOMRGBA `json:"outlineColor,omitempty"` // The highlight outline color (default: transparent).
}

OverlayHighlightRectArgs represents the arguments for HighlightRect in the Overlay domain.

func NewOverlayHighlightRectArgs 

func NewOverlayHighlightRectArgs(x int, y int, width int, height int) *OverlayHighlightRectArgs

NewOverlayHighlightRectArgs initializes OverlayHighlightRectArgs with the required arguments.

func (*OverlayHighlightRectArgs) SetColor 

func (a *OverlayHighlightRectArgs) SetColor(color cdptype.DOMRGBA) *OverlayHighlightRectArgs

SetColor sets the Color optional argument. The highlight fill color (default: transparent).

func (*OverlayHighlightRectArgs) SetOutlineColor 

func (a *OverlayHighlightRectArgs) SetOutlineColor(outlineColor cdptype.DOMRGBA) *OverlayHighlightRectArgs

SetOutlineColor sets the OutlineColor optional argument. The highlight outline color (default: transparent).

type OverlaySetInspectModeArgs 

type OverlaySetInspectModeArgs struct {
	Mode            cdptype.OverlayInspectMode      `json:"mode"`                      // Set an inspection mode.
	HighlightConfig *cdptype.OverlayHighlightConfig `json:"highlightConfig,omitempty"` // A descriptor for the highlight appearance of hovered-over nodes. May be omitted if enabled == false.
}

OverlaySetInspectModeArgs represents the arguments for SetInspectMode in the Overlay domain.

func NewOverlaySetInspectModeArgs 

func NewOverlaySetInspectModeArgs(mode cdptype.OverlayInspectMode) *OverlaySetInspectModeArgs

NewOverlaySetInspectModeArgs initializes OverlaySetInspectModeArgs with the required arguments.

func (*OverlaySetInspectModeArgs) SetHighlightConfig 

func (a *OverlaySetInspectModeArgs) SetHighlightConfig(highlightConfig cdptype.OverlayHighlightConfig) *OverlaySetInspectModeArgs

SetHighlightConfig sets the HighlightConfig optional argument. A descriptor for the highlight appearance of hovered-over nodes. May be omitted if enabled == false.

type OverlaySetPausedInDebuggerMessageArgs 

type OverlaySetPausedInDebuggerMessageArgs struct {
	Message *string `json:"message,omitempty"` // The message to display, also triggers resume and step over controls.
}

OverlaySetPausedInDebuggerMessageArgs represents the arguments for SetPausedInDebuggerMessage in the Overlay domain.

func NewOverlaySetPausedInDebuggerMessageArgs 

func NewOverlaySetPausedInDebuggerMessageArgs() *OverlaySetPausedInDebuggerMessageArgs

NewOverlaySetPausedInDebuggerMessageArgs initializes OverlaySetPausedInDebuggerMessageArgs with the required arguments.

func (*OverlaySetPausedInDebuggerMessageArgs) SetMessage 

func (a *OverlaySetPausedInDebuggerMessageArgs) SetMessage(message string) *OverlaySetPausedInDebuggerMessageArgs

SetMessage sets the Message optional argument. The message to display, also triggers resume and step over controls.

type OverlaySetShowDebugBordersArgs 

type OverlaySetShowDebugBordersArgs struct {
	Show bool `json:"show"` // True for showing debug borders
}

OverlaySetShowDebugBordersArgs represents the arguments for SetShowDebugBorders in the Overlay domain.

func NewOverlaySetShowDebugBordersArgs 

func NewOverlaySetShowDebugBordersArgs(show bool) *OverlaySetShowDebugBordersArgs

NewOverlaySetShowDebugBordersArgs initializes OverlaySetShowDebugBordersArgs with the required arguments.

type OverlaySetShowFPSCounterArgs 

type OverlaySetShowFPSCounterArgs struct {
	Show bool `json:"show"` // True for showing the FPS counter
}

OverlaySetShowFPSCounterArgs represents the arguments for SetShowFPSCounter in the Overlay domain.

func NewOverlaySetShowFPSCounterArgs 

func NewOverlaySetShowFPSCounterArgs(show bool) *OverlaySetShowFPSCounterArgs

NewOverlaySetShowFPSCounterArgs initializes OverlaySetShowFPSCounterArgs with the required arguments.

type OverlaySetShowPaintRectsArgs 

type OverlaySetShowPaintRectsArgs struct {
	Result bool `json:"result"` // True for showing paint rectangles
}

OverlaySetShowPaintRectsArgs represents the arguments for SetShowPaintRects in the Overlay domain.

func NewOverlaySetShowPaintRectsArgs 

func NewOverlaySetShowPaintRectsArgs(result bool) *OverlaySetShowPaintRectsArgs

NewOverlaySetShowPaintRectsArgs initializes OverlaySetShowPaintRectsArgs with the required arguments.

type OverlaySetShowScrollBottleneckRectsArgs 

type OverlaySetShowScrollBottleneckRectsArgs struct {
	Show bool `json:"show"` // True for showing scroll bottleneck rects
}

OverlaySetShowScrollBottleneckRectsArgs represents the arguments for SetShowScrollBottleneckRects in the Overlay domain.

func NewOverlaySetShowScrollBottleneckRectsArgs 

func NewOverlaySetShowScrollBottleneckRectsArgs(show bool) *OverlaySetShowScrollBottleneckRectsArgs

NewOverlaySetShowScrollBottleneckRectsArgs initializes OverlaySetShowScrollBottleneckRectsArgs with the required arguments.

type OverlaySetShowViewportSizeOnResizeArgs 

type OverlaySetShowViewportSizeOnResizeArgs struct {
	Show bool `json:"show"` // Whether to paint size or not.
}

OverlaySetShowViewportSizeOnResizeArgs represents the arguments for SetShowViewportSizeOnResize in the Overlay domain.

func NewOverlaySetShowViewportSizeOnResizeArgs 

func NewOverlaySetShowViewportSizeOnResizeArgs(show bool) *OverlaySetShowViewportSizeOnResizeArgs

NewOverlaySetShowViewportSizeOnResizeArgs initializes OverlaySetShowViewportSizeOnResizeArgs with the required arguments.

type OverlaySetSuspendedArgs 

type OverlaySetSuspendedArgs struct {
	Suspended bool `json:"suspended"` // Whether overlay should be suspended and not consume any resources until resumed.
}

OverlaySetSuspendedArgs represents the arguments for SetSuspended in the Overlay domain.

func NewOverlaySetSuspendedArgs 

func NewOverlaySetSuspendedArgs(suspended bool) *OverlaySetSuspendedArgs

NewOverlaySetSuspendedArgs initializes OverlaySetSuspendedArgs with the required arguments.

type PageAddScriptToEvaluateOnLoadArgs 

type PageAddScriptToEvaluateOnLoadArgs struct {
	ScriptSource string `json:"scriptSource"` //
}

PageAddScriptToEvaluateOnLoadArgs represents the arguments for AddScriptToEvaluateOnLoad in the Page domain.

func NewPageAddScriptToEvaluateOnLoadArgs 

func NewPageAddScriptToEvaluateOnLoadArgs(scriptSource string) *PageAddScriptToEvaluateOnLoadArgs

NewPageAddScriptToEvaluateOnLoadArgs initializes PageAddScriptToEvaluateOnLoadArgs with the required arguments.

type PageAddScriptToEvaluateOnLoadReply 

type PageAddScriptToEvaluateOnLoadReply struct {
	Identifier cdptype.PageScriptIdentifier `json:"identifier"` // Identifier of the added script.
}

PageAddScriptToEvaluateOnLoadReply represents the return values for AddScriptToEvaluateOnLoad in the Page domain.

type PageCaptureScreenshotArgs 

type PageCaptureScreenshotArgs struct {
	Format      *string `json:"format,omitempty"`      // Image compression format (defaults to png).
	Quality     *int    `json:"quality,omitempty"`     // Compression quality from range [0..100] (jpeg only).
	FromSurface *bool   `json:"fromSurface,omitempty"` // Capture the screenshot from the surface, rather than the view. Defaults to true.
}

PageCaptureScreenshotArgs represents the arguments for CaptureScreenshot in the Page domain.

func NewPageCaptureScreenshotArgs 

func NewPageCaptureScreenshotArgs() *PageCaptureScreenshotArgs

NewPageCaptureScreenshotArgs initializes PageCaptureScreenshotArgs with the required arguments.

func (*PageCaptureScreenshotArgs) SetFormat 

func (a *PageCaptureScreenshotArgs) SetFormat(format string) *PageCaptureScreenshotArgs

SetFormat sets the Format optional argument. Image compression format (defaults to png).

func (*PageCaptureScreenshotArgs) SetFromSurface 

func (a *PageCaptureScreenshotArgs) SetFromSurface(fromSurface bool) *PageCaptureScreenshotArgs

SetFromSurface sets the FromSurface optional argument. Capture the screenshot from the surface, rather than the view. Defaults to true.

func (*PageCaptureScreenshotArgs) SetQuality 

func (a *PageCaptureScreenshotArgs) SetQuality(quality int) *PageCaptureScreenshotArgs

SetQuality sets the Quality optional argument. Compression quality from range [0..100] (jpeg only).

type PageCaptureScreenshotReply 

type PageCaptureScreenshotReply struct {
	Data []byte `json:"data"` // Base64-encoded image data.
}

PageCaptureScreenshotReply represents the return values for CaptureScreenshot in the Page domain.

type PageCreateIsolatedWorldArgs 

type PageCreateIsolatedWorldArgs struct {
	FrameID             cdptype.PageFrameID `json:"frameId"`                       // Id of the frame in which the isolated world should be created.
	WorldName           *string             `json:"worldName,omitempty"`           // An optional name which is reported in the Execution Context.
	GrantUniveralAccess *bool               `json:"grantUniveralAccess,omitempty"` // Whether or not universal access should be granted to the isolated world. This is a powerful option, use with caution.
}

PageCreateIsolatedWorldArgs represents the arguments for CreateIsolatedWorld in the Page domain.

func NewPageCreateIsolatedWorldArgs 

func NewPageCreateIsolatedWorldArgs(frameID cdptype.PageFrameID) *PageCreateIsolatedWorldArgs

NewPageCreateIsolatedWorldArgs initializes PageCreateIsolatedWorldArgs with the required arguments.

func (*PageCreateIsolatedWorldArgs) SetGrantUniveralAccess 

func (a *PageCreateIsolatedWorldArgs) SetGrantUniveralAccess(grantUniveralAccess bool) *PageCreateIsolatedWorldArgs

SetGrantUniveralAccess sets the GrantUniveralAccess optional argument. Whether or not universal access should be granted to the isolated world. This is a powerful option, use with caution.

func (*PageCreateIsolatedWorldArgs) SetWorldName 

func (a *PageCreateIsolatedWorldArgs) SetWorldName(worldName string) *PageCreateIsolatedWorldArgs

SetWorldName sets the WorldName optional argument. An optional name which is reported in the Execution Context.

type PageCreateIsolatedWorldReply 

type PageCreateIsolatedWorldReply struct {
	ExecutionContextID cdptype.RuntimeExecutionContextID `json:"executionContextId"` // Execution context of the isolated world.
}

PageCreateIsolatedWorldReply represents the return values for CreateIsolatedWorld in the Page domain.

type PageDeleteCookieArgs 

type PageDeleteCookieArgs struct {
	CookieName string `json:"cookieName"` // Name of the cookie to remove.
	URL        string `json:"url"`        // URL to match cooke domain and path.
}

PageDeleteCookieArgs represents the arguments for DeleteCookie in the Page domain.

func NewPageDeleteCookieArgs 

func NewPageDeleteCookieArgs(cookieName string, url string) *PageDeleteCookieArgs

NewPageDeleteCookieArgs initializes PageDeleteCookieArgs with the required arguments.

type PageGetAppManifestReply 

type PageGetAppManifestReply struct {
	URL    string                         `json:"url"`            // Manifest location.
	Errors []cdptype.PageAppManifestError `json:"errors"`         //
	Data   *string                        `json:"data,omitempty"` // Manifest content.
}

PageGetAppManifestReply represents the return values for GetAppManifest in the Page domain.

type PageGetCookiesReply 

type PageGetCookiesReply struct {
	Cookies []cdptype.NetworkCookie `json:"cookies"` // Array of cookie objects.
}

PageGetCookiesReply represents the return values for GetCookies in the Page domain.

type PageGetLayoutMetricsReply 

type PageGetLayoutMetricsReply struct {
	LayoutViewport cdptype.PageLayoutViewport `json:"layoutViewport"` // Metrics relating to the layout viewport.
	VisualViewport cdptype.PageVisualViewport `json:"visualViewport"` // Metrics relating to the visual viewport.
	ContentSize    cdptype.DOMRect            `json:"contentSize"`    // Size of scrollable area.
}

PageGetLayoutMetricsReply represents the return values for GetLayoutMetrics in the Page domain.

type PageGetNavigationHistoryReply 

type PageGetNavigationHistoryReply struct {
	CurrentIndex int                           `json:"currentIndex"` // Index of the current navigation history entry.
	Entries      []cdptype.PageNavigationEntry `json:"entries"`      // Array of navigation history entries.
}

PageGetNavigationHistoryReply represents the return values for GetNavigationHistory in the Page domain.

type PageGetResourceContentArgs 

type PageGetResourceContentArgs struct {
	FrameID cdptype.PageFrameID `json:"frameId"` // Frame id to get resource for.
	URL     string              `json:"url"`     // URL of the resource to get content for.
}

PageGetResourceContentArgs represents the arguments for GetResourceContent in the Page domain.

func NewPageGetResourceContentArgs 

func NewPageGetResourceContentArgs(frameID cdptype.PageFrameID, url string) *PageGetResourceContentArgs

NewPageGetResourceContentArgs initializes PageGetResourceContentArgs with the required arguments.

type PageGetResourceContentReply 

type PageGetResourceContentReply struct {
	Content       string `json:"content"`       // Resource content.
	Base64Encoded bool   `json:"base64Encoded"` // True, if content was served as base64.
}

PageGetResourceContentReply represents the return values for GetResourceContent in the Page domain.

type PageGetResourceTreeReply 

type PageGetResourceTreeReply struct {
	FrameTree cdptype.PageFrameResourceTree `json:"frameTree"` // Present frame / resource tree structure.
}

PageGetResourceTreeReply represents the return values for GetResourceTree in the Page domain.

type PageHandleJavaScriptDialogArgs 

type PageHandleJavaScriptDialogArgs struct {
	Accept     bool    `json:"accept"`               // Whether to accept or dismiss the dialog.
	PromptText *string `json:"promptText,omitempty"` // The text to enter into the dialog prompt before accepting. Used only if this is a prompt dialog.
}

PageHandleJavaScriptDialogArgs represents the arguments for HandleJavaScriptDialog in the Page domain.

func NewPageHandleJavaScriptDialogArgs 

func NewPageHandleJavaScriptDialogArgs(accept bool) *PageHandleJavaScriptDialogArgs

NewPageHandleJavaScriptDialogArgs initializes PageHandleJavaScriptDialogArgs with the required arguments.

func (*PageHandleJavaScriptDialogArgs) SetPromptText 

func (a *PageHandleJavaScriptDialogArgs) SetPromptText(promptText string) *PageHandleJavaScriptDialogArgs

SetPromptText sets the PromptText optional argument. The text to enter into the dialog prompt before accepting. Used only if this is a prompt dialog. 

type PageNavigateArgs struct {
	URL            string                     `json:"url"`                      // URL to navigate the page to.
	Referrer       *string                    `json:"referrer,omitempty"`       // Referrer URL.
	TransitionType cdptype.PageTransitionType `json:"transitionType,omitempty"` // Intended transition type.
}

PageNavigateArgs represents the arguments for Navigate in the Page domain.

func NewPageNavigateArgs 

func NewPageNavigateArgs(url string) *PageNavigateArgs

NewPageNavigateArgs initializes PageNavigateArgs with the required arguments. 

func (a *PageNavigateArgs) SetReferrer(referrer string) *PageNavigateArgs

SetReferrer sets the Referrer optional argument. Referrer URL. 

func (a *PageNavigateArgs) SetTransitionType(transitionType cdptype.PageTransitionType) *PageNavigateArgs

SetTransitionType sets the TransitionType optional argument. Intended transition type. 

type PageNavigateReply struct {
	FrameID cdptype.PageFrameID `json:"frameId"` // Frame id that will be navigated.
}

PageNavigateReply represents the return values for Navigate in the Page domain. 

type PageNavigateToHistoryEntryArgs struct {
	EntryID int `json:"entryId"` // Unique id of the entry to navigate to.
}

PageNavigateToHistoryEntryArgs represents the arguments for NavigateToHistoryEntry in the Page domain.

func NewPageNavigateToHistoryEntryArgs 

func NewPageNavigateToHistoryEntryArgs(entryID int) *PageNavigateToHistoryEntryArgs

NewPageNavigateToHistoryEntryArgs initializes PageNavigateToHistoryEntryArgs with the required arguments.

type PagePrintToPDFArgs 

type PagePrintToPDFArgs struct {
	Landscape           *bool    `json:"landscape,omitempty"`           // Paper orientation. Defaults to false.
	DisplayHeaderFooter *bool    `json:"displayHeaderFooter,omitempty"` // Display header and footer. Defaults to false.
	PrintBackground     *bool    `json:"printBackground,omitempty"`     // Print background graphics. Defaults to false.
	Scale               *float64 `json:"scale,omitempty"`               // Scale of the webpage rendering. Defaults to 1.
	PaperWidth          *float64 `json:"paperWidth,omitempty"`          // Paper width in inches. Defaults to 8.5 inches.
	PaperHeight         *float64 `json:"paperHeight,omitempty"`         // Paper height in inches. Defaults to 11 inches.
	MarginTop           *float64 `json:"marginTop,omitempty"`           // Top margin in inches. Defaults to 1cm (~0.4 inches).
	MarginBottom        *float64 `json:"marginBottom,omitempty"`        // Bottom margin in inches. Defaults to 1cm (~0.4 inches).
	MarginLeft          *float64 `json:"marginLeft,omitempty"`          // Left margin in inches. Defaults to 1cm (~0.4 inches).
	MarginRight         *float64 `json:"marginRight,omitempty"`         // Right margin in inches. Defaults to 1cm (~0.4 inches).
	PageRanges          *string  `json:"pageRanges,omitempty"`          // Paper ranges to print, e.g., '1-5, 8, 11-13'. Defaults to the empty string, which means print all pages.
}

PagePrintToPDFArgs represents the arguments for PrintToPDF in the Page domain.

func NewPagePrintToPDFArgs 

func NewPagePrintToPDFArgs() *PagePrintToPDFArgs

NewPagePrintToPDFArgs initializes PagePrintToPDFArgs with the required arguments.

func (*PagePrintToPDFArgs) SetDisplayHeaderFooter 

func (a *PagePrintToPDFArgs) SetDisplayHeaderFooter(displayHeaderFooter bool) *PagePrintToPDFArgs

SetDisplayHeaderFooter sets the DisplayHeaderFooter optional argument. Display header and footer. Defaults to false.

func (*PagePrintToPDFArgs) SetLandscape 

func (a *PagePrintToPDFArgs) SetLandscape(landscape bool) *PagePrintToPDFArgs

SetLandscape sets the Landscape optional argument. Paper orientation. Defaults to false.

func (*PagePrintToPDFArgs) SetMarginBottom 

func (a *PagePrintToPDFArgs) SetMarginBottom(marginBottom float64) *PagePrintToPDFArgs

SetMarginBottom sets the MarginBottom optional argument. Bottom margin in inches. Defaults to 1cm (~0.4 inches).

func (*PagePrintToPDFArgs) SetMarginLeft 

func (a *PagePrintToPDFArgs) SetMarginLeft(marginLeft float64) *PagePrintToPDFArgs

SetMarginLeft sets the MarginLeft optional argument. Left margin in inches. Defaults to 1cm (~0.4 inches).

func (*PagePrintToPDFArgs) SetMarginRight 

func (a *PagePrintToPDFArgs) SetMarginRight(marginRight float64) *PagePrintToPDFArgs

SetMarginRight sets the MarginRight optional argument. Right margin in inches. Defaults to 1cm (~0.4 inches).

func (*PagePrintToPDFArgs) SetMarginTop 

func (a *PagePrintToPDFArgs) SetMarginTop(marginTop float64) *PagePrintToPDFArgs

SetMarginTop sets the MarginTop optional argument. Top margin in inches. Defaults to 1cm (~0.4 inches).

func (*PagePrintToPDFArgs) SetPageRanges 

func (a *PagePrintToPDFArgs) SetPageRanges(pageRanges string) *PagePrintToPDFArgs

SetPageRanges sets the PageRanges optional argument. Paper ranges to print, e.g., '1-5, 8, 11-13'. Defaults to the empty string, which means print all pages.

func (*PagePrintToPDFArgs) SetPaperHeight 

func (a *PagePrintToPDFArgs) SetPaperHeight(paperHeight float64) *PagePrintToPDFArgs

SetPaperHeight sets the PaperHeight optional argument. Paper height in inches. Defaults to 11 inches.

func (*PagePrintToPDFArgs) SetPaperWidth 

func (a *PagePrintToPDFArgs) SetPaperWidth(paperWidth float64) *PagePrintToPDFArgs

SetPaperWidth sets the PaperWidth optional argument. Paper width in inches. Defaults to 8.5 inches.

func (*PagePrintToPDFArgs) SetPrintBackground 

func (a *PagePrintToPDFArgs) SetPrintBackground(printBackground bool) *PagePrintToPDFArgs

SetPrintBackground sets the PrintBackground optional argument. Print background graphics. Defaults to false.

func (*PagePrintToPDFArgs) SetScale 

func (a *PagePrintToPDFArgs) SetScale(scale float64) *PagePrintToPDFArgs

SetScale sets the Scale optional argument. Scale of the webpage rendering. Defaults to 1.

type PagePrintToPDFReply 

type PagePrintToPDFReply struct {
	Data []byte `json:"data"` // Base64-encoded pdf data.
}

PagePrintToPDFReply represents the return values for PrintToPDF in the Page domain.

type PageProcessNavigationArgs 

type PageProcessNavigationArgs struct {
	Response     cdptype.PageNavigationResponse `json:"response"`     //
	NavigationID int                            `json:"navigationId"` //
}

PageProcessNavigationArgs represents the arguments for ProcessNavigation in the Page domain.

func NewPageProcessNavigationArgs 

func NewPageProcessNavigationArgs(response cdptype.PageNavigationResponse, navigationID int) *PageProcessNavigationArgs

NewPageProcessNavigationArgs initializes PageProcessNavigationArgs with the required arguments.

type PageReloadArgs 

type PageReloadArgs struct {
	IgnoreCache            *bool   `json:"ignoreCache,omitempty"`            // If true, browser cache is ignored (as if the user pressed Shift+refresh).
	ScriptToEvaluateOnLoad *string `json:"scriptToEvaluateOnLoad,omitempty"` // If set, the script will be injected into all frames of the inspected page after reload.
}

PageReloadArgs represents the arguments for Reload in the Page domain.

func NewPageReloadArgs 

func NewPageReloadArgs() *PageReloadArgs

NewPageReloadArgs initializes PageReloadArgs with the required arguments.

func (*PageReloadArgs) SetIgnoreCache 

func (a *PageReloadArgs) SetIgnoreCache(ignoreCache bool) *PageReloadArgs

SetIgnoreCache sets the IgnoreCache optional argument. If true, browser cache is ignored (as if the user pressed Shift+refresh).

func (*PageReloadArgs) SetScriptToEvaluateOnLoad 

func (a *PageReloadArgs) SetScriptToEvaluateOnLoad(scriptToEvaluateOnLoad string) *PageReloadArgs

SetScriptToEvaluateOnLoad sets the ScriptToEvaluateOnLoad optional argument. If set, the script will be injected into all frames of the inspected page after reload.

type PageRemoveScriptToEvaluateOnLoadArgs 

type PageRemoveScriptToEvaluateOnLoadArgs struct {
	Identifier cdptype.PageScriptIdentifier `json:"identifier"` //
}

PageRemoveScriptToEvaluateOnLoadArgs represents the arguments for RemoveScriptToEvaluateOnLoad in the Page domain.

func NewPageRemoveScriptToEvaluateOnLoadArgs 

func NewPageRemoveScriptToEvaluateOnLoadArgs(identifier cdptype.PageScriptIdentifier) *PageRemoveScriptToEvaluateOnLoadArgs

NewPageRemoveScriptToEvaluateOnLoadArgs initializes PageRemoveScriptToEvaluateOnLoadArgs with the required arguments.

type PageScreencastFrameAckArgs 

type PageScreencastFrameAckArgs struct {
	SessionID int `json:"sessionId"` // Frame number.
}

PageScreencastFrameAckArgs represents the arguments for ScreencastFrameAck in the Page domain.

func NewPageScreencastFrameAckArgs 

func NewPageScreencastFrameAckArgs(sessionID int) *PageScreencastFrameAckArgs

NewPageScreencastFrameAckArgs initializes PageScreencastFrameAckArgs with the required arguments.

type PageSearchInResourceArgs 

type PageSearchInResourceArgs struct {
	FrameID       cdptype.PageFrameID `json:"frameId"`                 // Frame id for resource to search in.
	URL           string              `json:"url"`                     // URL of the resource to search in.
	Query         string              `json:"query"`                   // String to search for.
	CaseSensitive *bool               `json:"caseSensitive,omitempty"` // If true, search is case sensitive.
	IsRegex       *bool               `json:"isRegex,omitempty"`       // If true, treats string parameter as regex.
}

PageSearchInResourceArgs represents the arguments for SearchInResource in the Page domain.

func NewPageSearchInResourceArgs 

func NewPageSearchInResourceArgs(frameID cdptype.PageFrameID, url string, query string) *PageSearchInResourceArgs

NewPageSearchInResourceArgs initializes PageSearchInResourceArgs with the required arguments.

func (*PageSearchInResourceArgs) SetCaseSensitive 

func (a *PageSearchInResourceArgs) SetCaseSensitive(caseSensitive bool) *PageSearchInResourceArgs

SetCaseSensitive sets the CaseSensitive optional argument. If true, search is case sensitive.

func (*PageSearchInResourceArgs) SetIsRegex 

func (a *PageSearchInResourceArgs) SetIsRegex(isRegex bool) *PageSearchInResourceArgs

SetIsRegex sets the IsRegex optional argument. If true, treats string parameter as regex.

type PageSearchInResourceReply 

type PageSearchInResourceReply struct {
	Result []cdptype.DebuggerSearchMatch `json:"result"` // List of search matches.
}

PageSearchInResourceReply represents the return values for SearchInResource in the Page domain.

type PageSetAutoAttachToCreatedPagesArgs 

type PageSetAutoAttachToCreatedPagesArgs struct {
	AutoAttach bool `json:"autoAttach"` // If true, browser will open a new inspector window for every page created from this one.
}

PageSetAutoAttachToCreatedPagesArgs represents the arguments for SetAutoAttachToCreatedPages in the Page domain.

func NewPageSetAutoAttachToCreatedPagesArgs 

func NewPageSetAutoAttachToCreatedPagesArgs(autoAttach bool) *PageSetAutoAttachToCreatedPagesArgs

NewPageSetAutoAttachToCreatedPagesArgs initializes PageSetAutoAttachToCreatedPagesArgs with the required arguments.

type PageSetControlNavigationsArgs 

type PageSetControlNavigationsArgs struct {
	Enabled bool `json:"enabled"` //
}

PageSetControlNavigationsArgs represents the arguments for SetControlNavigations in the Page domain.

func NewPageSetControlNavigationsArgs 

func NewPageSetControlNavigationsArgs(enabled bool) *PageSetControlNavigationsArgs

NewPageSetControlNavigationsArgs initializes PageSetControlNavigationsArgs with the required arguments.

type PageSetDeviceMetricsOverrideArgs 

type PageSetDeviceMetricsOverrideArgs struct {
	Width             int                                 `json:"width"`                       // Overriding width value in pixels (minimum 0, maximum 10000000). 0 disables the override.
	Height            int                                 `json:"height"`                      // Overriding height value in pixels (minimum 0, maximum 10000000). 0 disables the override.
	DeviceScaleFactor float64                             `json:"deviceScaleFactor"`           // Overriding device scale factor value. 0 disables the override.
	Mobile            bool                                `json:"mobile"`                      // Whether to emulate mobile device. This includes viewport meta tag, overlay scrollbars, text autosizing and more.
	FitWindow         bool                                `json:"fitWindow"`                   // Whether a view that exceeds the available browser window area should be scaled down to fit.
	Scale             *float64                            `json:"scale,omitempty"`             // Scale to apply to resulting view image. Ignored in |fitWindow| mode.
	OffsetX           *float64                            `json:"offsetX,omitempty"`           // X offset to shift resulting view image by. Ignored in |fitWindow| mode.
	OffsetY           *float64                            `json:"offsetY,omitempty"`           // Y offset to shift resulting view image by. Ignored in |fitWindow| mode.
	ScreenWidth       *int                                `json:"screenWidth,omitempty"`       // Overriding screen width value in pixels (minimum 0, maximum 10000000). Only used for |mobile==true|.
	ScreenHeight      *int                                `json:"screenHeight,omitempty"`      // Overriding screen height value in pixels (minimum 0, maximum 10000000). Only used for |mobile==true|.
	PositionX         *int                                `json:"positionX,omitempty"`         // Overriding view X position on screen in pixels (minimum 0, maximum 10000000). Only used for |mobile==true|.
	PositionY         *int                                `json:"positionY,omitempty"`         // Overriding view Y position on screen in pixels (minimum 0, maximum 10000000). Only used for |mobile==true|.
	ScreenOrientation *cdptype.EmulationScreenOrientation `json:"screenOrientation,omitempty"` // Screen orientation override.
}

PageSetDeviceMetricsOverrideArgs represents the arguments for SetDeviceMetricsOverride in the Page domain.

func NewPageSetDeviceMetricsOverrideArgs 

func NewPageSetDeviceMetricsOverrideArgs(width int, height int, deviceScaleFactor float64, mobile bool, fitWindow bool) *PageSetDeviceMetricsOverrideArgs

NewPageSetDeviceMetricsOverrideArgs initializes PageSetDeviceMetricsOverrideArgs with the required arguments.

func (*PageSetDeviceMetricsOverrideArgs) SetOffsetX 

func (a *PageSetDeviceMetricsOverrideArgs) SetOffsetX(offsetX float64) *PageSetDeviceMetricsOverrideArgs

SetOffsetX sets the OffsetX optional argument. X offset to shift resulting view image by. Ignored in |fitWindow| mode.

func (*PageSetDeviceMetricsOverrideArgs) SetOffsetY 

func (a *PageSetDeviceMetricsOverrideArgs) SetOffsetY(offsetY float64) *PageSetDeviceMetricsOverrideArgs

SetOffsetY sets the OffsetY optional argument. Y offset to shift resulting view image by. Ignored in |fitWindow| mode.

func (*PageSetDeviceMetricsOverrideArgs) SetPositionX 

func (a *PageSetDeviceMetricsOverrideArgs) SetPositionX(positionX int) *PageSetDeviceMetricsOverrideArgs

SetPositionX sets the PositionX optional argument. Overriding view X position on screen in pixels (minimum 0, maximum 10000000). Only used for |mobile==true|.

func (*PageSetDeviceMetricsOverrideArgs) SetPositionY 

func (a *PageSetDeviceMetricsOverrideArgs) SetPositionY(positionY int) *PageSetDeviceMetricsOverrideArgs

SetPositionY sets the PositionY optional argument. Overriding view Y position on screen in pixels (minimum 0, maximum 10000000). Only used for |mobile==true|.

func (*PageSetDeviceMetricsOverrideArgs) SetScale 

func (a *PageSetDeviceMetricsOverrideArgs) SetScale(scale float64) *PageSetDeviceMetricsOverrideArgs

SetScale sets the Scale optional argument. Scale to apply to resulting view image. Ignored in |fitWindow| mode.

func (*PageSetDeviceMetricsOverrideArgs) SetScreenHeight 

func (a *PageSetDeviceMetricsOverrideArgs) SetScreenHeight(screenHeight int) *PageSetDeviceMetricsOverrideArgs

SetScreenHeight sets the ScreenHeight optional argument. Overriding screen height value in pixels (minimum 0, maximum 10000000). Only used for |mobile==true|.

func (*PageSetDeviceMetricsOverrideArgs) SetScreenOrientation 

func (a *PageSetDeviceMetricsOverrideArgs) SetScreenOrientation(screenOrientation cdptype.EmulationScreenOrientation) *PageSetDeviceMetricsOverrideArgs

SetScreenOrientation sets the ScreenOrientation optional argument. Screen orientation override.

func (*PageSetDeviceMetricsOverrideArgs) SetScreenWidth 

func (a *PageSetDeviceMetricsOverrideArgs) SetScreenWidth(screenWidth int) *PageSetDeviceMetricsOverrideArgs

SetScreenWidth sets the ScreenWidth optional argument. Overriding screen width value in pixels (minimum 0, maximum 10000000). Only used for |mobile==true|.

type PageSetDeviceOrientationOverrideArgs 

type PageSetDeviceOrientationOverrideArgs struct {
	Alpha float64 `json:"alpha"` // Mock alpha
	Beta  float64 `json:"beta"`  // Mock beta
	Gamma float64 `json:"gamma"` // Mock gamma
}

PageSetDeviceOrientationOverrideArgs represents the arguments for SetDeviceOrientationOverride in the Page domain.

func NewPageSetDeviceOrientationOverrideArgs 

func NewPageSetDeviceOrientationOverrideArgs(alpha float64, beta float64, gamma float64) *PageSetDeviceOrientationOverrideArgs

NewPageSetDeviceOrientationOverrideArgs initializes PageSetDeviceOrientationOverrideArgs with the required arguments.

type PageSetDocumentContentArgs 

type PageSetDocumentContentArgs struct {
	FrameID cdptype.PageFrameID `json:"frameId"` // Frame id to set HTML for.
	HTML    string              `json:"html"`    // HTML content to set.
}

PageSetDocumentContentArgs represents the arguments for SetDocumentContent in the Page domain.

func NewPageSetDocumentContentArgs 

func NewPageSetDocumentContentArgs(frameID cdptype.PageFrameID, html string) *PageSetDocumentContentArgs

NewPageSetDocumentContentArgs initializes PageSetDocumentContentArgs with the required arguments.

type PageSetGeolocationOverrideArgs 

type PageSetGeolocationOverrideArgs struct {
	Latitude  *float64 `json:"latitude,omitempty"`  // Mock latitude
	Longitude *float64 `json:"longitude,omitempty"` // Mock longitude
	Accuracy  *float64 `json:"accuracy,omitempty"`  // Mock accuracy
}

PageSetGeolocationOverrideArgs represents the arguments for SetGeolocationOverride in the Page domain.

func NewPageSetGeolocationOverrideArgs 

func NewPageSetGeolocationOverrideArgs() *PageSetGeolocationOverrideArgs

NewPageSetGeolocationOverrideArgs initializes PageSetGeolocationOverrideArgs with the required arguments.

func (*PageSetGeolocationOverrideArgs) SetAccuracy 

func (a *PageSetGeolocationOverrideArgs) SetAccuracy(accuracy float64) *PageSetGeolocationOverrideArgs

SetAccuracy sets the Accuracy optional argument. Mock accuracy

func (*PageSetGeolocationOverrideArgs) SetLatitude 

func (a *PageSetGeolocationOverrideArgs) SetLatitude(latitude float64) *PageSetGeolocationOverrideArgs

SetLatitude sets the Latitude optional argument. Mock latitude

func (*PageSetGeolocationOverrideArgs) SetLongitude 

func (a *PageSetGeolocationOverrideArgs) SetLongitude(longitude float64) *PageSetGeolocationOverrideArgs

SetLongitude sets the Longitude optional argument. Mock longitude

type PageSetTouchEmulationEnabledArgs 

type PageSetTouchEmulationEnabledArgs struct {
	Enabled       bool    `json:"enabled"`                 // Whether the touch event emulation should be enabled.
	Configuration *string `json:"configuration,omitempty"` // Touch/gesture events configuration. Default: current platform.
}

PageSetTouchEmulationEnabledArgs represents the arguments for SetTouchEmulationEnabled in the Page domain.

func NewPageSetTouchEmulationEnabledArgs 

func NewPageSetTouchEmulationEnabledArgs(enabled bool) *PageSetTouchEmulationEnabledArgs

NewPageSetTouchEmulationEnabledArgs initializes PageSetTouchEmulationEnabledArgs with the required arguments.

func (*PageSetTouchEmulationEnabledArgs) SetConfiguration 

func (a *PageSetTouchEmulationEnabledArgs) SetConfiguration(configuration string) *PageSetTouchEmulationEnabledArgs

SetConfiguration sets the Configuration optional argument. Touch/gesture events configuration. Default: current platform.

type PageStartScreencastArgs 

type PageStartScreencastArgs struct {
	Format        *string `json:"format,omitempty"`        // Image compression format.
	Quality       *int    `json:"quality,omitempty"`       // Compression quality from range [0..100].
	MaxWidth      *int    `json:"maxWidth,omitempty"`      // Maximum screenshot width.
	MaxHeight     *int    `json:"maxHeight,omitempty"`     // Maximum screenshot height.
	EveryNthFrame *int    `json:"everyNthFrame,omitempty"` // Send every n-th frame.
}

PageStartScreencastArgs represents the arguments for StartScreencast in the Page domain.

func NewPageStartScreencastArgs 

func NewPageStartScreencastArgs() *PageStartScreencastArgs

NewPageStartScreencastArgs initializes PageStartScreencastArgs with the required arguments.

func (*PageStartScreencastArgs) SetEveryNthFrame 

func (a *PageStartScreencastArgs) SetEveryNthFrame(everyNthFrame int) *PageStartScreencastArgs

SetEveryNthFrame sets the EveryNthFrame optional argument. Send every n-th frame.

func (*PageStartScreencastArgs) SetFormat 

func (a *PageStartScreencastArgs) SetFormat(format string) *PageStartScreencastArgs

SetFormat sets the Format optional argument. Image compression format.

func (*PageStartScreencastArgs) SetMaxHeight 

func (a *PageStartScreencastArgs) SetMaxHeight(maxHeight int) *PageStartScreencastArgs

SetMaxHeight sets the MaxHeight optional argument. Maximum screenshot height.

func (*PageStartScreencastArgs) SetMaxWidth 

func (a *PageStartScreencastArgs) SetMaxWidth(maxWidth int) *PageStartScreencastArgs

SetMaxWidth sets the MaxWidth optional argument. Maximum screenshot width.

func (*PageStartScreencastArgs) SetQuality 

func (a *PageStartScreencastArgs) SetQuality(quality int) *PageStartScreencastArgs

SetQuality sets the Quality optional argument. Compression quality from range [0..100].

type ProfilerGetBestEffortCoverageReply 

type ProfilerGetBestEffortCoverageReply struct {
	Result []cdptype.ProfilerScriptCoverage `json:"result"` // Coverage data for the current isolate.
}

ProfilerGetBestEffortCoverageReply represents the return values for GetBestEffortCoverage in the Profiler domain.

type ProfilerSetSamplingIntervalArgs 

type ProfilerSetSamplingIntervalArgs struct {
	Interval int `json:"interval"` // New sampling interval in microseconds.
}

ProfilerSetSamplingIntervalArgs represents the arguments for SetSamplingInterval in the Profiler domain.

func NewProfilerSetSamplingIntervalArgs 

func NewProfilerSetSamplingIntervalArgs(interval int) *ProfilerSetSamplingIntervalArgs

NewProfilerSetSamplingIntervalArgs initializes ProfilerSetSamplingIntervalArgs with the required arguments.

type ProfilerStartPreciseCoverageArgs 

type ProfilerStartPreciseCoverageArgs struct {
	CallCount *bool `json:"callCount,omitempty"` // Collect accurate call counts beyond simple 'covered' or 'not covered'.
}

ProfilerStartPreciseCoverageArgs represents the arguments for StartPreciseCoverage in the Profiler domain.

func NewProfilerStartPreciseCoverageArgs 

func NewProfilerStartPreciseCoverageArgs() *ProfilerStartPreciseCoverageArgs

NewProfilerStartPreciseCoverageArgs initializes ProfilerStartPreciseCoverageArgs with the required arguments.

func (*ProfilerStartPreciseCoverageArgs) SetCallCount 

func (a *ProfilerStartPreciseCoverageArgs) SetCallCount(callCount bool) *ProfilerStartPreciseCoverageArgs

SetCallCount sets the CallCount optional argument. Collect accurate call counts beyond simple 'covered' or 'not covered'.

type ProfilerStopReply 

type ProfilerStopReply struct {
	Profile cdptype.ProfilerProfile `json:"profile"` // Recorded profile.
}

ProfilerStopReply represents the return values for Stop in the Profiler domain.

type ProfilerTakePreciseCoverageReply 

type ProfilerTakePreciseCoverageReply struct {
	Result []cdptype.ProfilerScriptCoverage `json:"result"` // Coverage data for the current isolate.
}

ProfilerTakePreciseCoverageReply represents the return values for TakePreciseCoverage in the Profiler domain.

type RuntimeAwaitPromiseArgs 

type RuntimeAwaitPromiseArgs struct {
	PromiseObjectID cdptype.RuntimeRemoteObjectID `json:"promiseObjectId"`           // Identifier of the promise.
	ReturnByValue   *bool                         `json:"returnByValue,omitempty"`   // Whether the result is expected to be a JSON object that should be sent by value.
	GeneratePreview *bool                         `json:"generatePreview,omitempty"` // Whether preview should be generated for the result.
}

RuntimeAwaitPromiseArgs represents the arguments for AwaitPromise in the Runtime domain.

func NewRuntimeAwaitPromiseArgs 

func NewRuntimeAwaitPromiseArgs(promiseObjectID cdptype.RuntimeRemoteObjectID) *RuntimeAwaitPromiseArgs

NewRuntimeAwaitPromiseArgs initializes RuntimeAwaitPromiseArgs with the required arguments.

func (*RuntimeAwaitPromiseArgs) SetGeneratePreview 

func (a *RuntimeAwaitPromiseArgs) SetGeneratePreview(generatePreview bool) *RuntimeAwaitPromiseArgs

SetGeneratePreview sets the GeneratePreview optional argument. Whether preview should be generated for the result.

func (*RuntimeAwaitPromiseArgs) SetReturnByValue 

func (a *RuntimeAwaitPromiseArgs) SetReturnByValue(returnByValue bool) *RuntimeAwaitPromiseArgs

SetReturnByValue sets the ReturnByValue optional argument. Whether the result is expected to be a JSON object that should be sent by value.

type RuntimeAwaitPromiseReply 

type RuntimeAwaitPromiseReply struct {
	Result           cdptype.RuntimeRemoteObject      `json:"result"`                     // Promise result. Will contain rejected value if promise was rejected.
	ExceptionDetails *cdptype.RuntimeExceptionDetails `json:"exceptionDetails,omitempty"` // Exception details if stack strace is available.
}

RuntimeAwaitPromiseReply represents the return values for AwaitPromise in the Runtime domain.

type RuntimeCallFunctionOnArgs 

type RuntimeCallFunctionOnArgs struct {
	ObjectID            cdptype.RuntimeRemoteObjectID `json:"objectId"`                  // Identifier of the object to call function on.
	FunctionDeclaration string                        `json:"functionDeclaration"`       // Declaration of the function to call.
	Arguments           []cdptype.RuntimeCallArgument `json:"arguments,omitempty"`       // Call arguments. All call arguments must belong to the same JavaScript world as the target object.
	Silent              *bool                         `json:"silent,omitempty"`          // In silent mode exceptions thrown during evaluation are not reported and do not pause execution. Overrides setPauseOnException state.
	ReturnByValue       *bool                         `json:"returnByValue,omitempty"`   // Whether the result is expected to be a JSON object which should be sent by value.
	GeneratePreview     *bool                         `json:"generatePreview,omitempty"` // Whether preview should be generated for the result.
	UserGesture         *bool                         `json:"userGesture,omitempty"`     // Whether execution should be treated as initiated by user in the UI.
	AwaitPromise        *bool                         `json:"awaitPromise,omitempty"`    // Whether execution should wait for promise to be resolved. If the result of evaluation is not a Promise, it's considered to be an error.
}

RuntimeCallFunctionOnArgs represents the arguments for CallFunctionOn in the Runtime domain.

func NewRuntimeCallFunctionOnArgs 

func NewRuntimeCallFunctionOnArgs(objectID cdptype.RuntimeRemoteObjectID, functionDeclaration string) *RuntimeCallFunctionOnArgs

NewRuntimeCallFunctionOnArgs initializes RuntimeCallFunctionOnArgs with the required arguments.

func (*RuntimeCallFunctionOnArgs) SetArguments 

func (a *RuntimeCallFunctionOnArgs) SetArguments(arguments []cdptype.RuntimeCallArgument) *RuntimeCallFunctionOnArgs

SetArguments sets the Arguments optional argument. Call arguments. All call arguments must belong to the same JavaScript world as the target object.

func (*RuntimeCallFunctionOnArgs) SetAwaitPromise 

func (a *RuntimeCallFunctionOnArgs) SetAwaitPromise(awaitPromise bool) *RuntimeCallFunctionOnArgs

SetAwaitPromise sets the AwaitPromise optional argument. Whether execution should wait for promise to be resolved. If the result of evaluation is not a Promise, it's considered to be an error.

func (*RuntimeCallFunctionOnArgs) SetGeneratePreview 

func (a *RuntimeCallFunctionOnArgs) SetGeneratePreview(generatePreview bool) *RuntimeCallFunctionOnArgs

SetGeneratePreview sets the GeneratePreview optional argument. Whether preview should be generated for the result.

func (*RuntimeCallFunctionOnArgs) SetReturnByValue 

func (a *RuntimeCallFunctionOnArgs) SetReturnByValue(returnByValue bool) *RuntimeCallFunctionOnArgs

SetReturnByValue sets the ReturnByValue optional argument. Whether the result is expected to be a JSON object which should be sent by value.

func (*RuntimeCallFunctionOnArgs) SetSilent 

func (a *RuntimeCallFunctionOnArgs) SetSilent(silent bool) *RuntimeCallFunctionOnArgs

SetSilent sets the Silent optional argument. In silent mode exceptions thrown during evaluation are not reported and do not pause execution. Overrides setPauseOnException state.

func (*RuntimeCallFunctionOnArgs) SetUserGesture 

func (a *RuntimeCallFunctionOnArgs) SetUserGesture(userGesture bool) *RuntimeCallFunctionOnArgs

SetUserGesture sets the UserGesture optional argument. Whether execution should be treated as initiated by user in the UI.

type RuntimeCallFunctionOnReply 

type RuntimeCallFunctionOnReply struct {
	Result           cdptype.RuntimeRemoteObject      `json:"result"`                     // Call result.
	ExceptionDetails *cdptype.RuntimeExceptionDetails `json:"exceptionDetails,omitempty"` // Exception details.
}

RuntimeCallFunctionOnReply represents the return values for CallFunctionOn in the Runtime domain.

type RuntimeCompileScriptArgs 

type RuntimeCompileScriptArgs struct {
	Expression         string                             `json:"expression"`                   // Expression to compile.
	SourceURL          string                             `json:"sourceURL"`                    // Source url to be set for the script.
	PersistScript      bool                               `json:"persistScript"`                // Specifies whether the compiled script should be persisted.
	ExecutionContextID *cdptype.RuntimeExecutionContextID `json:"executionContextId,omitempty"` // Specifies in which execution context to perform script run. If the parameter is omitted the evaluation will be performed in the context of the inspected page.
}

RuntimeCompileScriptArgs represents the arguments for CompileScript in the Runtime domain.

func NewRuntimeCompileScriptArgs 

func NewRuntimeCompileScriptArgs(expression string, sourceURL string, persistScript bool) *RuntimeCompileScriptArgs

NewRuntimeCompileScriptArgs initializes RuntimeCompileScriptArgs with the required arguments.

func (*RuntimeCompileScriptArgs) SetExecutionContextID 

func (a *RuntimeCompileScriptArgs) SetExecutionContextID(executionContextID cdptype.RuntimeExecutionContextID) *RuntimeCompileScriptArgs

SetExecutionContextID sets the ExecutionContextID optional argument. Specifies in which execution context to perform script run. If the parameter is omitted the evaluation will be performed in the context of the inspected page.

type RuntimeCompileScriptReply 

type RuntimeCompileScriptReply struct {
	ScriptID         *cdptype.RuntimeScriptID         `json:"scriptId,omitempty"`         // Id of the script.
	ExceptionDetails *cdptype.RuntimeExceptionDetails `json:"exceptionDetails,omitempty"` // Exception details.
}

RuntimeCompileScriptReply represents the return values for CompileScript in the Runtime domain.

type RuntimeEvaluateArgs 

type RuntimeEvaluateArgs struct {
	Expression            string                             `json:"expression"`                      // Expression to evaluate.
	ObjectGroup           *string                            `json:"objectGroup,omitempty"`           // Symbolic group name that can be used to release multiple objects.
	IncludeCommandLineAPI *bool                              `json:"includeCommandLineAPI,omitempty"` // Determines whether Command Line API should be available during the evaluation.
	Silent                *bool                              `json:"silent,omitempty"`                // In silent mode exceptions thrown during evaluation are not reported and do not pause execution. Overrides setPauseOnException state.
	ContextID             *cdptype.RuntimeExecutionContextID `json:"contextId,omitempty"`             // 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.
	ReturnByValue         *bool                              `json:"returnByValue,omitempty"`         // Whether the result is expected to be a JSON object that should be sent by value.
	GeneratePreview       *bool                              `json:"generatePreview,omitempty"`       // Whether preview should be generated for the result.
	UserGesture           *bool                              `json:"userGesture,omitempty"`           // Whether execution should be treated as initiated by user in the UI.
	AwaitPromise          *bool                              `json:"awaitPromise,omitempty"`          // Whether execution should wait for promise to be resolved. If the result of evaluation is not a Promise, it's considered to be an error.
}

RuntimeEvaluateArgs represents the arguments for Evaluate in the Runtime domain.

func NewRuntimeEvaluateArgs 

func NewRuntimeEvaluateArgs(expression string) *RuntimeEvaluateArgs

NewRuntimeEvaluateArgs initializes RuntimeEvaluateArgs with the required arguments.

func (*RuntimeEvaluateArgs) SetAwaitPromise 

func (a *RuntimeEvaluateArgs) SetAwaitPromise(awaitPromise bool) *RuntimeEvaluateArgs

SetAwaitPromise sets the AwaitPromise optional argument. Whether execution should wait for promise to be resolved. If the result of evaluation is not a Promise, it's considered to be an error.

func (*RuntimeEvaluateArgs) SetContextID 

func (a *RuntimeEvaluateArgs) SetContextID(contextID cdptype.RuntimeExecutionContextID) *RuntimeEvaluateArgs

SetContextID sets the ContextID optional argument. 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 (*RuntimeEvaluateArgs) SetGeneratePreview 

func (a *RuntimeEvaluateArgs) SetGeneratePreview(generatePreview bool) *RuntimeEvaluateArgs

SetGeneratePreview sets the GeneratePreview optional argument. Whether preview should be generated for the result.

func (*RuntimeEvaluateArgs) SetIncludeCommandLineAPI 

func (a *RuntimeEvaluateArgs) SetIncludeCommandLineAPI(includeCommandLineAPI bool) *RuntimeEvaluateArgs

SetIncludeCommandLineAPI sets the IncludeCommandLineAPI optional argument. Determines whether Command Line API should be available during the evaluation.

func (*RuntimeEvaluateArgs) SetObjectGroup 

func (a *RuntimeEvaluateArgs) SetObjectGroup(objectGroup string) *RuntimeEvaluateArgs

SetObjectGroup sets the ObjectGroup optional argument. Symbolic group name that can be used to release multiple objects.

func (*RuntimeEvaluateArgs) SetReturnByValue 

func (a *RuntimeEvaluateArgs) SetReturnByValue(returnByValue bool) *RuntimeEvaluateArgs

SetReturnByValue sets the ReturnByValue optional argument. Whether the result is expected to be a JSON object that should be sent by value.

func (*RuntimeEvaluateArgs) SetSilent 

func (a *RuntimeEvaluateArgs) SetSilent(silent bool) *RuntimeEvaluateArgs

SetSilent sets the Silent optional argument. In silent mode exceptions thrown during evaluation are not reported and do not pause execution. Overrides setPauseOnException state.

func (*RuntimeEvaluateArgs) SetUserGesture 

func (a *RuntimeEvaluateArgs) SetUserGesture(userGesture bool) *RuntimeEvaluateArgs

SetUserGesture sets the UserGesture optional argument. Whether execution should be treated as initiated by user in the UI.

type RuntimeEvaluateReply 

type RuntimeEvaluateReply struct {
	Result           cdptype.RuntimeRemoteObject      `json:"result"`                     // Evaluation result.
	ExceptionDetails *cdptype.RuntimeExceptionDetails `json:"exceptionDetails,omitempty"` // Exception details.
}

RuntimeEvaluateReply represents the return values for Evaluate in the Runtime domain.

type RuntimeGetPropertiesArgs 

type RuntimeGetPropertiesArgs struct {
	ObjectID               cdptype.RuntimeRemoteObjectID `json:"objectId"`                         // Identifier of the object to return properties for.
	OwnProperties          *bool                         `json:"ownProperties,omitempty"`          // If true, returns properties belonging only to the element itself, not to its prototype chain.
	AccessorPropertiesOnly *bool                         `json:"accessorPropertiesOnly,omitempty"` // If true, returns accessor properties (with getter/setter) only; internal properties are not returned either.
	GeneratePreview        *bool                         `json:"generatePreview,omitempty"`        // Whether preview should be generated for the results.
}

RuntimeGetPropertiesArgs represents the arguments for GetProperties in the Runtime domain.

func NewRuntimeGetPropertiesArgs 

func NewRuntimeGetPropertiesArgs(objectID cdptype.RuntimeRemoteObjectID) *RuntimeGetPropertiesArgs

NewRuntimeGetPropertiesArgs initializes RuntimeGetPropertiesArgs with the required arguments.

func (*RuntimeGetPropertiesArgs) SetAccessorPropertiesOnly 

func (a *RuntimeGetPropertiesArgs) SetAccessorPropertiesOnly(accessorPropertiesOnly bool) *RuntimeGetPropertiesArgs

SetAccessorPropertiesOnly sets the AccessorPropertiesOnly optional argument. If true, returns accessor properties (with getter/setter) only; internal properties are not returned either.

func (*RuntimeGetPropertiesArgs) SetGeneratePreview 

func (a *RuntimeGetPropertiesArgs) SetGeneratePreview(generatePreview bool) *RuntimeGetPropertiesArgs

SetGeneratePreview sets the GeneratePreview optional argument. Whether preview should be generated for the results.

func (*RuntimeGetPropertiesArgs) SetOwnProperties 

func (a *RuntimeGetPropertiesArgs) SetOwnProperties(ownProperties bool) *RuntimeGetPropertiesArgs

SetOwnProperties sets the OwnProperties optional argument. If true, returns properties belonging only to the element itself, not to its prototype chain.

type RuntimeGetPropertiesReply 

type RuntimeGetPropertiesReply struct {
	Result             []cdptype.RuntimePropertyDescriptor         `json:"result"`                       // Object properties.
	InternalProperties []cdptype.RuntimeInternalPropertyDescriptor `json:"internalProperties,omitempty"` // Internal object properties (only of the element itself).
	ExceptionDetails   *cdptype.RuntimeExceptionDetails            `json:"exceptionDetails,omitempty"`   // Exception details.
}

RuntimeGetPropertiesReply represents the return values for GetProperties in the Runtime domain.

type RuntimeReleaseObjectArgs 

type RuntimeReleaseObjectArgs struct {
	ObjectID cdptype.RuntimeRemoteObjectID `json:"objectId"` // Identifier of the object to release.
}

RuntimeReleaseObjectArgs represents the arguments for ReleaseObject in the Runtime domain.

func NewRuntimeReleaseObjectArgs 

func NewRuntimeReleaseObjectArgs(objectID cdptype.RuntimeRemoteObjectID) *RuntimeReleaseObjectArgs

NewRuntimeReleaseObjectArgs initializes RuntimeReleaseObjectArgs with the required arguments.

type RuntimeReleaseObjectGroupArgs 

type RuntimeReleaseObjectGroupArgs struct {
	ObjectGroup string `json:"objectGroup"` // Symbolic object group name.
}

RuntimeReleaseObjectGroupArgs represents the arguments for ReleaseObjectGroup in the Runtime domain.

func NewRuntimeReleaseObjectGroupArgs 

func NewRuntimeReleaseObjectGroupArgs(objectGroup string) *RuntimeReleaseObjectGroupArgs

NewRuntimeReleaseObjectGroupArgs initializes RuntimeReleaseObjectGroupArgs with the required arguments.

type RuntimeRunScriptArgs 

type RuntimeRunScriptArgs struct {
	ScriptID              cdptype.RuntimeScriptID            `json:"scriptId"`                        // Id of the script to run.
	ExecutionContextID    *cdptype.RuntimeExecutionContextID `json:"executionContextId,omitempty"`    // Specifies in which execution context to perform script run. If the parameter is omitted the evaluation will be performed in the context of the inspected page.
	ObjectGroup           *string                            `json:"objectGroup,omitempty"`           // Symbolic group name that can be used to release multiple objects.
	Silent                *bool                              `json:"silent,omitempty"`                // In silent mode exceptions thrown during evaluation are not reported and do not pause execution. Overrides setPauseOnException state.
	IncludeCommandLineAPI *bool                              `json:"includeCommandLineAPI,omitempty"` // Determines whether Command Line API should be available during the evaluation.
	ReturnByValue         *bool                              `json:"returnByValue,omitempty"`         // Whether the result is expected to be a JSON object which should be sent by value.
	GeneratePreview       *bool                              `json:"generatePreview,omitempty"`       // Whether preview should be generated for the result.
	AwaitPromise          *bool                              `json:"awaitPromise,omitempty"`          // Whether execution should wait for promise to be resolved. If the result of evaluation is not a Promise, it's considered to be an error.
}

RuntimeRunScriptArgs represents the arguments for RunScript in the Runtime domain.

func NewRuntimeRunScriptArgs 

func NewRuntimeRunScriptArgs(scriptID cdptype.RuntimeScriptID) *RuntimeRunScriptArgs

NewRuntimeRunScriptArgs initializes RuntimeRunScriptArgs with the required arguments.

func (*RuntimeRunScriptArgs) SetAwaitPromise 

func (a *RuntimeRunScriptArgs) SetAwaitPromise(awaitPromise bool) *RuntimeRunScriptArgs

SetAwaitPromise sets the AwaitPromise optional argument. Whether execution should wait for promise to be resolved. If the result of evaluation is not a Promise, it's considered to be an error.

func (*RuntimeRunScriptArgs) SetExecutionContextID 

func (a *RuntimeRunScriptArgs) SetExecutionContextID(executionContextID cdptype.RuntimeExecutionContextID) *RuntimeRunScriptArgs

SetExecutionContextID sets the ExecutionContextID optional argument. Specifies in which execution context to perform script run. If the parameter is omitted the evaluation will be performed in the context of the inspected page.

func (*RuntimeRunScriptArgs) SetGeneratePreview 

func (a *RuntimeRunScriptArgs) SetGeneratePreview(generatePreview bool) *RuntimeRunScriptArgs

SetGeneratePreview sets the GeneratePreview optional argument. Whether preview should be generated for the result.

func (*RuntimeRunScriptArgs) SetIncludeCommandLineAPI 

func (a *RuntimeRunScriptArgs) SetIncludeCommandLineAPI(includeCommandLineAPI bool) *RuntimeRunScriptArgs

SetIncludeCommandLineAPI sets the IncludeCommandLineAPI optional argument. Determines whether Command Line API should be available during the evaluation.

func (*RuntimeRunScriptArgs) SetObjectGroup 

func (a *RuntimeRunScriptArgs) SetObjectGroup(objectGroup string) *RuntimeRunScriptArgs

SetObjectGroup sets the ObjectGroup optional argument. Symbolic group name that can be used to release multiple objects.

func (*RuntimeRunScriptArgs) SetReturnByValue 

func (a *RuntimeRunScriptArgs) SetReturnByValue(returnByValue bool) *RuntimeRunScriptArgs

SetReturnByValue sets the ReturnByValue optional argument. Whether the result is expected to be a JSON object which should be sent by value.

func (*RuntimeRunScriptArgs) SetSilent 

func (a *RuntimeRunScriptArgs) SetSilent(silent bool) *RuntimeRunScriptArgs

SetSilent sets the Silent optional argument. In silent mode exceptions thrown during evaluation are not reported and do not pause execution. Overrides setPauseOnException state.

type RuntimeRunScriptReply 

type RuntimeRunScriptReply struct {
	Result           cdptype.RuntimeRemoteObject      `json:"result"`                     // Run result.
	ExceptionDetails *cdptype.RuntimeExceptionDetails `json:"exceptionDetails,omitempty"` // Exception details.
}

RuntimeRunScriptReply represents the return values for RunScript in the Runtime domain.

type RuntimeSetCustomObjectFormatterEnabledArgs 

type RuntimeSetCustomObjectFormatterEnabledArgs struct {
	Enabled bool `json:"enabled"` //
}

RuntimeSetCustomObjectFormatterEnabledArgs represents the arguments for SetCustomObjectFormatterEnabled in the Runtime domain.

func NewRuntimeSetCustomObjectFormatterEnabledArgs 

func NewRuntimeSetCustomObjectFormatterEnabledArgs(enabled bool) *RuntimeSetCustomObjectFormatterEnabledArgs

NewRuntimeSetCustomObjectFormatterEnabledArgs initializes RuntimeSetCustomObjectFormatterEnabledArgs with the required arguments.

type SchemaGetDomainsReply 

type SchemaGetDomainsReply struct {
	Domains []cdptype.SchemaDomain `json:"domains"` // List of supported domains.
}

SchemaGetDomainsReply represents the return values for GetDomains in the Schema domain.

type SecurityHandleCertificateErrorArgs 

type SecurityHandleCertificateErrorArgs struct {
	EventID int                                    `json:"eventId"` // The ID of the event.
	Action  cdptype.SecurityCertificateErrorAction `json:"action"`  // The action to take on the certificate error.
}

SecurityHandleCertificateErrorArgs represents the arguments for HandleCertificateError in the Security domain.

func NewSecurityHandleCertificateErrorArgs 

func NewSecurityHandleCertificateErrorArgs(eventID int, action cdptype.SecurityCertificateErrorAction) *SecurityHandleCertificateErrorArgs

NewSecurityHandleCertificateErrorArgs initializes SecurityHandleCertificateErrorArgs with the required arguments.

type SecuritySetOverrideCertificateErrorsArgs 

type SecuritySetOverrideCertificateErrorsArgs struct {
	Override bool `json:"override"` // If true, certificate errors will be overridden.
}

SecuritySetOverrideCertificateErrorsArgs represents the arguments for SetOverrideCertificateErrors in the Security domain.

func NewSecuritySetOverrideCertificateErrorsArgs 

func NewSecuritySetOverrideCertificateErrorsArgs(override bool) *SecuritySetOverrideCertificateErrorsArgs

NewSecuritySetOverrideCertificateErrorsArgs initializes SecuritySetOverrideCertificateErrorsArgs with the required arguments.

type ServiceWorkerDeliverPushMessageArgs 

type ServiceWorkerDeliverPushMessageArgs struct {
	Origin         string `json:"origin"`         //
	RegistrationID string `json:"registrationId"` //
	Data           string `json:"data"`           //
}

ServiceWorkerDeliverPushMessageArgs represents the arguments for DeliverPushMessage in the ServiceWorker domain.

func NewServiceWorkerDeliverPushMessageArgs 

func NewServiceWorkerDeliverPushMessageArgs(origin string, registrationID string, data string) *ServiceWorkerDeliverPushMessageArgs

NewServiceWorkerDeliverPushMessageArgs initializes ServiceWorkerDeliverPushMessageArgs with the required arguments.

type ServiceWorkerDispatchSyncEventArgs 

type ServiceWorkerDispatchSyncEventArgs struct {
	Origin         string `json:"origin"`         //
	RegistrationID string `json:"registrationId"` //
	Tag            string `json:"tag"`            //
	LastChance     bool   `json:"lastChance"`     //
}

ServiceWorkerDispatchSyncEventArgs represents the arguments for DispatchSyncEvent in the ServiceWorker domain.

func NewServiceWorkerDispatchSyncEventArgs 

func NewServiceWorkerDispatchSyncEventArgs(origin string, registrationID string, tag string, lastChance bool) *ServiceWorkerDispatchSyncEventArgs

NewServiceWorkerDispatchSyncEventArgs initializes ServiceWorkerDispatchSyncEventArgs with the required arguments.

type ServiceWorkerInspectWorkerArgs 

type ServiceWorkerInspectWorkerArgs struct {
	VersionID string `json:"versionId"` //
}

ServiceWorkerInspectWorkerArgs represents the arguments for InspectWorker in the ServiceWorker domain.

func NewServiceWorkerInspectWorkerArgs 

func NewServiceWorkerInspectWorkerArgs(versionID string) *ServiceWorkerInspectWorkerArgs

NewServiceWorkerInspectWorkerArgs initializes ServiceWorkerInspectWorkerArgs with the required arguments.

type ServiceWorkerSetForceUpdateOnPageLoadArgs 

type ServiceWorkerSetForceUpdateOnPageLoadArgs struct {
	ForceUpdateOnPageLoad bool `json:"forceUpdateOnPageLoad"` //
}

ServiceWorkerSetForceUpdateOnPageLoadArgs represents the arguments for SetForceUpdateOnPageLoad in the ServiceWorker domain.

func NewServiceWorkerSetForceUpdateOnPageLoadArgs 

func NewServiceWorkerSetForceUpdateOnPageLoadArgs(forceUpdateOnPageLoad bool) *ServiceWorkerSetForceUpdateOnPageLoadArgs

NewServiceWorkerSetForceUpdateOnPageLoadArgs initializes ServiceWorkerSetForceUpdateOnPageLoadArgs with the required arguments.

type ServiceWorkerSkipWaitingArgs 

type ServiceWorkerSkipWaitingArgs struct {
	ScopeURL string `json:"scopeURL"` //
}

ServiceWorkerSkipWaitingArgs represents the arguments for SkipWaiting in the ServiceWorker domain.

func NewServiceWorkerSkipWaitingArgs 

func NewServiceWorkerSkipWaitingArgs(scopeURL string) *ServiceWorkerSkipWaitingArgs

NewServiceWorkerSkipWaitingArgs initializes ServiceWorkerSkipWaitingArgs with the required arguments.

type ServiceWorkerStartWorkerArgs 

type ServiceWorkerStartWorkerArgs struct {
	ScopeURL string `json:"scopeURL"` //
}

ServiceWorkerStartWorkerArgs represents the arguments for StartWorker in the ServiceWorker domain.

func NewServiceWorkerStartWorkerArgs 

func NewServiceWorkerStartWorkerArgs(scopeURL string) *ServiceWorkerStartWorkerArgs

NewServiceWorkerStartWorkerArgs initializes ServiceWorkerStartWorkerArgs with the required arguments.

type ServiceWorkerStopWorkerArgs 

type ServiceWorkerStopWorkerArgs struct {
	VersionID string `json:"versionId"` //
}

ServiceWorkerStopWorkerArgs represents the arguments for StopWorker in the ServiceWorker domain.

func NewServiceWorkerStopWorkerArgs 

func NewServiceWorkerStopWorkerArgs(versionID string) *ServiceWorkerStopWorkerArgs

NewServiceWorkerStopWorkerArgs initializes ServiceWorkerStopWorkerArgs with the required arguments.

type ServiceWorkerUnregisterArgs 

type ServiceWorkerUnregisterArgs struct {
	ScopeURL string `json:"scopeURL"` //
}

ServiceWorkerUnregisterArgs represents the arguments for Unregister in the ServiceWorker domain.

func NewServiceWorkerUnregisterArgs 

func NewServiceWorkerUnregisterArgs(scopeURL string) *ServiceWorkerUnregisterArgs

NewServiceWorkerUnregisterArgs initializes ServiceWorkerUnregisterArgs with the required arguments.

type ServiceWorkerUpdateRegistrationArgs 

type ServiceWorkerUpdateRegistrationArgs struct {
	ScopeURL string `json:"scopeURL"` //
}

ServiceWorkerUpdateRegistrationArgs represents the arguments for UpdateRegistration in the ServiceWorker domain.

func NewServiceWorkerUpdateRegistrationArgs 

func NewServiceWorkerUpdateRegistrationArgs(scopeURL string) *ServiceWorkerUpdateRegistrationArgs

NewServiceWorkerUpdateRegistrationArgs initializes ServiceWorkerUpdateRegistrationArgs with the required arguments.

type StorageClearDataForOriginArgs 

type StorageClearDataForOriginArgs struct {
	Origin       string `json:"origin"`       // Security origin.
	StorageTypes string `json:"storageTypes"` // Comma separated origin names.
}

StorageClearDataForOriginArgs represents the arguments for ClearDataForOrigin in the Storage domain.

func NewStorageClearDataForOriginArgs 

func NewStorageClearDataForOriginArgs(origin string, storageTypes string) *StorageClearDataForOriginArgs

NewStorageClearDataForOriginArgs initializes StorageClearDataForOriginArgs with the required arguments.

type StorageGetUsageAndQuotaArgs 

type StorageGetUsageAndQuotaArgs struct {
	Origin string `json:"origin"` // Security origin.
}

StorageGetUsageAndQuotaArgs represents the arguments for GetUsageAndQuota in the Storage domain.

func NewStorageGetUsageAndQuotaArgs 

func NewStorageGetUsageAndQuotaArgs(origin string) *StorageGetUsageAndQuotaArgs

NewStorageGetUsageAndQuotaArgs initializes StorageGetUsageAndQuotaArgs with the required arguments.

type StorageGetUsageAndQuotaReply 

type StorageGetUsageAndQuotaReply struct {
	Usage          float64                       `json:"usage"`          // Storage usage (bytes).
	Quota          float64                       `json:"quota"`          // Storage quota (bytes).
	UsageBreakdown []cdptype.StorageUsageForType `json:"usageBreakdown"` // Storage usage per type (bytes).
}

StorageGetUsageAndQuotaReply represents the return values for GetUsageAndQuota in the Storage domain.

type SystemInfoGetInfoReply 

type SystemInfoGetInfoReply struct {
	GPU          cdptype.SystemInfoGPUInfo `json:"gpu"`          // Information about the GPUs on the system.
	ModelName    string                    `json:"modelName"`    // A platform-dependent description of the model of the machine. On Mac OS, this is, for example, 'MacBookPro'. Will be the empty string if not supported.
	ModelVersion string                    `json:"modelVersion"` // A platform-dependent description of the version of the machine. On Mac OS, this is, for example, '10.1'. Will be the empty string if not supported.
	CommandLine  string                    `json:"commandLine"`  // The command line string used to launch the browser. Will be the empty string if not supported.
}

SystemInfoGetInfoReply represents the return values for GetInfo in the SystemInfo domain.

type TargetActivateTargetArgs 

type TargetActivateTargetArgs struct {
	TargetID cdptype.TargetID `json:"targetId"` //
}

TargetActivateTargetArgs represents the arguments for ActivateTarget in the Target domain.

func NewTargetActivateTargetArgs 

func NewTargetActivateTargetArgs(targetID cdptype.TargetID) *TargetActivateTargetArgs

NewTargetActivateTargetArgs initializes TargetActivateTargetArgs with the required arguments.

type TargetAttachToTargetArgs 

type TargetAttachToTargetArgs struct {
	TargetID cdptype.TargetID `json:"targetId"` //
}

TargetAttachToTargetArgs represents the arguments for AttachToTarget in the Target domain.

func NewTargetAttachToTargetArgs 

func NewTargetAttachToTargetArgs(targetID cdptype.TargetID) *TargetAttachToTargetArgs

NewTargetAttachToTargetArgs initializes TargetAttachToTargetArgs with the required arguments.

type TargetAttachToTargetReply 

type TargetAttachToTargetReply struct {
	Success bool `json:"success"` // Whether attach succeeded.
}

TargetAttachToTargetReply represents the return values for AttachToTarget in the Target domain.

type TargetCloseTargetArgs 

type TargetCloseTargetArgs struct {
	TargetID cdptype.TargetID `json:"targetId"` //
}

TargetCloseTargetArgs represents the arguments for CloseTarget in the Target domain.

func NewTargetCloseTargetArgs 

func NewTargetCloseTargetArgs(targetID cdptype.TargetID) *TargetCloseTargetArgs

NewTargetCloseTargetArgs initializes TargetCloseTargetArgs with the required arguments.

type TargetCloseTargetReply 

type TargetCloseTargetReply struct {
	Success bool `json:"success"` //
}

TargetCloseTargetReply represents the return values for CloseTarget in the Target domain.

type TargetCreateBrowserContextReply 

type TargetCreateBrowserContextReply struct {
	BrowserContextID cdptype.TargetBrowserContextID `json:"browserContextId"` // The id of the context created.
}

TargetCreateBrowserContextReply represents the return values for CreateBrowserContext in the Target domain.

type TargetCreateTargetArgs 

type TargetCreateTargetArgs struct {
	URL              string                          `json:"url"`                        // The initial URL the page will be navigated to.
	Width            *int                            `json:"width,omitempty"`            // Frame width in DIP (headless chrome only).
	Height           *int                            `json:"height,omitempty"`           // Frame height in DIP (headless chrome only).
	BrowserContextID *cdptype.TargetBrowserContextID `json:"browserContextId,omitempty"` // The browser context to create the page in (headless chrome only).
}

TargetCreateTargetArgs represents the arguments for CreateTarget in the Target domain.

func NewTargetCreateTargetArgs 

func NewTargetCreateTargetArgs(url string) *TargetCreateTargetArgs

NewTargetCreateTargetArgs initializes TargetCreateTargetArgs with the required arguments.

func (*TargetCreateTargetArgs) SetBrowserContextID 

func (a *TargetCreateTargetArgs) SetBrowserContextID(browserContextID cdptype.TargetBrowserContextID) *TargetCreateTargetArgs

SetBrowserContextID sets the BrowserContextID optional argument. The browser context to create the page in (headless chrome only).

func (*TargetCreateTargetArgs) SetHeight 

func (a *TargetCreateTargetArgs) SetHeight(height int) *TargetCreateTargetArgs

SetHeight sets the Height optional argument. Frame height in DIP (headless chrome only).

func (*TargetCreateTargetArgs) SetWidth 

func (a *TargetCreateTargetArgs) SetWidth(width int) *TargetCreateTargetArgs

SetWidth sets the Width optional argument. Frame width in DIP (headless chrome only).

type TargetCreateTargetReply 

type TargetCreateTargetReply struct {
	TargetID cdptype.TargetID `json:"targetId"` // The id of the page opened.
}

TargetCreateTargetReply represents the return values for CreateTarget in the Target domain.

type TargetDetachFromTargetArgs 

type TargetDetachFromTargetArgs struct {
	TargetID cdptype.TargetID `json:"targetId"` //
}

TargetDetachFromTargetArgs represents the arguments for DetachFromTarget in the Target domain.

func NewTargetDetachFromTargetArgs 

func NewTargetDetachFromTargetArgs(targetID cdptype.TargetID) *TargetDetachFromTargetArgs

NewTargetDetachFromTargetArgs initializes TargetDetachFromTargetArgs with the required arguments.

type TargetDisposeBrowserContextArgs 

type TargetDisposeBrowserContextArgs struct {
	BrowserContextID cdptype.TargetBrowserContextID `json:"browserContextId"` //
}

TargetDisposeBrowserContextArgs represents the arguments for DisposeBrowserContext in the Target domain.

func NewTargetDisposeBrowserContextArgs 

func NewTargetDisposeBrowserContextArgs(browserContextID cdptype.TargetBrowserContextID) *TargetDisposeBrowserContextArgs

NewTargetDisposeBrowserContextArgs initializes TargetDisposeBrowserContextArgs with the required arguments.

type TargetDisposeBrowserContextReply 

type TargetDisposeBrowserContextReply struct {
	Success bool `json:"success"` //
}

TargetDisposeBrowserContextReply represents the return values for DisposeBrowserContext in the Target domain.

type TargetGetTargetInfoArgs 

type TargetGetTargetInfoArgs struct {
	TargetID cdptype.TargetID `json:"targetId"` //
}

TargetGetTargetInfoArgs represents the arguments for GetTargetInfo in the Target domain.

func NewTargetGetTargetInfoArgs 

func NewTargetGetTargetInfoArgs(targetID cdptype.TargetID) *TargetGetTargetInfoArgs

NewTargetGetTargetInfoArgs initializes TargetGetTargetInfoArgs with the required arguments.

type TargetGetTargetInfoReply 

type TargetGetTargetInfoReply struct {
	TargetInfo cdptype.TargetInfo `json:"targetInfo"` //
}

TargetGetTargetInfoReply represents the return values for GetTargetInfo in the Target domain.

type TargetGetTargetsReply 

type TargetGetTargetsReply struct {
	TargetInfos []cdptype.TargetInfo `json:"targetInfos"` // The list of targets.
}

TargetGetTargetsReply represents the return values for GetTargets in the Target domain.

type TargetSendMessageToTargetArgs 

type TargetSendMessageToTargetArgs struct {
	TargetID cdptype.TargetID `json:"targetId"` //
	Message  string           `json:"message"`  //
}

TargetSendMessageToTargetArgs represents the arguments for SendMessageToTarget in the Target domain.

func NewTargetSendMessageToTargetArgs 

func NewTargetSendMessageToTargetArgs(targetID cdptype.TargetID, message string) *TargetSendMessageToTargetArgs

NewTargetSendMessageToTargetArgs initializes TargetSendMessageToTargetArgs with the required arguments.

type TargetSetAttachToFramesArgs 

type TargetSetAttachToFramesArgs struct {
	Value bool `json:"value"` // Whether to attach to frames.
}

TargetSetAttachToFramesArgs represents the arguments for SetAttachToFrames in the Target domain.

func NewTargetSetAttachToFramesArgs 

func NewTargetSetAttachToFramesArgs(value bool) *TargetSetAttachToFramesArgs

NewTargetSetAttachToFramesArgs initializes TargetSetAttachToFramesArgs with the required arguments.

type TargetSetAutoAttachArgs 

type TargetSetAutoAttachArgs struct {
	AutoAttach             bool `json:"autoAttach"`             // Whether to auto-attach to related targets.
	WaitForDebuggerOnStart bool `json:"waitForDebuggerOnStart"` // Whether to pause new targets when attaching to them. Use Runtime.runIfWaitingForDebugger to run paused targets.
}

TargetSetAutoAttachArgs represents the arguments for SetAutoAttach in the Target domain.

func NewTargetSetAutoAttachArgs 

func NewTargetSetAutoAttachArgs(autoAttach bool, waitForDebuggerOnStart bool) *TargetSetAutoAttachArgs

NewTargetSetAutoAttachArgs initializes TargetSetAutoAttachArgs with the required arguments.

type TargetSetDiscoverTargetsArgs 

type TargetSetDiscoverTargetsArgs struct {
	Discover bool `json:"discover"` // Whether to discover available targets.
}

TargetSetDiscoverTargetsArgs represents the arguments for SetDiscoverTargets in the Target domain.

func NewTargetSetDiscoverTargetsArgs 

func NewTargetSetDiscoverTargetsArgs(discover bool) *TargetSetDiscoverTargetsArgs

NewTargetSetDiscoverTargetsArgs initializes TargetSetDiscoverTargetsArgs with the required arguments.

type TargetSetRemoteLocationsArgs 

type TargetSetRemoteLocationsArgs struct {
	Locations []cdptype.TargetRemoteLocation `json:"locations"` // List of remote locations.
}

TargetSetRemoteLocationsArgs represents the arguments for SetRemoteLocations in the Target domain.

func NewTargetSetRemoteLocationsArgs 

func NewTargetSetRemoteLocationsArgs(locations []cdptype.TargetRemoteLocation) *TargetSetRemoteLocationsArgs

NewTargetSetRemoteLocationsArgs initializes TargetSetRemoteLocationsArgs with the required arguments.

type TetheringBindArgs 

type TetheringBindArgs struct {
	Port int `json:"port"` // Port number to bind.
}

TetheringBindArgs represents the arguments for Bind in the Tethering domain.

func NewTetheringBindArgs 

func NewTetheringBindArgs(port int) *TetheringBindArgs

NewTetheringBindArgs initializes TetheringBindArgs with the required arguments.

type TetheringUnbindArgs 

type TetheringUnbindArgs struct {
	Port int `json:"port"` // Port number to unbind.
}

TetheringUnbindArgs represents the arguments for Unbind in the Tethering domain.

func NewTetheringUnbindArgs 

func NewTetheringUnbindArgs(port int) *TetheringUnbindArgs

NewTetheringUnbindArgs initializes TetheringUnbindArgs with the required arguments.

type TracingGetCategoriesReply 

type TracingGetCategoriesReply struct {
	Categories []string `json:"categories"` // A list of supported tracing categories.
}

TracingGetCategoriesReply represents the return values for GetCategories in the Tracing domain.

type TracingRecordClockSyncMarkerArgs 

type TracingRecordClockSyncMarkerArgs struct {
	SyncID string `json:"syncId"` // The ID of this clock sync marker
}

TracingRecordClockSyncMarkerArgs represents the arguments for RecordClockSyncMarker in the Tracing domain.

func NewTracingRecordClockSyncMarkerArgs 

func NewTracingRecordClockSyncMarkerArgs(syncID string) *TracingRecordClockSyncMarkerArgs

NewTracingRecordClockSyncMarkerArgs initializes TracingRecordClockSyncMarkerArgs with the required arguments.

type TracingRequestMemoryDumpReply 

type TracingRequestMemoryDumpReply struct {
	DumpGUID string `json:"dumpGuid"` // GUID of the resulting global memory dump.
	Success  bool   `json:"success"`  // True iff the global memory dump succeeded.
}

TracingRequestMemoryDumpReply represents the return values for RequestMemoryDump in the Tracing domain.

type TracingStartArgs 

type TracingStartArgs struct {
	Categories                   *string                     `json:"categories,omitempty"`                   // Category/tag filter
	Options                      *string                     `json:"options,omitempty"`                      // Tracing options
	BufferUsageReportingInterval *float64                    `json:"bufferUsageReportingInterval,omitempty"` // If set, the agent will issue bufferUsage events at this interval, specified in milliseconds
	TransferMode                 *string                     `json:"transferMode,omitempty"`                 // Whether to report trace events as series of dataCollected events or to save trace to a stream (defaults to ReportEvents).
	TraceConfig                  *cdptype.TracingTraceConfig `json:"traceConfig,omitempty"`                  //
}

TracingStartArgs represents the arguments for Start in the Tracing domain.

func NewTracingStartArgs 

func NewTracingStartArgs() *TracingStartArgs

NewTracingStartArgs initializes TracingStartArgs with the required arguments.

func (*TracingStartArgs) SetBufferUsageReportingInterval 

func (a *TracingStartArgs) SetBufferUsageReportingInterval(bufferUsageReportingInterval float64) *TracingStartArgs

SetBufferUsageReportingInterval sets the BufferUsageReportingInterval optional argument. If set, the agent will issue bufferUsage events at this interval, specified in milliseconds

func (*TracingStartArgs) SetCategories 

func (a *TracingStartArgs) SetCategories(categories string) *TracingStartArgs

SetCategories sets the Categories optional argument. Category/tag filter

func (*TracingStartArgs) SetOptions 

func (a *TracingStartArgs) SetOptions(options string) *TracingStartArgs

SetOptions sets the Options optional argument. Tracing options

func (*TracingStartArgs) SetTraceConfig 

func (a *TracingStartArgs) SetTraceConfig(traceConfig cdptype.TracingTraceConfig) *TracingStartArgs

SetTraceConfig sets the TraceConfig optional argument.

func (*TracingStartArgs) SetTransferMode 

func (a *TracingStartArgs) SetTransferMode(transferMode string) *TracingStartArgs

SetTransferMode sets the TransferMode optional argument. Whether to report trace events as series of dataCollected events or to save trace to a stream (defaults to ReportEvents).

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.