// This file is generated by "./lib/proto/generate"

package proto_test

import (
	"github.com/go-rod/rod/lib/proto"
)

func (t T) AccessibilityDisable() {
	c := &Client{}
	err := proto.AccessibilityDisable{}.Call(c)
	t.Nil(err)
}

func (t T) AccessibilityEnable() {
	c := &Client{}
	err := proto.AccessibilityEnable{}.Call(c)
	t.Nil(err)
}

func (t T) AccessibilityGetPartialAXTree() {
	c := &Client{}
	_, err := proto.AccessibilityGetPartialAXTree{}.Call(c)
	t.Nil(err)
}

func (t T) AccessibilityGetFullAXTree() {
	c := &Client{}
	_, err := proto.AccessibilityGetFullAXTree{}.Call(c)
	t.Nil(err)
}

func (t T) AccessibilityGetRootAXNode() {
	c := &Client{}
	_, err := proto.AccessibilityGetRootAXNode{}.Call(c)
	t.Nil(err)
}

func (t T) AccessibilityGetAXNodeAndAncestors() {
	c := &Client{}
	_, err := proto.AccessibilityGetAXNodeAndAncestors{}.Call(c)
	t.Nil(err)
}

func (t T) AccessibilityGetChildAXNodes() {
	c := &Client{}
	_, err := proto.AccessibilityGetChildAXNodes{}.Call(c)
	t.Nil(err)
}

func (t T) AccessibilityQueryAXTree() {
	c := &Client{}
	_, err := proto.AccessibilityQueryAXTree{}.Call(c)
	t.Nil(err)
}

func (t T) AccessibilityLoadComplete() {
	e := proto.AccessibilityLoadComplete{}
	t.Regex("", e.ProtoEvent())
}

func (t T) AccessibilityNodesUpdated() {
	e := proto.AccessibilityNodesUpdated{}
	t.Regex("", e.ProtoEvent())
}

func (t T) AnimationDisable() {
	c := &Client{}
	err := proto.AnimationDisable{}.Call(c)
	t.Nil(err)
}

func (t T) AnimationEnable() {
	c := &Client{}
	err := proto.AnimationEnable{}.Call(c)
	t.Nil(err)
}

func (t T) AnimationGetCurrentTime() {
	c := &Client{}
	_, err := proto.AnimationGetCurrentTime{}.Call(c)
	t.Nil(err)
}

func (t T) AnimationGetPlaybackRate() {
	c := &Client{}
	_, err := proto.AnimationGetPlaybackRate{}.Call(c)
	t.Nil(err)
}

func (t T) AnimationReleaseAnimations() {
	c := &Client{}
	err := proto.AnimationReleaseAnimations{}.Call(c)
	t.Nil(err)
}

func (t T) AnimationResolveAnimation() {
	c := &Client{}
	_, err := proto.AnimationResolveAnimation{}.Call(c)
	t.Nil(err)
}

func (t T) AnimationSeekAnimations() {
	c := &Client{}
	err := proto.AnimationSeekAnimations{}.Call(c)
	t.Nil(err)
}

func (t T) AnimationSetPaused() {
	c := &Client{}
	err := proto.AnimationSetPaused{}.Call(c)
	t.Nil(err)
}

func (t T) AnimationSetPlaybackRate() {
	c := &Client{}
	err := proto.AnimationSetPlaybackRate{}.Call(c)
	t.Nil(err)
}

func (t T) AnimationSetTiming() {
	c := &Client{}
	err := proto.AnimationSetTiming{}.Call(c)
	t.Nil(err)
}

func (t T) AnimationAnimationCanceled() {
	e := proto.AnimationAnimationCanceled{}
	t.Regex("", e.ProtoEvent())
}

func (t T) AnimationAnimationCreated() {
	e := proto.AnimationAnimationCreated{}
	t.Regex("", e.ProtoEvent())
}

func (t T) AnimationAnimationStarted() {
	e := proto.AnimationAnimationStarted{}
	t.Regex("", e.ProtoEvent())
}

func (t T) AuditsGetEncodedResponse() {
	c := &Client{}
	_, err := proto.AuditsGetEncodedResponse{}.Call(c)
	t.Nil(err)
}

func (t T) AuditsDisable() {
	c := &Client{}
	err := proto.AuditsDisable{}.Call(c)
	t.Nil(err)
}

func (t T) AuditsEnable() {
	c := &Client{}
	err := proto.AuditsEnable{}.Call(c)
	t.Nil(err)
}

func (t T) AuditsCheckContrast() {
	c := &Client{}
	err := proto.AuditsCheckContrast{}.Call(c)
	t.Nil(err)
}

func (t T) AuditsIssueAdded() {
	e := proto.AuditsIssueAdded{}
	t.Regex("", e.ProtoEvent())
}

func (t T) BackgroundServiceStartObserving() {
	c := &Client{}
	err := proto.BackgroundServiceStartObserving{}.Call(c)
	t.Nil(err)
}

func (t T) BackgroundServiceStopObserving() {
	c := &Client{}
	err := proto.BackgroundServiceStopObserving{}.Call(c)
	t.Nil(err)
}

func (t T) BackgroundServiceSetRecording() {
	c := &Client{}
	err := proto.BackgroundServiceSetRecording{}.Call(c)
	t.Nil(err)
}

func (t T) BackgroundServiceClearEvents() {
	c := &Client{}
	err := proto.BackgroundServiceClearEvents{}.Call(c)
	t.Nil(err)
}

func (t T) BackgroundServiceRecordingStateChanged() {
	e := proto.BackgroundServiceRecordingStateChanged{}
	t.Regex("", e.ProtoEvent())
}

func (t T) BackgroundServiceBackgroundServiceEventReceived() {
	e := proto.BackgroundServiceBackgroundServiceEventReceived{}
	t.Regex("", e.ProtoEvent())
}

func (t T) BrowserSetPermission() {
	c := &Client{}
	err := proto.BrowserSetPermission{}.Call(c)
	t.Nil(err)
}

func (t T) BrowserGrantPermissions() {
	c := &Client{}
	err := proto.BrowserGrantPermissions{}.Call(c)
	t.Nil(err)
}

func (t T) BrowserResetPermissions() {
	c := &Client{}
	err := proto.BrowserResetPermissions{}.Call(c)
	t.Nil(err)
}

func (t T) BrowserSetDownloadBehavior() {
	c := &Client{}
	err := proto.BrowserSetDownloadBehavior{}.Call(c)
	t.Nil(err)
}

func (t T) BrowserCancelDownload() {
	c := &Client{}
	err := proto.BrowserCancelDownload{}.Call(c)
	t.Nil(err)
}

func (t T) BrowserClose() {
	c := &Client{}
	err := proto.BrowserClose{}.Call(c)
	t.Nil(err)
}

func (t T) BrowserCrash() {
	c := &Client{}
	err := proto.BrowserCrash{}.Call(c)
	t.Nil(err)
}

func (t T) BrowserCrashGpuProcess() {
	c := &Client{}
	err := proto.BrowserCrashGpuProcess{}.Call(c)
	t.Nil(err)
}

func (t T) BrowserGetVersion() {
	c := &Client{}
	_, err := proto.BrowserGetVersion{}.Call(c)
	t.Nil(err)
}

func (t T) BrowserGetBrowserCommandLine() {
	c := &Client{}
	_, err := proto.BrowserGetBrowserCommandLine{}.Call(c)
	t.Nil(err)
}

func (t T) BrowserGetHistograms() {
	c := &Client{}
	_, err := proto.BrowserGetHistograms{}.Call(c)
	t.Nil(err)
}

func (t T) BrowserGetHistogram() {
	c := &Client{}
	_, err := proto.BrowserGetHistogram{}.Call(c)
	t.Nil(err)
}

func (t T) BrowserGetWindowBounds() {
	c := &Client{}
	_, err := proto.BrowserGetWindowBounds{}.Call(c)
	t.Nil(err)
}

func (t T) BrowserGetWindowForTarget() {
	c := &Client{}
	_, err := proto.BrowserGetWindowForTarget{}.Call(c)
	t.Nil(err)
}

func (t T) BrowserSetWindowBounds() {
	c := &Client{}
	err := proto.BrowserSetWindowBounds{}.Call(c)
	t.Nil(err)
}

func (t T) BrowserSetDockTile() {
	c := &Client{}
	err := proto.BrowserSetDockTile{}.Call(c)
	t.Nil(err)
}

func (t T) BrowserExecuteBrowserCommand() {
	c := &Client{}
	err := proto.BrowserExecuteBrowserCommand{}.Call(c)
	t.Nil(err)
}

func (t T) BrowserDownloadWillBegin() {
	e := proto.BrowserDownloadWillBegin{}
	t.Regex("", e.ProtoEvent())
}

func (t T) BrowserDownloadProgress() {
	e := proto.BrowserDownloadProgress{}
	t.Regex("", e.ProtoEvent())
}

func (t T) CSSAddRule() {
	c := &Client{}
	_, err := proto.CSSAddRule{}.Call(c)
	t.Nil(err)
}

func (t T) CSSCollectClassNames() {
	c := &Client{}
	_, err := proto.CSSCollectClassNames{}.Call(c)
	t.Nil(err)
}

func (t T) CSSCreateStyleSheet() {
	c := &Client{}
	_, err := proto.CSSCreateStyleSheet{}.Call(c)
	t.Nil(err)
}

func (t T) CSSDisable() {
	c := &Client{}
	err := proto.CSSDisable{}.Call(c)
	t.Nil(err)
}

func (t T) CSSEnable() {
	c := &Client{}
	err := proto.CSSEnable{}.Call(c)
	t.Nil(err)
}

func (t T) CSSForcePseudoState() {
	c := &Client{}
	err := proto.CSSForcePseudoState{}.Call(c)
	t.Nil(err)
}

func (t T) CSSGetBackgroundColors() {
	c := &Client{}
	_, err := proto.CSSGetBackgroundColors{}.Call(c)
	t.Nil(err)
}

func (t T) CSSGetComputedStyleForNode() {
	c := &Client{}
	_, err := proto.CSSGetComputedStyleForNode{}.Call(c)
	t.Nil(err)
}

func (t T) CSSGetInlineStylesForNode() {
	c := &Client{}
	_, err := proto.CSSGetInlineStylesForNode{}.Call(c)
	t.Nil(err)
}

func (t T) CSSGetMatchedStylesForNode() {
	c := &Client{}
	_, err := proto.CSSGetMatchedStylesForNode{}.Call(c)
	t.Nil(err)
}

func (t T) CSSGetMediaQueries() {
	c := &Client{}
	_, err := proto.CSSGetMediaQueries{}.Call(c)
	t.Nil(err)
}

func (t T) CSSGetPlatformFontsForNode() {
	c := &Client{}
	_, err := proto.CSSGetPlatformFontsForNode{}.Call(c)
	t.Nil(err)
}

func (t T) CSSGetStyleSheetText() {
	c := &Client{}
	_, err := proto.CSSGetStyleSheetText{}.Call(c)
	t.Nil(err)
}

func (t T) CSSGetLayersForNode() {
	c := &Client{}
	_, err := proto.CSSGetLayersForNode{}.Call(c)
	t.Nil(err)
}

func (t T) CSSTrackComputedStyleUpdates() {
	c := &Client{}
	err := proto.CSSTrackComputedStyleUpdates{}.Call(c)
	t.Nil(err)
}

func (t T) CSSTakeComputedStyleUpdates() {
	c := &Client{}
	_, err := proto.CSSTakeComputedStyleUpdates{}.Call(c)
	t.Nil(err)
}

func (t T) CSSSetEffectivePropertyValueForNode() {
	c := &Client{}
	err := proto.CSSSetEffectivePropertyValueForNode{}.Call(c)
	t.Nil(err)
}

func (t T) CSSSetKeyframeKey() {
	c := &Client{}
	_, err := proto.CSSSetKeyframeKey{}.Call(c)
	t.Nil(err)
}

func (t T) CSSSetMediaText() {
	c := &Client{}
	_, err := proto.CSSSetMediaText{}.Call(c)
	t.Nil(err)
}

func (t T) CSSSetContainerQueryText() {
	c := &Client{}
	_, err := proto.CSSSetContainerQueryText{}.Call(c)
	t.Nil(err)
}

func (t T) CSSSetSupportsText() {
	c := &Client{}
	_, err := proto.CSSSetSupportsText{}.Call(c)
	t.Nil(err)
}

func (t T) CSSSetScopeText() {
	c := &Client{}
	_, err := proto.CSSSetScopeText{}.Call(c)
	t.Nil(err)
}

func (t T) CSSSetRuleSelector() {
	c := &Client{}
	_, err := proto.CSSSetRuleSelector{}.Call(c)
	t.Nil(err)
}

func (t T) CSSSetStyleSheetText() {
	c := &Client{}
	_, err := proto.CSSSetStyleSheetText{}.Call(c)
	t.Nil(err)
}

func (t T) CSSSetStyleTexts() {
	c := &Client{}
	_, err := proto.CSSSetStyleTexts{}.Call(c)
	t.Nil(err)
}

func (t T) CSSStartRuleUsageTracking() {
	c := &Client{}
	err := proto.CSSStartRuleUsageTracking{}.Call(c)
	t.Nil(err)
}

func (t T) CSSStopRuleUsageTracking() {
	c := &Client{}
	_, err := proto.CSSStopRuleUsageTracking{}.Call(c)
	t.Nil(err)
}

func (t T) CSSTakeCoverageDelta() {
	c := &Client{}
	_, err := proto.CSSTakeCoverageDelta{}.Call(c)
	t.Nil(err)
}

func (t T) CSSSetLocalFontsEnabled() {
	c := &Client{}
	err := proto.CSSSetLocalFontsEnabled{}.Call(c)
	t.Nil(err)
}

func (t T) CSSFontsUpdated() {
	e := proto.CSSFontsUpdated{}
	t.Regex("", e.ProtoEvent())
}

func (t T) CSSMediaQueryResultChanged() {
	e := proto.CSSMediaQueryResultChanged{}
	t.Regex("", e.ProtoEvent())
}

func (t T) CSSStyleSheetAdded() {
	e := proto.CSSStyleSheetAdded{}
	t.Regex("", e.ProtoEvent())
}

func (t T) CSSStyleSheetChanged() {
	e := proto.CSSStyleSheetChanged{}
	t.Regex("", e.ProtoEvent())
}

func (t T) CSSStyleSheetRemoved() {
	e := proto.CSSStyleSheetRemoved{}
	t.Regex("", e.ProtoEvent())
}

func (t T) CacheStorageDeleteCache() {
	c := &Client{}
	err := proto.CacheStorageDeleteCache{}.Call(c)
	t.Nil(err)
}

func (t T) CacheStorageDeleteEntry() {
	c := &Client{}
	err := proto.CacheStorageDeleteEntry{}.Call(c)
	t.Nil(err)
}

func (t T) CacheStorageRequestCacheNames() {
	c := &Client{}
	_, err := proto.CacheStorageRequestCacheNames{}.Call(c)
	t.Nil(err)
}

func (t T) CacheStorageRequestCachedResponse() {
	c := &Client{}
	_, err := proto.CacheStorageRequestCachedResponse{}.Call(c)
	t.Nil(err)
}

func (t T) CacheStorageRequestEntries() {
	c := &Client{}
	_, err := proto.CacheStorageRequestEntries{}.Call(c)
	t.Nil(err)
}

func (t T) CastEnable() {
	c := &Client{}
	err := proto.CastEnable{}.Call(c)
	t.Nil(err)
}

func (t T) CastDisable() {
	c := &Client{}
	err := proto.CastDisable{}.Call(c)
	t.Nil(err)
}

func (t T) CastSetSinkToUse() {
	c := &Client{}
	err := proto.CastSetSinkToUse{}.Call(c)
	t.Nil(err)
}

func (t T) CastStartDesktopMirroring() {
	c := &Client{}
	err := proto.CastStartDesktopMirroring{}.Call(c)
	t.Nil(err)
}

func (t T) CastStartTabMirroring() {
	c := &Client{}
	err := proto.CastStartTabMirroring{}.Call(c)
	t.Nil(err)
}

func (t T) CastStopCasting() {
	c := &Client{}
	err := proto.CastStopCasting{}.Call(c)
	t.Nil(err)
}

func (t T) CastSinksUpdated() {
	e := proto.CastSinksUpdated{}
	t.Regex("", e.ProtoEvent())
}

func (t T) CastIssueUpdated() {
	e := proto.CastIssueUpdated{}
	t.Regex("", e.ProtoEvent())
}

func (t T) DOMCollectClassNamesFromSubtree() {
	c := &Client{}
	_, err := proto.DOMCollectClassNamesFromSubtree{}.Call(c)
	t.Nil(err)
}

func (t T) DOMCopyTo() {
	c := &Client{}
	_, err := proto.DOMCopyTo{}.Call(c)
	t.Nil(err)
}

func (t T) DOMDescribeNode() {
	c := &Client{}
	_, err := proto.DOMDescribeNode{}.Call(c)
	t.Nil(err)
}

func (t T) DOMScrollIntoViewIfNeeded() {
	c := &Client{}
	err := proto.DOMScrollIntoViewIfNeeded{}.Call(c)
	t.Nil(err)
}

func (t T) DOMDisable() {
	c := &Client{}
	err := proto.DOMDisable{}.Call(c)
	t.Nil(err)
}

func (t T) DOMDiscardSearchResults() {
	c := &Client{}
	err := proto.DOMDiscardSearchResults{}.Call(c)
	t.Nil(err)
}

func (t T) DOMEnable() {
	c := &Client{}
	err := proto.DOMEnable{}.Call(c)
	t.Nil(err)
}

func (t T) DOMFocus() {
	c := &Client{}
	err := proto.DOMFocus{}.Call(c)
	t.Nil(err)
}

func (t T) DOMGetAttributes() {
	c := &Client{}
	_, err := proto.DOMGetAttributes{}.Call(c)
	t.Nil(err)
}

func (t T) DOMGetBoxModel() {
	c := &Client{}
	_, err := proto.DOMGetBoxModel{}.Call(c)
	t.Nil(err)
}

func (t T) DOMGetContentQuads() {
	c := &Client{}
	_, err := proto.DOMGetContentQuads{}.Call(c)
	t.Nil(err)
}

func (t T) DOMGetDocument() {
	c := &Client{}
	_, err := proto.DOMGetDocument{}.Call(c)
	t.Nil(err)
}

func (t T) DOMGetFlattenedDocument() {
	c := &Client{}
	_, err := proto.DOMGetFlattenedDocument{}.Call(c)
	t.Nil(err)
}

func (t T) DOMGetNodesForSubtreeByStyle() {
	c := &Client{}
	_, err := proto.DOMGetNodesForSubtreeByStyle{}.Call(c)
	t.Nil(err)
}

func (t T) DOMGetNodeForLocation() {
	c := &Client{}
	_, err := proto.DOMGetNodeForLocation{}.Call(c)
	t.Nil(err)
}

func (t T) DOMGetOuterHTML() {
	c := &Client{}
	_, err := proto.DOMGetOuterHTML{}.Call(c)
	t.Nil(err)
}

func (t T) DOMGetRelayoutBoundary() {
	c := &Client{}
	_, err := proto.DOMGetRelayoutBoundary{}.Call(c)
	t.Nil(err)
}

func (t T) DOMGetSearchResults() {
	c := &Client{}
	_, err := proto.DOMGetSearchResults{}.Call(c)
	t.Nil(err)
}

func (t T) DOMHideHighlight() {
	c := &Client{}
	err := proto.DOMHideHighlight{}.Call(c)
	t.Nil(err)
}

func (t T) DOMHighlightNode() {
	c := &Client{}
	err := proto.DOMHighlightNode{}.Call(c)
	t.Nil(err)
}

func (t T) DOMHighlightRect() {
	c := &Client{}
	err := proto.DOMHighlightRect{}.Call(c)
	t.Nil(err)
}

func (t T) DOMMarkUndoableState() {
	c := &Client{}
	err := proto.DOMMarkUndoableState{}.Call(c)
	t.Nil(err)
}

func (t T) DOMMoveTo() {
	c := &Client{}
	_, err := proto.DOMMoveTo{}.Call(c)
	t.Nil(err)
}

func (t T) DOMPerformSearch() {
	c := &Client{}
	_, err := proto.DOMPerformSearch{}.Call(c)
	t.Nil(err)
}

func (t T) DOMPushNodeByPathToFrontend() {
	c := &Client{}
	_, err := proto.DOMPushNodeByPathToFrontend{}.Call(c)
	t.Nil(err)
}

func (t T) DOMPushNodesByBackendIdsToFrontend() {
	c := &Client{}
	_, err := proto.DOMPushNodesByBackendIdsToFrontend{}.Call(c)
	t.Nil(err)
}

func (t T) DOMQuerySelector() {
	c := &Client{}
	_, err := proto.DOMQuerySelector{}.Call(c)
	t.Nil(err)
}

func (t T) DOMQuerySelectorAll() {
	c := &Client{}
	_, err := proto.DOMQuerySelectorAll{}.Call(c)
	t.Nil(err)
}

func (t T) DOMGetTopLayerElements() {
	c := &Client{}
	_, err := proto.DOMGetTopLayerElements{}.Call(c)
	t.Nil(err)
}

func (t T) DOMRedo() {
	c := &Client{}
	err := proto.DOMRedo{}.Call(c)
	t.Nil(err)
}

func (t T) DOMRemoveAttribute() {
	c := &Client{}
	err := proto.DOMRemoveAttribute{}.Call(c)
	t.Nil(err)
}

func (t T) DOMRemoveNode() {
	c := &Client{}
	err := proto.DOMRemoveNode{}.Call(c)
	t.Nil(err)
}

func (t T) DOMRequestChildNodes() {
	c := &Client{}
	err := proto.DOMRequestChildNodes{}.Call(c)
	t.Nil(err)
}

func (t T) DOMRequestNode() {
	c := &Client{}
	_, err := proto.DOMRequestNode{}.Call(c)
	t.Nil(err)
}

func (t T) DOMResolveNode() {
	c := &Client{}
	_, err := proto.DOMResolveNode{}.Call(c)
	t.Nil(err)
}

func (t T) DOMSetAttributeValue() {
	c := &Client{}
	err := proto.DOMSetAttributeValue{}.Call(c)
	t.Nil(err)
}

func (t T) DOMSetAttributesAsText() {
	c := &Client{}
	err := proto.DOMSetAttributesAsText{}.Call(c)
	t.Nil(err)
}

func (t T) DOMSetFileInputFiles() {
	c := &Client{}
	err := proto.DOMSetFileInputFiles{}.Call(c)
	t.Nil(err)
}

func (t T) DOMSetNodeStackTracesEnabled() {
	c := &Client{}
	err := proto.DOMSetNodeStackTracesEnabled{}.Call(c)
	t.Nil(err)
}

func (t T) DOMGetNodeStackTraces() {
	c := &Client{}
	_, err := proto.DOMGetNodeStackTraces{}.Call(c)
	t.Nil(err)
}

func (t T) DOMGetFileInfo() {
	c := &Client{}
	_, err := proto.DOMGetFileInfo{}.Call(c)
	t.Nil(err)
}

func (t T) DOMSetInspectedNode() {
	c := &Client{}
	err := proto.DOMSetInspectedNode{}.Call(c)
	t.Nil(err)
}

func (t T) DOMSetNodeName() {
	c := &Client{}
	_, err := proto.DOMSetNodeName{}.Call(c)
	t.Nil(err)
}

func (t T) DOMSetNodeValue() {
	c := &Client{}
	err := proto.DOMSetNodeValue{}.Call(c)
	t.Nil(err)
}

func (t T) DOMSetOuterHTML() {
	c := &Client{}
	err := proto.DOMSetOuterHTML{}.Call(c)
	t.Nil(err)
}

func (t T) DOMUndo() {
	c := &Client{}
	err := proto.DOMUndo{}.Call(c)
	t.Nil(err)
}

func (t T) DOMGetFrameOwner() {
	c := &Client{}
	_, err := proto.DOMGetFrameOwner{}.Call(c)
	t.Nil(err)
}

func (t T) DOMGetContainerForNode() {
	c := &Client{}
	_, err := proto.DOMGetContainerForNode{}.Call(c)
	t.Nil(err)
}

func (t T) DOMGetQueryingDescendantsForContainer() {
	c := &Client{}
	_, err := proto.DOMGetQueryingDescendantsForContainer{}.Call(c)
	t.Nil(err)
}

func (t T) DOMAttributeModified() {
	e := proto.DOMAttributeModified{}
	t.Regex("", e.ProtoEvent())
}

func (t T) DOMAttributeRemoved() {
	e := proto.DOMAttributeRemoved{}
	t.Regex("", e.ProtoEvent())
}

func (t T) DOMCharacterDataModified() {
	e := proto.DOMCharacterDataModified{}
	t.Regex("", e.ProtoEvent())
}

func (t T) DOMChildNodeCountUpdated() {
	e := proto.DOMChildNodeCountUpdated{}
	t.Regex("", e.ProtoEvent())
}

func (t T) DOMChildNodeInserted() {
	e := proto.DOMChildNodeInserted{}
	t.Regex("", e.ProtoEvent())
}

func (t T) DOMChildNodeRemoved() {
	e := proto.DOMChildNodeRemoved{}
	t.Regex("", e.ProtoEvent())
}

func (t T) DOMDistributedNodesUpdated() {
	e := proto.DOMDistributedNodesUpdated{}
	t.Regex("", e.ProtoEvent())
}

func (t T) DOMDocumentUpdated() {
	e := proto.DOMDocumentUpdated{}
	t.Regex("", e.ProtoEvent())
}

func (t T) DOMInlineStyleInvalidated() {
	e := proto.DOMInlineStyleInvalidated{}
	t.Regex("", e.ProtoEvent())
}

func (t T) DOMPseudoElementAdded() {
	e := proto.DOMPseudoElementAdded{}
	t.Regex("", e.ProtoEvent())
}

func (t T) DOMTopLayerElementsUpdated() {
	e := proto.DOMTopLayerElementsUpdated{}
	t.Regex("", e.ProtoEvent())
}

func (t T) DOMPseudoElementRemoved() {
	e := proto.DOMPseudoElementRemoved{}
	t.Regex("", e.ProtoEvent())
}

func (t T) DOMSetChildNodes() {
	e := proto.DOMSetChildNodes{}
	t.Regex("", e.ProtoEvent())
}

func (t T) DOMShadowRootPopped() {
	e := proto.DOMShadowRootPopped{}
	t.Regex("", e.ProtoEvent())
}

func (t T) DOMShadowRootPushed() {
	e := proto.DOMShadowRootPushed{}
	t.Regex("", e.ProtoEvent())
}

func (t T) DOMDebuggerGetEventListeners() {
	c := &Client{}
	_, err := proto.DOMDebuggerGetEventListeners{}.Call(c)
	t.Nil(err)
}

func (t T) DOMDebuggerRemoveDOMBreakpoint() {
	c := &Client{}
	err := proto.DOMDebuggerRemoveDOMBreakpoint{}.Call(c)
	t.Nil(err)
}

func (t T) DOMDebuggerRemoveEventListenerBreakpoint() {
	c := &Client{}
	err := proto.DOMDebuggerRemoveEventListenerBreakpoint{}.Call(c)
	t.Nil(err)
}

func (t T) DOMDebuggerRemoveInstrumentationBreakpoint() {
	c := &Client{}
	err := proto.DOMDebuggerRemoveInstrumentationBreakpoint{}.Call(c)
	t.Nil(err)
}

func (t T) DOMDebuggerRemoveXHRBreakpoint() {
	c := &Client{}
	err := proto.DOMDebuggerRemoveXHRBreakpoint{}.Call(c)
	t.Nil(err)
}

func (t T) DOMDebuggerSetBreakOnCSPViolation() {
	c := &Client{}
	err := proto.DOMDebuggerSetBreakOnCSPViolation{}.Call(c)
	t.Nil(err)
}

func (t T) DOMDebuggerSetDOMBreakpoint() {
	c := &Client{}
	err := proto.DOMDebuggerSetDOMBreakpoint{}.Call(c)
	t.Nil(err)
}

func (t T) DOMDebuggerSetEventListenerBreakpoint() {
	c := &Client{}
	err := proto.DOMDebuggerSetEventListenerBreakpoint{}.Call(c)
	t.Nil(err)
}

func (t T) DOMDebuggerSetInstrumentationBreakpoint() {
	c := &Client{}
	err := proto.DOMDebuggerSetInstrumentationBreakpoint{}.Call(c)
	t.Nil(err)
}

func (t T) DOMDebuggerSetXHRBreakpoint() {
	c := &Client{}
	err := proto.DOMDebuggerSetXHRBreakpoint{}.Call(c)
	t.Nil(err)
}

func (t T) EventBreakpointsSetInstrumentationBreakpoint() {
	c := &Client{}
	err := proto.EventBreakpointsSetInstrumentationBreakpoint{}.Call(c)
	t.Nil(err)
}

func (t T) EventBreakpointsRemoveInstrumentationBreakpoint() {
	c := &Client{}
	err := proto.EventBreakpointsRemoveInstrumentationBreakpoint{}.Call(c)
	t.Nil(err)
}

func (t T) DOMSnapshotDisable() {
	c := &Client{}
	err := proto.DOMSnapshotDisable{}.Call(c)
	t.Nil(err)
}

func (t T) DOMSnapshotEnable() {
	c := &Client{}
	err := proto.DOMSnapshotEnable{}.Call(c)
	t.Nil(err)
}

func (t T) DOMSnapshotGetSnapshot() {
	c := &Client{}
	_, err := proto.DOMSnapshotGetSnapshot{}.Call(c)
	t.Nil(err)
}

func (t T) DOMSnapshotCaptureSnapshot() {
	c := &Client{}
	_, err := proto.DOMSnapshotCaptureSnapshot{}.Call(c)
	t.Nil(err)
}

func (t T) DOMStorageClear() {
	c := &Client{}
	err := proto.DOMStorageClear{}.Call(c)
	t.Nil(err)
}

func (t T) DOMStorageDisable() {
	c := &Client{}
	err := proto.DOMStorageDisable{}.Call(c)
	t.Nil(err)
}

func (t T) DOMStorageEnable() {
	c := &Client{}
	err := proto.DOMStorageEnable{}.Call(c)
	t.Nil(err)
}

func (t T) DOMStorageGetDOMStorageItems() {
	c := &Client{}
	_, err := proto.DOMStorageGetDOMStorageItems{}.Call(c)
	t.Nil(err)
}

func (t T) DOMStorageRemoveDOMStorageItem() {
	c := &Client{}
	err := proto.DOMStorageRemoveDOMStorageItem{}.Call(c)
	t.Nil(err)
}

func (t T) DOMStorageSetDOMStorageItem() {
	c := &Client{}
	err := proto.DOMStorageSetDOMStorageItem{}.Call(c)
	t.Nil(err)
}

func (t T) DOMStorageDomStorageItemAdded() {
	e := proto.DOMStorageDomStorageItemAdded{}
	t.Regex("", e.ProtoEvent())
}

func (t T) DOMStorageDomStorageItemRemoved() {
	e := proto.DOMStorageDomStorageItemRemoved{}
	t.Regex("", e.ProtoEvent())
}

func (t T) DOMStorageDomStorageItemUpdated() {
	e := proto.DOMStorageDomStorageItemUpdated{}
	t.Regex("", e.ProtoEvent())
}

func (t T) DOMStorageDomStorageItemsCleared() {
	e := proto.DOMStorageDomStorageItemsCleared{}
	t.Regex("", e.ProtoEvent())
}

func (t T) DatabaseDisable() {
	c := &Client{}
	err := proto.DatabaseDisable{}.Call(c)
	t.Nil(err)
}

func (t T) DatabaseEnable() {
	c := &Client{}
	err := proto.DatabaseEnable{}.Call(c)
	t.Nil(err)
}

func (t T) DatabaseExecuteSQL() {
	c := &Client{}
	_, err := proto.DatabaseExecuteSQL{}.Call(c)
	t.Nil(err)
}

func (t T) DatabaseGetDatabaseTableNames() {
	c := &Client{}
	_, err := proto.DatabaseGetDatabaseTableNames{}.Call(c)
	t.Nil(err)
}

func (t T) DatabaseAddDatabase() {
	e := proto.DatabaseAddDatabase{}
	t.Regex("", e.ProtoEvent())
}

func (t T) DeviceOrientationClearDeviceOrientationOverride() {
	c := &Client{}
	err := proto.DeviceOrientationClearDeviceOrientationOverride{}.Call(c)
	t.Nil(err)
}

func (t T) DeviceOrientationSetDeviceOrientationOverride() {
	c := &Client{}
	err := proto.DeviceOrientationSetDeviceOrientationOverride{}.Call(c)
	t.Nil(err)
}

func (t T) EmulationCanEmulate() {
	c := &Client{}
	_, err := proto.EmulationCanEmulate{}.Call(c)
	t.Nil(err)
}

func (t T) EmulationClearDeviceMetricsOverride() {
	c := &Client{}
	err := proto.EmulationClearDeviceMetricsOverride{}.Call(c)
	t.Nil(err)
}

func (t T) EmulationClearGeolocationOverride() {
	c := &Client{}
	err := proto.EmulationClearGeolocationOverride{}.Call(c)
	t.Nil(err)
}

func (t T) EmulationResetPageScaleFactor() {
	c := &Client{}
	err := proto.EmulationResetPageScaleFactor{}.Call(c)
	t.Nil(err)
}

func (t T) EmulationSetFocusEmulationEnabled() {
	c := &Client{}
	err := proto.EmulationSetFocusEmulationEnabled{}.Call(c)
	t.Nil(err)
}

func (t T) EmulationSetAutoDarkModeOverride() {
	c := &Client{}
	err := proto.EmulationSetAutoDarkModeOverride{}.Call(c)
	t.Nil(err)
}

func (t T) EmulationSetCPUThrottlingRate() {
	c := &Client{}
	err := proto.EmulationSetCPUThrottlingRate{}.Call(c)
	t.Nil(err)
}

func (t T) EmulationSetDefaultBackgroundColorOverride() {
	c := &Client{}
	err := proto.EmulationSetDefaultBackgroundColorOverride{}.Call(c)
	t.Nil(err)
}

func (t T) EmulationSetDeviceMetricsOverride() {
	c := &Client{}
	err := proto.EmulationSetDeviceMetricsOverride{}.Call(c)
	t.Nil(err)
}

func (t T) EmulationSetScrollbarsHidden() {
	c := &Client{}
	err := proto.EmulationSetScrollbarsHidden{}.Call(c)
	t.Nil(err)
}

func (t T) EmulationSetDocumentCookieDisabled() {
	c := &Client{}
	err := proto.EmulationSetDocumentCookieDisabled{}.Call(c)
	t.Nil(err)
}

func (t T) EmulationSetEmitTouchEventsForMouse() {
	c := &Client{}
	err := proto.EmulationSetEmitTouchEventsForMouse{}.Call(c)
	t.Nil(err)
}

func (t T) EmulationSetEmulatedMedia() {
	c := &Client{}
	err := proto.EmulationSetEmulatedMedia{}.Call(c)
	t.Nil(err)
}

func (t T) EmulationSetEmulatedVisionDeficiency() {
	c := &Client{}
	err := proto.EmulationSetEmulatedVisionDeficiency{}.Call(c)
	t.Nil(err)
}

func (t T) EmulationSetGeolocationOverride() {
	c := &Client{}
	err := proto.EmulationSetGeolocationOverride{}.Call(c)
	t.Nil(err)
}

func (t T) EmulationSetIdleOverride() {
	c := &Client{}
	err := proto.EmulationSetIdleOverride{}.Call(c)
	t.Nil(err)
}

func (t T) EmulationClearIdleOverride() {
	c := &Client{}
	err := proto.EmulationClearIdleOverride{}.Call(c)
	t.Nil(err)
}

func (t T) EmulationSetNavigatorOverrides() {
	c := &Client{}
	err := proto.EmulationSetNavigatorOverrides{}.Call(c)
	t.Nil(err)
}

func (t T) EmulationSetPageScaleFactor() {
	c := &Client{}
	err := proto.EmulationSetPageScaleFactor{}.Call(c)
	t.Nil(err)
}

func (t T) EmulationSetScriptExecutionDisabled() {
	c := &Client{}
	err := proto.EmulationSetScriptExecutionDisabled{}.Call(c)
	t.Nil(err)
}

func (t T) EmulationSetTouchEmulationEnabled() {
	c := &Client{}
	err := proto.EmulationSetTouchEmulationEnabled{}.Call(c)
	t.Nil(err)
}

func (t T) EmulationSetVirtualTimePolicy() {
	c := &Client{}
	_, err := proto.EmulationSetVirtualTimePolicy{}.Call(c)
	t.Nil(err)
}

func (t T) EmulationSetLocaleOverride() {
	c := &Client{}
	err := proto.EmulationSetLocaleOverride{}.Call(c)
	t.Nil(err)
}

func (t T) EmulationSetTimezoneOverride() {
	c := &Client{}
	err := proto.EmulationSetTimezoneOverride{}.Call(c)
	t.Nil(err)
}

func (t T) EmulationSetVisibleSize() {
	c := &Client{}
	err := proto.EmulationSetVisibleSize{}.Call(c)
	t.Nil(err)
}

func (t T) EmulationSetDisabledImageTypes() {
	c := &Client{}
	err := proto.EmulationSetDisabledImageTypes{}.Call(c)
	t.Nil(err)
}

func (t T) EmulationSetHardwareConcurrencyOverride() {
	c := &Client{}
	err := proto.EmulationSetHardwareConcurrencyOverride{}.Call(c)
	t.Nil(err)
}

func (t T) EmulationSetUserAgentOverride() {
	c := &Client{}
	err := proto.EmulationSetUserAgentOverride{}.Call(c)
	t.Nil(err)
}

func (t T) EmulationSetAutomationOverride() {
	c := &Client{}
	err := proto.EmulationSetAutomationOverride{}.Call(c)
	t.Nil(err)
}

func (t T) EmulationVirtualTimeBudgetExpired() {
	e := proto.EmulationVirtualTimeBudgetExpired{}
	t.Regex("", e.ProtoEvent())
}

func (t T) HeadlessExperimentalBeginFrame() {
	c := &Client{}
	_, err := proto.HeadlessExperimentalBeginFrame{}.Call(c)
	t.Nil(err)
}

func (t T) HeadlessExperimentalDisable() {
	c := &Client{}
	err := proto.HeadlessExperimentalDisable{}.Call(c)
	t.Nil(err)
}

func (t T) HeadlessExperimentalEnable() {
	c := &Client{}
	err := proto.HeadlessExperimentalEnable{}.Call(c)
	t.Nil(err)
}

func (t T) IOClose() {
	c := &Client{}
	err := proto.IOClose{}.Call(c)
	t.Nil(err)
}

func (t T) IORead() {
	c := &Client{}
	_, err := proto.IORead{}.Call(c)
	t.Nil(err)
}

func (t T) IOResolveBlob() {
	c := &Client{}
	_, err := proto.IOResolveBlob{}.Call(c)
	t.Nil(err)
}

func (t T) IndexedDBClearObjectStore() {
	c := &Client{}
	err := proto.IndexedDBClearObjectStore{}.Call(c)
	t.Nil(err)
}

func (t T) IndexedDBDeleteDatabase() {
	c := &Client{}
	err := proto.IndexedDBDeleteDatabase{}.Call(c)
	t.Nil(err)
}

func (t T) IndexedDBDeleteObjectStoreEntries() {
	c := &Client{}
	err := proto.IndexedDBDeleteObjectStoreEntries{}.Call(c)
	t.Nil(err)
}

func (t T) IndexedDBDisable() {
	c := &Client{}
	err := proto.IndexedDBDisable{}.Call(c)
	t.Nil(err)
}

func (t T) IndexedDBEnable() {
	c := &Client{}
	err := proto.IndexedDBEnable{}.Call(c)
	t.Nil(err)
}

func (t T) IndexedDBRequestData() {
	c := &Client{}
	_, err := proto.IndexedDBRequestData{}.Call(c)
	t.Nil(err)
}

func (t T) IndexedDBGetMetadata() {
	c := &Client{}
	_, err := proto.IndexedDBGetMetadata{}.Call(c)
	t.Nil(err)
}

func (t T) IndexedDBRequestDatabase() {
	c := &Client{}
	_, err := proto.IndexedDBRequestDatabase{}.Call(c)
	t.Nil(err)
}

func (t T) IndexedDBRequestDatabaseNames() {
	c := &Client{}
	_, err := proto.IndexedDBRequestDatabaseNames{}.Call(c)
	t.Nil(err)
}

func (t T) InputDispatchDragEvent() {
	c := &Client{}
	err := proto.InputDispatchDragEvent{}.Call(c)
	t.Nil(err)
}

func (t T) InputDispatchKeyEvent() {
	c := &Client{}
	err := proto.InputDispatchKeyEvent{}.Call(c)
	t.Nil(err)
}

func (t T) InputInsertText() {
	c := &Client{}
	err := proto.InputInsertText{}.Call(c)
	t.Nil(err)
}

func (t T) InputImeSetComposition() {
	c := &Client{}
	err := proto.InputImeSetComposition{}.Call(c)
	t.Nil(err)
}

func (t T) InputDispatchMouseEvent() {
	c := &Client{}
	err := proto.InputDispatchMouseEvent{}.Call(c)
	t.Nil(err)
}

func (t T) InputDispatchTouchEvent() {
	c := &Client{}
	err := proto.InputDispatchTouchEvent{}.Call(c)
	t.Nil(err)
}

func (t T) InputEmulateTouchFromMouseEvent() {
	c := &Client{}
	err := proto.InputEmulateTouchFromMouseEvent{}.Call(c)
	t.Nil(err)
}

func (t T) InputSetIgnoreInputEvents() {
	c := &Client{}
	err := proto.InputSetIgnoreInputEvents{}.Call(c)
	t.Nil(err)
}

func (t T) InputSetInterceptDrags() {
	c := &Client{}
	err := proto.InputSetInterceptDrags{}.Call(c)
	t.Nil(err)
}

func (t T) InputSynthesizePinchGesture() {
	c := &Client{}
	err := proto.InputSynthesizePinchGesture{}.Call(c)
	t.Nil(err)
}

func (t T) InputSynthesizeScrollGesture() {
	c := &Client{}
	err := proto.InputSynthesizeScrollGesture{}.Call(c)
	t.Nil(err)
}

func (t T) InputSynthesizeTapGesture() {
	c := &Client{}
	err := proto.InputSynthesizeTapGesture{}.Call(c)
	t.Nil(err)
}

func (t T) InputDragIntercepted() {
	e := proto.InputDragIntercepted{}
	t.Regex("", e.ProtoEvent())
}

func (t T) InspectorDisable() {
	c := &Client{}
	err := proto.InspectorDisable{}.Call(c)
	t.Nil(err)
}

func (t T) InspectorEnable() {
	c := &Client{}
	err := proto.InspectorEnable{}.Call(c)
	t.Nil(err)
}

func (t T) InspectorDetached() {
	e := proto.InspectorDetached{}
	t.Regex("", e.ProtoEvent())
}

func (t T) InspectorTargetCrashed() {
	e := proto.InspectorTargetCrashed{}
	t.Regex("", e.ProtoEvent())
}

func (t T) InspectorTargetReloadedAfterCrash() {
	e := proto.InspectorTargetReloadedAfterCrash{}
	t.Regex("", e.ProtoEvent())
}

func (t T) LayerTreeCompositingReasons() {
	c := &Client{}
	_, err := proto.LayerTreeCompositingReasons{}.Call(c)
	t.Nil(err)
}

func (t T) LayerTreeDisable() {
	c := &Client{}
	err := proto.LayerTreeDisable{}.Call(c)
	t.Nil(err)
}

func (t T) LayerTreeEnable() {
	c := &Client{}
	err := proto.LayerTreeEnable{}.Call(c)
	t.Nil(err)
}

func (t T) LayerTreeLoadSnapshot() {
	c := &Client{}
	_, err := proto.LayerTreeLoadSnapshot{}.Call(c)
	t.Nil(err)
}

func (t T) LayerTreeMakeSnapshot() {
	c := &Client{}
	_, err := proto.LayerTreeMakeSnapshot{}.Call(c)
	t.Nil(err)
}

func (t T) LayerTreeProfileSnapshot() {
	c := &Client{}
	_, err := proto.LayerTreeProfileSnapshot{}.Call(c)
	t.Nil(err)
}

func (t T) LayerTreeReleaseSnapshot() {
	c := &Client{}
	err := proto.LayerTreeReleaseSnapshot{}.Call(c)
	t.Nil(err)
}

func (t T) LayerTreeReplaySnapshot() {
	c := &Client{}
	_, err := proto.LayerTreeReplaySnapshot{}.Call(c)
	t.Nil(err)
}

func (t T) LayerTreeSnapshotCommandLog() {
	c := &Client{}
	_, err := proto.LayerTreeSnapshotCommandLog{}.Call(c)
	t.Nil(err)
}

func (t T) LayerTreeLayerPainted() {
	e := proto.LayerTreeLayerPainted{}
	t.Regex("", e.ProtoEvent())
}

func (t T) LayerTreeLayerTreeDidChange() {
	e := proto.LayerTreeLayerTreeDidChange{}
	t.Regex("", e.ProtoEvent())
}

func (t T) LogClear() {
	c := &Client{}
	err := proto.LogClear{}.Call(c)
	t.Nil(err)
}

func (t T) LogDisable() {
	c := &Client{}
	err := proto.LogDisable{}.Call(c)
	t.Nil(err)
}

func (t T) LogEnable() {
	c := &Client{}
	err := proto.LogEnable{}.Call(c)
	t.Nil(err)
}

func (t T) LogStartViolationsReport() {
	c := &Client{}
	err := proto.LogStartViolationsReport{}.Call(c)
	t.Nil(err)
}

func (t T) LogStopViolationsReport() {
	c := &Client{}
	err := proto.LogStopViolationsReport{}.Call(c)
	t.Nil(err)
}

func (t T) LogEntryAdded() {
	e := proto.LogEntryAdded{}
	t.Regex("", e.ProtoEvent())
}

func (t T) MemoryGetDOMCounters() {
	c := &Client{}
	_, err := proto.MemoryGetDOMCounters{}.Call(c)
	t.Nil(err)
}

func (t T) MemoryPrepareForLeakDetection() {
	c := &Client{}
	err := proto.MemoryPrepareForLeakDetection{}.Call(c)
	t.Nil(err)
}

func (t T) MemoryForciblyPurgeJavaScriptMemory() {
	c := &Client{}
	err := proto.MemoryForciblyPurgeJavaScriptMemory{}.Call(c)
	t.Nil(err)
}

func (t T) MemorySetPressureNotificationsSuppressed() {
	c := &Client{}
	err := proto.MemorySetPressureNotificationsSuppressed{}.Call(c)
	t.Nil(err)
}

func (t T) MemorySimulatePressureNotification() {
	c := &Client{}
	err := proto.MemorySimulatePressureNotification{}.Call(c)
	t.Nil(err)
}

func (t T) MemoryStartSampling() {
	c := &Client{}
	err := proto.MemoryStartSampling{}.Call(c)
	t.Nil(err)
}

func (t T) MemoryStopSampling() {
	c := &Client{}
	err := proto.MemoryStopSampling{}.Call(c)
	t.Nil(err)
}

func (t T) MemoryGetAllTimeSamplingProfile() {
	c := &Client{}
	_, err := proto.MemoryGetAllTimeSamplingProfile{}.Call(c)
	t.Nil(err)
}

func (t T) MemoryGetBrowserSamplingProfile() {
	c := &Client{}
	_, err := proto.MemoryGetBrowserSamplingProfile{}.Call(c)
	t.Nil(err)
}

func (t T) MemoryGetSamplingProfile() {
	c := &Client{}
	_, err := proto.MemoryGetSamplingProfile{}.Call(c)
	t.Nil(err)
}

func (t T) NetworkSetAcceptedEncodings() {
	c := &Client{}
	err := proto.NetworkSetAcceptedEncodings{}.Call(c)
	t.Nil(err)
}

func (t T) NetworkClearAcceptedEncodingsOverride() {
	c := &Client{}
	err := proto.NetworkClearAcceptedEncodingsOverride{}.Call(c)
	t.Nil(err)
}

func (t T) NetworkCanClearBrowserCache() {
	c := &Client{}
	_, err := proto.NetworkCanClearBrowserCache{}.Call(c)
	t.Nil(err)
}

func (t T) NetworkCanClearBrowserCookies() {
	c := &Client{}
	_, err := proto.NetworkCanClearBrowserCookies{}.Call(c)
	t.Nil(err)
}

func (t T) NetworkCanEmulateNetworkConditions() {
	c := &Client{}
	_, err := proto.NetworkCanEmulateNetworkConditions{}.Call(c)
	t.Nil(err)
}

func (t T) NetworkClearBrowserCache() {
	c := &Client{}
	err := proto.NetworkClearBrowserCache{}.Call(c)
	t.Nil(err)
}

func (t T) NetworkClearBrowserCookies() {
	c := &Client{}
	err := proto.NetworkClearBrowserCookies{}.Call(c)
	t.Nil(err)
}

func (t T) NetworkContinueInterceptedRequest() {
	c := &Client{}
	err := proto.NetworkContinueInterceptedRequest{}.Call(c)
	t.Nil(err)
}

func (t T) NetworkDeleteCookies() {
	c := &Client{}
	err := proto.NetworkDeleteCookies{}.Call(c)
	t.Nil(err)
}

func (t T) NetworkDisable() {
	c := &Client{}
	err := proto.NetworkDisable{}.Call(c)
	t.Nil(err)
}

func (t T) NetworkEmulateNetworkConditions() {
	c := &Client{}
	err := proto.NetworkEmulateNetworkConditions{}.Call(c)
	t.Nil(err)
}

func (t T) NetworkEnable() {
	c := &Client{}
	err := proto.NetworkEnable{}.Call(c)
	t.Nil(err)
}

func (t T) NetworkGetAllCookies() {
	c := &Client{}
	_, err := proto.NetworkGetAllCookies{}.Call(c)
	t.Nil(err)
}

func (t T) NetworkGetCertificate() {
	c := &Client{}
	_, err := proto.NetworkGetCertificate{}.Call(c)
	t.Nil(err)
}

func (t T) NetworkGetCookies() {
	c := &Client{}
	_, err := proto.NetworkGetCookies{}.Call(c)
	t.Nil(err)
}

func (t T) NetworkGetResponseBody() {
	c := &Client{}
	_, err := proto.NetworkGetResponseBody{}.Call(c)
	t.Nil(err)
}

func (t T) NetworkGetRequestPostData() {
	c := &Client{}
	_, err := proto.NetworkGetRequestPostData{}.Call(c)
	t.Nil(err)
}

func (t T) NetworkGetResponseBodyForInterception() {
	c := &Client{}
	_, err := proto.NetworkGetResponseBodyForInterception{}.Call(c)
	t.Nil(err)
}

func (t T) NetworkTakeResponseBodyForInterceptionAsStream() {
	c := &Client{}
	_, err := proto.NetworkTakeResponseBodyForInterceptionAsStream{}.Call(c)
	t.Nil(err)
}

func (t T) NetworkReplayXHR() {
	c := &Client{}
	err := proto.NetworkReplayXHR{}.Call(c)
	t.Nil(err)
}

func (t T) NetworkSearchInResponseBody() {
	c := &Client{}
	_, err := proto.NetworkSearchInResponseBody{}.Call(c)
	t.Nil(err)
}

func (t T) NetworkSetBlockedURLs() {
	c := &Client{}
	err := proto.NetworkSetBlockedURLs{}.Call(c)
	t.Nil(err)
}

func (t T) NetworkSetBypassServiceWorker() {
	c := &Client{}
	err := proto.NetworkSetBypassServiceWorker{}.Call(c)
	t.Nil(err)
}

func (t T) NetworkSetCacheDisabled() {
	c := &Client{}
	err := proto.NetworkSetCacheDisabled{}.Call(c)
	t.Nil(err)
}

func (t T) NetworkSetCookie() {
	c := &Client{}
	_, err := proto.NetworkSetCookie{}.Call(c)
	t.Nil(err)
}

func (t T) NetworkSetCookies() {
	c := &Client{}
	err := proto.NetworkSetCookies{}.Call(c)
	t.Nil(err)
}

func (t T) NetworkSetExtraHTTPHeaders() {
	c := &Client{}
	err := proto.NetworkSetExtraHTTPHeaders{}.Call(c)
	t.Nil(err)
}

func (t T) NetworkSetAttachDebugStack() {
	c := &Client{}
	err := proto.NetworkSetAttachDebugStack{}.Call(c)
	t.Nil(err)
}

func (t T) NetworkSetRequestInterception() {
	c := &Client{}
	err := proto.NetworkSetRequestInterception{}.Call(c)
	t.Nil(err)
}

func (t T) NetworkSetUserAgentOverride() {
	c := &Client{}
	err := proto.NetworkSetUserAgentOverride{}.Call(c)
	t.Nil(err)
}

func (t T) NetworkGetSecurityIsolationStatus() {
	c := &Client{}
	_, err := proto.NetworkGetSecurityIsolationStatus{}.Call(c)
	t.Nil(err)
}

func (t T) NetworkEnableReportingAPI() {
	c := &Client{}
	err := proto.NetworkEnableReportingAPI{}.Call(c)
	t.Nil(err)
}

func (t T) NetworkLoadNetworkResource() {
	c := &Client{}
	_, err := proto.NetworkLoadNetworkResource{}.Call(c)
	t.Nil(err)
}

func (t T) NetworkDataReceived() {
	e := proto.NetworkDataReceived{}
	t.Regex("", e.ProtoEvent())
}

func (t T) NetworkEventSourceMessageReceived() {
	e := proto.NetworkEventSourceMessageReceived{}
	t.Regex("", e.ProtoEvent())
}

func (t T) NetworkLoadingFailed() {
	e := proto.NetworkLoadingFailed{}
	t.Regex("", e.ProtoEvent())
}

func (t T) NetworkLoadingFinished() {
	e := proto.NetworkLoadingFinished{}
	t.Regex("", e.ProtoEvent())
}

func (t T) NetworkRequestIntercepted() {
	e := proto.NetworkRequestIntercepted{}
	t.Regex("", e.ProtoEvent())
}

func (t T) NetworkRequestServedFromCache() {
	e := proto.NetworkRequestServedFromCache{}
	t.Regex("", e.ProtoEvent())
}

func (t T) NetworkRequestWillBeSent() {
	e := proto.NetworkRequestWillBeSent{}
	t.Regex("", e.ProtoEvent())
}

func (t T) NetworkResourceChangedPriority() {
	e := proto.NetworkResourceChangedPriority{}
	t.Regex("", e.ProtoEvent())
}

func (t T) NetworkSignedExchangeReceived() {
	e := proto.NetworkSignedExchangeReceived{}
	t.Regex("", e.ProtoEvent())
}

func (t T) NetworkResponseReceived() {
	e := proto.NetworkResponseReceived{}
	t.Regex("", e.ProtoEvent())
}

func (t T) NetworkWebSocketClosed() {
	e := proto.NetworkWebSocketClosed{}
	t.Regex("", e.ProtoEvent())
}

func (t T) NetworkWebSocketCreated() {
	e := proto.NetworkWebSocketCreated{}
	t.Regex("", e.ProtoEvent())
}

func (t T) NetworkWebSocketFrameError() {
	e := proto.NetworkWebSocketFrameError{}
	t.Regex("", e.ProtoEvent())
}

func (t T) NetworkWebSocketFrameReceived() {
	e := proto.NetworkWebSocketFrameReceived{}
	t.Regex("", e.ProtoEvent())
}

func (t T) NetworkWebSocketFrameSent() {
	e := proto.NetworkWebSocketFrameSent{}
	t.Regex("", e.ProtoEvent())
}

func (t T) NetworkWebSocketHandshakeResponseReceived() {
	e := proto.NetworkWebSocketHandshakeResponseReceived{}
	t.Regex("", e.ProtoEvent())
}

func (t T) NetworkWebSocketWillSendHandshakeRequest() {
	e := proto.NetworkWebSocketWillSendHandshakeRequest{}
	t.Regex("", e.ProtoEvent())
}

func (t T) NetworkWebTransportCreated() {
	e := proto.NetworkWebTransportCreated{}
	t.Regex("", e.ProtoEvent())
}

func (t T) NetworkWebTransportConnectionEstablished() {
	e := proto.NetworkWebTransportConnectionEstablished{}
	t.Regex("", e.ProtoEvent())
}

func (t T) NetworkWebTransportClosed() {
	e := proto.NetworkWebTransportClosed{}
	t.Regex("", e.ProtoEvent())
}

func (t T) NetworkRequestWillBeSentExtraInfo() {
	e := proto.NetworkRequestWillBeSentExtraInfo{}
	t.Regex("", e.ProtoEvent())
}

func (t T) NetworkResponseReceivedExtraInfo() {
	e := proto.NetworkResponseReceivedExtraInfo{}
	t.Regex("", e.ProtoEvent())
}

func (t T) NetworkTrustTokenOperationDone() {
	e := proto.NetworkTrustTokenOperationDone{}
	t.Regex("", e.ProtoEvent())
}

func (t T) NetworkSubresourceWebBundleMetadataReceived() {
	e := proto.NetworkSubresourceWebBundleMetadataReceived{}
	t.Regex("", e.ProtoEvent())
}

func (t T) NetworkSubresourceWebBundleMetadataError() {
	e := proto.NetworkSubresourceWebBundleMetadataError{}
	t.Regex("", e.ProtoEvent())
}

func (t T) NetworkSubresourceWebBundleInnerResponseParsed() {
	e := proto.NetworkSubresourceWebBundleInnerResponseParsed{}
	t.Regex("", e.ProtoEvent())
}

func (t T) NetworkSubresourceWebBundleInnerResponseError() {
	e := proto.NetworkSubresourceWebBundleInnerResponseError{}
	t.Regex("", e.ProtoEvent())
}

func (t T) NetworkReportingAPIReportAdded() {
	e := proto.NetworkReportingAPIReportAdded{}
	t.Regex("", e.ProtoEvent())
}

func (t T) NetworkReportingAPIReportUpdated() {
	e := proto.NetworkReportingAPIReportUpdated{}
	t.Regex("", e.ProtoEvent())
}

func (t T) NetworkReportingAPIEndpointsChangedForOrigin() {
	e := proto.NetworkReportingAPIEndpointsChangedForOrigin{}
	t.Regex("", e.ProtoEvent())
}

func (t T) OverlayDisable() {
	c := &Client{}
	err := proto.OverlayDisable{}.Call(c)
	t.Nil(err)
}

func (t T) OverlayEnable() {
	c := &Client{}
	err := proto.OverlayEnable{}.Call(c)
	t.Nil(err)
}

func (t T) OverlayGetHighlightObjectForTest() {
	c := &Client{}
	_, err := proto.OverlayGetHighlightObjectForTest{}.Call(c)
	t.Nil(err)
}

func (t T) OverlayGetGridHighlightObjectsForTest() {
	c := &Client{}
	_, err := proto.OverlayGetGridHighlightObjectsForTest{}.Call(c)
	t.Nil(err)
}

func (t T) OverlayGetSourceOrderHighlightObjectForTest() {
	c := &Client{}
	_, err := proto.OverlayGetSourceOrderHighlightObjectForTest{}.Call(c)
	t.Nil(err)
}

func (t T) OverlayHideHighlight() {
	c := &Client{}
	err := proto.OverlayHideHighlight{}.Call(c)
	t.Nil(err)
}

func (t T) OverlayHighlightFrame() {
	c := &Client{}
	err := proto.OverlayHighlightFrame{}.Call(c)
	t.Nil(err)
}

func (t T) OverlayHighlightNode() {
	c := &Client{}
	err := proto.OverlayHighlightNode{}.Call(c)
	t.Nil(err)
}

func (t T) OverlayHighlightQuad() {
	c := &Client{}
	err := proto.OverlayHighlightQuad{}.Call(c)
	t.Nil(err)
}

func (t T) OverlayHighlightRect() {
	c := &Client{}
	err := proto.OverlayHighlightRect{}.Call(c)
	t.Nil(err)
}

func (t T) OverlayHighlightSourceOrder() {
	c := &Client{}
	err := proto.OverlayHighlightSourceOrder{}.Call(c)
	t.Nil(err)
}

func (t T) OverlaySetInspectMode() {
	c := &Client{}
	err := proto.OverlaySetInspectMode{}.Call(c)
	t.Nil(err)
}

func (t T) OverlaySetShowAdHighlights() {
	c := &Client{}
	err := proto.OverlaySetShowAdHighlights{}.Call(c)
	t.Nil(err)
}

func (t T) OverlaySetPausedInDebuggerMessage() {
	c := &Client{}
	err := proto.OverlaySetPausedInDebuggerMessage{}.Call(c)
	t.Nil(err)
}

func (t T) OverlaySetShowDebugBorders() {
	c := &Client{}
	err := proto.OverlaySetShowDebugBorders{}.Call(c)
	t.Nil(err)
}

func (t T) OverlaySetShowFPSCounter() {
	c := &Client{}
	err := proto.OverlaySetShowFPSCounter{}.Call(c)
	t.Nil(err)
}

func (t T) OverlaySetShowGridOverlays() {
	c := &Client{}
	err := proto.OverlaySetShowGridOverlays{}.Call(c)
	t.Nil(err)
}

func (t T) OverlaySetShowFlexOverlays() {
	c := &Client{}
	err := proto.OverlaySetShowFlexOverlays{}.Call(c)
	t.Nil(err)
}

func (t T) OverlaySetShowScrollSnapOverlays() {
	c := &Client{}
	err := proto.OverlaySetShowScrollSnapOverlays{}.Call(c)
	t.Nil(err)
}

func (t T) OverlaySetShowContainerQueryOverlays() {
	c := &Client{}
	err := proto.OverlaySetShowContainerQueryOverlays{}.Call(c)
	t.Nil(err)
}

func (t T) OverlaySetShowPaintRects() {
	c := &Client{}
	err := proto.OverlaySetShowPaintRects{}.Call(c)
	t.Nil(err)
}

func (t T) OverlaySetShowLayoutShiftRegions() {
	c := &Client{}
	err := proto.OverlaySetShowLayoutShiftRegions{}.Call(c)
	t.Nil(err)
}

func (t T) OverlaySetShowScrollBottleneckRects() {
	c := &Client{}
	err := proto.OverlaySetShowScrollBottleneckRects{}.Call(c)
	t.Nil(err)
}

func (t T) OverlaySetShowHitTestBorders() {
	c := &Client{}
	err := proto.OverlaySetShowHitTestBorders{}.Call(c)
	t.Nil(err)
}

func (t T) OverlaySetShowWebVitals() {
	c := &Client{}
	err := proto.OverlaySetShowWebVitals{}.Call(c)
	t.Nil(err)
}

func (t T) OverlaySetShowViewportSizeOnResize() {
	c := &Client{}
	err := proto.OverlaySetShowViewportSizeOnResize{}.Call(c)
	t.Nil(err)
}

func (t T) OverlaySetShowHinge() {
	c := &Client{}
	err := proto.OverlaySetShowHinge{}.Call(c)
	t.Nil(err)
}

func (t T) OverlaySetShowIsolatedElements() {
	c := &Client{}
	err := proto.OverlaySetShowIsolatedElements{}.Call(c)
	t.Nil(err)
}

func (t T) OverlayInspectNodeRequested() {
	e := proto.OverlayInspectNodeRequested{}
	t.Regex("", e.ProtoEvent())
}

func (t T) OverlayNodeHighlightRequested() {
	e := proto.OverlayNodeHighlightRequested{}
	t.Regex("", e.ProtoEvent())
}

func (t T) OverlayScreenshotRequested() {
	e := proto.OverlayScreenshotRequested{}
	t.Regex("", e.ProtoEvent())
}

func (t T) OverlayInspectModeCanceled() {
	e := proto.OverlayInspectModeCanceled{}
	t.Regex("", e.ProtoEvent())
}

func (t T) PageAddScriptToEvaluateOnLoad() {
	c := &Client{}
	_, err := proto.PageAddScriptToEvaluateOnLoad{}.Call(c)
	t.Nil(err)
}

func (t T) PageAddScriptToEvaluateOnNewDocument() {
	c := &Client{}
	_, err := proto.PageAddScriptToEvaluateOnNewDocument{}.Call(c)
	t.Nil(err)
}

func (t T) PageBringToFront() {
	c := &Client{}
	err := proto.PageBringToFront{}.Call(c)
	t.Nil(err)
}

func (t T) PageCaptureScreenshot() {
	c := &Client{}
	_, err := proto.PageCaptureScreenshot{}.Call(c)
	t.Nil(err)
}

func (t T) PageCaptureSnapshot() {
	c := &Client{}
	_, err := proto.PageCaptureSnapshot{}.Call(c)
	t.Nil(err)
}

func (t T) PageClearDeviceMetricsOverride() {
	c := &Client{}
	err := proto.PageClearDeviceMetricsOverride{}.Call(c)
	t.Nil(err)
}

func (t T) PageClearDeviceOrientationOverride() {
	c := &Client{}
	err := proto.PageClearDeviceOrientationOverride{}.Call(c)
	t.Nil(err)
}

func (t T) PageClearGeolocationOverride() {
	c := &Client{}
	err := proto.PageClearGeolocationOverride{}.Call(c)
	t.Nil(err)
}

func (t T) PageCreateIsolatedWorld() {
	c := &Client{}
	_, err := proto.PageCreateIsolatedWorld{}.Call(c)
	t.Nil(err)
}

func (t T) PageDeleteCookie() {
	c := &Client{}
	err := proto.PageDeleteCookie{}.Call(c)
	t.Nil(err)
}

func (t T) PageDisable() {
	c := &Client{}
	err := proto.PageDisable{}.Call(c)
	t.Nil(err)
}

func (t T) PageEnable() {
	c := &Client{}
	err := proto.PageEnable{}.Call(c)
	t.Nil(err)
}

func (t T) PageGetAppManifest() {
	c := &Client{}
	_, err := proto.PageGetAppManifest{}.Call(c)
	t.Nil(err)
}

func (t T) PageGetInstallabilityErrors() {
	c := &Client{}
	_, err := proto.PageGetInstallabilityErrors{}.Call(c)
	t.Nil(err)
}

func (t T) PageGetManifestIcons() {
	c := &Client{}
	_, err := proto.PageGetManifestIcons{}.Call(c)
	t.Nil(err)
}

func (t T) PageGetAppID() {
	c := &Client{}
	_, err := proto.PageGetAppID{}.Call(c)
	t.Nil(err)
}

func (t T) PageGetAdScriptID() {
	c := &Client{}
	_, err := proto.PageGetAdScriptID{}.Call(c)
	t.Nil(err)
}

func (t T) PageGetCookies() {
	c := &Client{}
	_, err := proto.PageGetCookies{}.Call(c)
	t.Nil(err)
}

func (t T) PageGetFrameTree() {
	c := &Client{}
	_, err := proto.PageGetFrameTree{}.Call(c)
	t.Nil(err)
}

func (t T) PageGetLayoutMetrics() {
	c := &Client{}
	_, err := proto.PageGetLayoutMetrics{}.Call(c)
	t.Nil(err)
}

func (t T) PageGetNavigationHistory() {
	c := &Client{}
	_, err := proto.PageGetNavigationHistory{}.Call(c)
	t.Nil(err)
}

func (t T) PageResetNavigationHistory() {
	c := &Client{}
	err := proto.PageResetNavigationHistory{}.Call(c)
	t.Nil(err)
}

func (t T) PageGetResourceContent() {
	c := &Client{}
	_, err := proto.PageGetResourceContent{}.Call(c)
	t.Nil(err)
}

func (t T) PageGetResourceTree() {
	c := &Client{}
	_, err := proto.PageGetResourceTree{}.Call(c)
	t.Nil(err)
}

func (t T) PageHandleJavaScriptDialog() {
	c := &Client{}
	err := proto.PageHandleJavaScriptDialog{}.Call(c)
	t.Nil(err)
}

func (t T) PageNavigate() {
	c := &Client{}
	_, err := proto.PageNavigate{}.Call(c)
	t.Nil(err)
}

func (t T) PageNavigateToHistoryEntry() {
	c := &Client{}
	err := proto.PageNavigateToHistoryEntry{}.Call(c)
	t.Nil(err)
}

func (t T) PagePrintToPDF() {
	c := &Client{}
	_, err := proto.PagePrintToPDF{}.Call(c)
	t.Nil(err)
}

func (t T) PageReload() {
	c := &Client{}
	err := proto.PageReload{}.Call(c)
	t.Nil(err)
}

func (t T) PageRemoveScriptToEvaluateOnLoad() {
	c := &Client{}
	err := proto.PageRemoveScriptToEvaluateOnLoad{}.Call(c)
	t.Nil(err)
}

func (t T) PageRemoveScriptToEvaluateOnNewDocument() {
	c := &Client{}
	err := proto.PageRemoveScriptToEvaluateOnNewDocument{}.Call(c)
	t.Nil(err)
}

func (t T) PageScreencastFrameAck() {
	c := &Client{}
	err := proto.PageScreencastFrameAck{}.Call(c)
	t.Nil(err)
}

func (t T) PageSearchInResource() {
	c := &Client{}
	_, err := proto.PageSearchInResource{}.Call(c)
	t.Nil(err)
}

func (t T) PageSetAdBlockingEnabled() {
	c := &Client{}
	err := proto.PageSetAdBlockingEnabled{}.Call(c)
	t.Nil(err)
}

func (t T) PageSetBypassCSP() {
	c := &Client{}
	err := proto.PageSetBypassCSP{}.Call(c)
	t.Nil(err)
}

func (t T) PageGetPermissionsPolicyState() {
	c := &Client{}
	_, err := proto.PageGetPermissionsPolicyState{}.Call(c)
	t.Nil(err)
}

func (t T) PageGetOriginTrials() {
	c := &Client{}
	_, err := proto.PageGetOriginTrials{}.Call(c)
	t.Nil(err)
}

func (t T) PageSetDeviceMetricsOverride() {
	c := &Client{}
	err := proto.PageSetDeviceMetricsOverride{}.Call(c)
	t.Nil(err)
}

func (t T) PageSetDeviceOrientationOverride() {
	c := &Client{}
	err := proto.PageSetDeviceOrientationOverride{}.Call(c)
	t.Nil(err)
}

func (t T) PageSetFontFamilies() {
	c := &Client{}
	err := proto.PageSetFontFamilies{}.Call(c)
	t.Nil(err)
}

func (t T) PageSetFontSizes() {
	c := &Client{}
	err := proto.PageSetFontSizes{}.Call(c)
	t.Nil(err)
}

func (t T) PageSetDocumentContent() {
	c := &Client{}
	err := proto.PageSetDocumentContent{}.Call(c)
	t.Nil(err)
}

func (t T) PageSetDownloadBehavior() {
	c := &Client{}
	err := proto.PageSetDownloadBehavior{}.Call(c)
	t.Nil(err)
}

func (t T) PageSetGeolocationOverride() {
	c := &Client{}
	err := proto.PageSetGeolocationOverride{}.Call(c)
	t.Nil(err)
}

func (t T) PageSetLifecycleEventsEnabled() {
	c := &Client{}
	err := proto.PageSetLifecycleEventsEnabled{}.Call(c)
	t.Nil(err)
}

func (t T) PageSetTouchEmulationEnabled() {
	c := &Client{}
	err := proto.PageSetTouchEmulationEnabled{}.Call(c)
	t.Nil(err)
}

func (t T) PageStartScreencast() {
	c := &Client{}
	err := proto.PageStartScreencast{}.Call(c)
	t.Nil(err)
}

func (t T) PageStopLoading() {
	c := &Client{}
	err := proto.PageStopLoading{}.Call(c)
	t.Nil(err)
}

func (t T) PageCrash() {
	c := &Client{}
	err := proto.PageCrash{}.Call(c)
	t.Nil(err)
}

func (t T) PageClose() {
	c := &Client{}
	err := proto.PageClose{}.Call(c)
	t.Nil(err)
}

func (t T) PageSetWebLifecycleState() {
	c := &Client{}
	err := proto.PageSetWebLifecycleState{}.Call(c)
	t.Nil(err)
}

func (t T) PageStopScreencast() {
	c := &Client{}
	err := proto.PageStopScreencast{}.Call(c)
	t.Nil(err)
}

func (t T) PageProduceCompilationCache() {
	c := &Client{}
	err := proto.PageProduceCompilationCache{}.Call(c)
	t.Nil(err)
}

func (t T) PageAddCompilationCache() {
	c := &Client{}
	err := proto.PageAddCompilationCache{}.Call(c)
	t.Nil(err)
}

func (t T) PageClearCompilationCache() {
	c := &Client{}
	err := proto.PageClearCompilationCache{}.Call(c)
	t.Nil(err)
}

func (t T) PageSetSPCTransactionMode() {
	c := &Client{}
	err := proto.PageSetSPCTransactionMode{}.Call(c)
	t.Nil(err)
}

func (t T) PageSetRPHRegistrationMode() {
	c := &Client{}
	err := proto.PageSetRPHRegistrationMode{}.Call(c)
	t.Nil(err)
}

func (t T) PageGenerateTestReport() {
	c := &Client{}
	err := proto.PageGenerateTestReport{}.Call(c)
	t.Nil(err)
}

func (t T) PageWaitForDebugger() {
	c := &Client{}
	err := proto.PageWaitForDebugger{}.Call(c)
	t.Nil(err)
}

func (t T) PageSetInterceptFileChooserDialog() {
	c := &Client{}
	err := proto.PageSetInterceptFileChooserDialog{}.Call(c)
	t.Nil(err)
}

func (t T) PageDomContentEventFired() {
	e := proto.PageDomContentEventFired{}
	t.Regex("", e.ProtoEvent())
}

func (t T) PageFileChooserOpened() {
	e := proto.PageFileChooserOpened{}
	t.Regex("", e.ProtoEvent())
}

func (t T) PageFrameAttached() {
	e := proto.PageFrameAttached{}
	t.Regex("", e.ProtoEvent())
}

func (t T) PageFrameClearedScheduledNavigation() {
	e := proto.PageFrameClearedScheduledNavigation{}
	t.Regex("", e.ProtoEvent())
}

func (t T) PageFrameDetached() {
	e := proto.PageFrameDetached{}
	t.Regex("", e.ProtoEvent())
}

func (t T) PageFrameNavigated() {
	e := proto.PageFrameNavigated{}
	t.Regex("", e.ProtoEvent())
}

func (t T) PageDocumentOpened() {
	e := proto.PageDocumentOpened{}
	t.Regex("", e.ProtoEvent())
}

func (t T) PageFrameResized() {
	e := proto.PageFrameResized{}
	t.Regex("", e.ProtoEvent())
}

func (t T) PageFrameRequestedNavigation() {
	e := proto.PageFrameRequestedNavigation{}
	t.Regex("", e.ProtoEvent())
}

func (t T) PageFrameScheduledNavigation() {
	e := proto.PageFrameScheduledNavigation{}
	t.Regex("", e.ProtoEvent())
}

func (t T) PageFrameStartedLoading() {
	e := proto.PageFrameStartedLoading{}
	t.Regex("", e.ProtoEvent())
}

func (t T) PageFrameStoppedLoading() {
	e := proto.PageFrameStoppedLoading{}
	t.Regex("", e.ProtoEvent())
}

func (t T) PageDownloadWillBegin() {
	e := proto.PageDownloadWillBegin{}
	t.Regex("", e.ProtoEvent())
}

func (t T) PageDownloadProgress() {
	e := proto.PageDownloadProgress{}
	t.Regex("", e.ProtoEvent())
}

func (t T) PageInterstitialHidden() {
	e := proto.PageInterstitialHidden{}
	t.Regex("", e.ProtoEvent())
}

func (t T) PageInterstitialShown() {
	e := proto.PageInterstitialShown{}
	t.Regex("", e.ProtoEvent())
}

func (t T) PageJavascriptDialogClosed() {
	e := proto.PageJavascriptDialogClosed{}
	t.Regex("", e.ProtoEvent())
}

func (t T) PageJavascriptDialogOpening() {
	e := proto.PageJavascriptDialogOpening{}
	t.Regex("", e.ProtoEvent())
}

func (t T) PageLifecycleEvent() {
	e := proto.PageLifecycleEvent{}
	t.Regex("", e.ProtoEvent())
}

func (t T) PageBackForwardCacheNotUsed() {
	e := proto.PageBackForwardCacheNotUsed{}
	t.Regex("", e.ProtoEvent())
}

func (t T) PageLoadEventFired() {
	e := proto.PageLoadEventFired{}
	t.Regex("", e.ProtoEvent())
}

func (t T) PageNavigatedWithinDocument() {
	e := proto.PageNavigatedWithinDocument{}
	t.Regex("", e.ProtoEvent())
}

func (t T) PageScreencastFrame() {
	e := proto.PageScreencastFrame{}
	t.Regex("", e.ProtoEvent())
}

func (t T) PageScreencastVisibilityChanged() {
	e := proto.PageScreencastVisibilityChanged{}
	t.Regex("", e.ProtoEvent())
}

func (t T) PageWindowOpen() {
	e := proto.PageWindowOpen{}
	t.Regex("", e.ProtoEvent())
}

func (t T) PageCompilationCacheProduced() {
	e := proto.PageCompilationCacheProduced{}
	t.Regex("", e.ProtoEvent())
}

func (t T) PerformanceDisable() {
	c := &Client{}
	err := proto.PerformanceDisable{}.Call(c)
	t.Nil(err)
}

func (t T) PerformanceEnable() {
	c := &Client{}
	err := proto.PerformanceEnable{}.Call(c)
	t.Nil(err)
}

func (t T) PerformanceSetTimeDomain() {
	c := &Client{}
	err := proto.PerformanceSetTimeDomain{}.Call(c)
	t.Nil(err)
}

func (t T) PerformanceGetMetrics() {
	c := &Client{}
	_, err := proto.PerformanceGetMetrics{}.Call(c)
	t.Nil(err)
}

func (t T) PerformanceMetrics() {
	e := proto.PerformanceMetrics{}
	t.Regex("", e.ProtoEvent())
}

func (t T) PerformanceTimelineEnable() {
	c := &Client{}
	err := proto.PerformanceTimelineEnable{}.Call(c)
	t.Nil(err)
}

func (t T) PerformanceTimelineTimelineEventAdded() {
	e := proto.PerformanceTimelineTimelineEventAdded{}
	t.Regex("", e.ProtoEvent())
}

func (t T) SecurityDisable() {
	c := &Client{}
	err := proto.SecurityDisable{}.Call(c)
	t.Nil(err)
}

func (t T) SecurityEnable() {
	c := &Client{}
	err := proto.SecurityEnable{}.Call(c)
	t.Nil(err)
}

func (t T) SecuritySetIgnoreCertificateErrors() {
	c := &Client{}
	err := proto.SecuritySetIgnoreCertificateErrors{}.Call(c)
	t.Nil(err)
}

func (t T) SecurityHandleCertificateError() {
	c := &Client{}
	err := proto.SecurityHandleCertificateError{}.Call(c)
	t.Nil(err)
}

func (t T) SecuritySetOverrideCertificateErrors() {
	c := &Client{}
	err := proto.SecuritySetOverrideCertificateErrors{}.Call(c)
	t.Nil(err)
}

func (t T) SecurityCertificateError() {
	e := proto.SecurityCertificateError{}
	t.Regex("", e.ProtoEvent())
}

func (t T) SecurityVisibleSecurityStateChanged() {
	e := proto.SecurityVisibleSecurityStateChanged{}
	t.Regex("", e.ProtoEvent())
}

func (t T) SecuritySecurityStateChanged() {
	e := proto.SecuritySecurityStateChanged{}
	t.Regex("", e.ProtoEvent())
}

func (t T) ServiceWorkerDeliverPushMessage() {
	c := &Client{}
	err := proto.ServiceWorkerDeliverPushMessage{}.Call(c)
	t.Nil(err)
}

func (t T) ServiceWorkerDisable() {
	c := &Client{}
	err := proto.ServiceWorkerDisable{}.Call(c)
	t.Nil(err)
}

func (t T) ServiceWorkerDispatchSyncEvent() {
	c := &Client{}
	err := proto.ServiceWorkerDispatchSyncEvent{}.Call(c)
	t.Nil(err)
}

func (t T) ServiceWorkerDispatchPeriodicSyncEvent() {
	c := &Client{}
	err := proto.ServiceWorkerDispatchPeriodicSyncEvent{}.Call(c)
	t.Nil(err)
}

func (t T) ServiceWorkerEnable() {
	c := &Client{}
	err := proto.ServiceWorkerEnable{}.Call(c)
	t.Nil(err)
}

func (t T) ServiceWorkerInspectWorker() {
	c := &Client{}
	err := proto.ServiceWorkerInspectWorker{}.Call(c)
	t.Nil(err)
}

func (t T) ServiceWorkerSetForceUpdateOnPageLoad() {
	c := &Client{}
	err := proto.ServiceWorkerSetForceUpdateOnPageLoad{}.Call(c)
	t.Nil(err)
}

func (t T) ServiceWorkerSkipWaiting() {
	c := &Client{}
	err := proto.ServiceWorkerSkipWaiting{}.Call(c)
	t.Nil(err)
}

func (t T) ServiceWorkerStartWorker() {
	c := &Client{}
	err := proto.ServiceWorkerStartWorker{}.Call(c)
	t.Nil(err)
}

func (t T) ServiceWorkerStopAllWorkers() {
	c := &Client{}
	err := proto.ServiceWorkerStopAllWorkers{}.Call(c)
	t.Nil(err)
}

func (t T) ServiceWorkerStopWorker() {
	c := &Client{}
	err := proto.ServiceWorkerStopWorker{}.Call(c)
	t.Nil(err)
}

func (t T) ServiceWorkerUnregister() {
	c := &Client{}
	err := proto.ServiceWorkerUnregister{}.Call(c)
	t.Nil(err)
}

func (t T) ServiceWorkerUpdateRegistration() {
	c := &Client{}
	err := proto.ServiceWorkerUpdateRegistration{}.Call(c)
	t.Nil(err)
}

func (t T) ServiceWorkerWorkerErrorReported() {
	e := proto.ServiceWorkerWorkerErrorReported{}
	t.Regex("", e.ProtoEvent())
}

func (t T) ServiceWorkerWorkerRegistrationUpdated() {
	e := proto.ServiceWorkerWorkerRegistrationUpdated{}
	t.Regex("", e.ProtoEvent())
}

func (t T) ServiceWorkerWorkerVersionUpdated() {
	e := proto.ServiceWorkerWorkerVersionUpdated{}
	t.Regex("", e.ProtoEvent())
}

func (t T) StorageGetStorageKeyForFrame() {
	c := &Client{}
	_, err := proto.StorageGetStorageKeyForFrame{}.Call(c)
	t.Nil(err)
}

func (t T) StorageClearDataForOrigin() {
	c := &Client{}
	err := proto.StorageClearDataForOrigin{}.Call(c)
	t.Nil(err)
}

func (t T) StorageClearDataForStorageKey() {
	c := &Client{}
	err := proto.StorageClearDataForStorageKey{}.Call(c)
	t.Nil(err)
}

func (t T) StorageGetCookies() {
	c := &Client{}
	_, err := proto.StorageGetCookies{}.Call(c)
	t.Nil(err)
}

func (t T) StorageSetCookies() {
	c := &Client{}
	err := proto.StorageSetCookies{}.Call(c)
	t.Nil(err)
}

func (t T) StorageClearCookies() {
	c := &Client{}
	err := proto.StorageClearCookies{}.Call(c)
	t.Nil(err)
}

func (t T) StorageGetUsageAndQuota() {
	c := &Client{}
	_, err := proto.StorageGetUsageAndQuota{}.Call(c)
	t.Nil(err)
}

func (t T) StorageOverrideQuotaForOrigin() {
	c := &Client{}
	err := proto.StorageOverrideQuotaForOrigin{}.Call(c)
	t.Nil(err)
}

func (t T) StorageTrackCacheStorageForOrigin() {
	c := &Client{}
	err := proto.StorageTrackCacheStorageForOrigin{}.Call(c)
	t.Nil(err)
}

func (t T) StorageTrackCacheStorageForStorageKey() {
	c := &Client{}
	err := proto.StorageTrackCacheStorageForStorageKey{}.Call(c)
	t.Nil(err)
}

func (t T) StorageTrackIndexedDBForOrigin() {
	c := &Client{}
	err := proto.StorageTrackIndexedDBForOrigin{}.Call(c)
	t.Nil(err)
}

func (t T) StorageTrackIndexedDBForStorageKey() {
	c := &Client{}
	err := proto.StorageTrackIndexedDBForStorageKey{}.Call(c)
	t.Nil(err)
}

func (t T) StorageUntrackCacheStorageForOrigin() {
	c := &Client{}
	err := proto.StorageUntrackCacheStorageForOrigin{}.Call(c)
	t.Nil(err)
}

func (t T) StorageUntrackCacheStorageForStorageKey() {
	c := &Client{}
	err := proto.StorageUntrackCacheStorageForStorageKey{}.Call(c)
	t.Nil(err)
}

func (t T) StorageUntrackIndexedDBForOrigin() {
	c := &Client{}
	err := proto.StorageUntrackIndexedDBForOrigin{}.Call(c)
	t.Nil(err)
}

func (t T) StorageUntrackIndexedDBForStorageKey() {
	c := &Client{}
	err := proto.StorageUntrackIndexedDBForStorageKey{}.Call(c)
	t.Nil(err)
}

func (t T) StorageGetTrustTokens() {
	c := &Client{}
	_, err := proto.StorageGetTrustTokens{}.Call(c)
	t.Nil(err)
}

func (t T) StorageClearTrustTokens() {
	c := &Client{}
	_, err := proto.StorageClearTrustTokens{}.Call(c)
	t.Nil(err)
}

func (t T) StorageGetInterestGroupDetails() {
	c := &Client{}
	_, err := proto.StorageGetInterestGroupDetails{}.Call(c)
	t.Nil(err)
}

func (t T) StorageSetInterestGroupTracking() {
	c := &Client{}
	err := proto.StorageSetInterestGroupTracking{}.Call(c)
	t.Nil(err)
}

func (t T) StorageGetSharedStorageMetadata() {
	c := &Client{}
	_, err := proto.StorageGetSharedStorageMetadata{}.Call(c)
	t.Nil(err)
}

func (t T) StorageGetSharedStorageEntries() {
	c := &Client{}
	_, err := proto.StorageGetSharedStorageEntries{}.Call(c)
	t.Nil(err)
}

func (t T) StorageSetSharedStorageEntry() {
	c := &Client{}
	err := proto.StorageSetSharedStorageEntry{}.Call(c)
	t.Nil(err)
}

func (t T) StorageDeleteSharedStorageEntry() {
	c := &Client{}
	err := proto.StorageDeleteSharedStorageEntry{}.Call(c)
	t.Nil(err)
}

func (t T) StorageClearSharedStorageEntries() {
	c := &Client{}
	err := proto.StorageClearSharedStorageEntries{}.Call(c)
	t.Nil(err)
}

func (t T) StorageResetSharedStorageBudget() {
	c := &Client{}
	err := proto.StorageResetSharedStorageBudget{}.Call(c)
	t.Nil(err)
}

func (t T) StorageSetSharedStorageTracking() {
	c := &Client{}
	err := proto.StorageSetSharedStorageTracking{}.Call(c)
	t.Nil(err)
}

func (t T) StorageSetStorageBucketTracking() {
	c := &Client{}
	err := proto.StorageSetStorageBucketTracking{}.Call(c)
	t.Nil(err)
}

func (t T) StorageDeleteStorageBucket() {
	c := &Client{}
	err := proto.StorageDeleteStorageBucket{}.Call(c)
	t.Nil(err)
}

func (t T) StorageCacheStorageContentUpdated() {
	e := proto.StorageCacheStorageContentUpdated{}
	t.Regex("", e.ProtoEvent())
}

func (t T) StorageCacheStorageListUpdated() {
	e := proto.StorageCacheStorageListUpdated{}
	t.Regex("", e.ProtoEvent())
}

func (t T) StorageIndexedDBContentUpdated() {
	e := proto.StorageIndexedDBContentUpdated{}
	t.Regex("", e.ProtoEvent())
}

func (t T) StorageIndexedDBListUpdated() {
	e := proto.StorageIndexedDBListUpdated{}
	t.Regex("", e.ProtoEvent())
}

func (t T) StorageInterestGroupAccessed() {
	e := proto.StorageInterestGroupAccessed{}
	t.Regex("", e.ProtoEvent())
}

func (t T) StorageSharedStorageAccessed() {
	e := proto.StorageSharedStorageAccessed{}
	t.Regex("", e.ProtoEvent())
}

func (t T) StorageStorageBucketCreatedOrUpdated() {
	e := proto.StorageStorageBucketCreatedOrUpdated{}
	t.Regex("", e.ProtoEvent())
}

func (t T) StorageStorageBucketDeleted() {
	e := proto.StorageStorageBucketDeleted{}
	t.Regex("", e.ProtoEvent())
}

func (t T) SystemInfoGetInfo() {
	c := &Client{}
	_, err := proto.SystemInfoGetInfo{}.Call(c)
	t.Nil(err)
}

func (t T) SystemInfoGetFeatureState() {
	c := &Client{}
	_, err := proto.SystemInfoGetFeatureState{}.Call(c)
	t.Nil(err)
}

func (t T) SystemInfoGetProcessInfo() {
	c := &Client{}
	_, err := proto.SystemInfoGetProcessInfo{}.Call(c)
	t.Nil(err)
}

func (t T) TargetActivateTarget() {
	c := &Client{}
	err := proto.TargetActivateTarget{}.Call(c)
	t.Nil(err)
}

func (t T) TargetAttachToTarget() {
	c := &Client{}
	_, err := proto.TargetAttachToTarget{}.Call(c)
	t.Nil(err)
}

func (t T) TargetAttachToBrowserTarget() {
	c := &Client{}
	_, err := proto.TargetAttachToBrowserTarget{}.Call(c)
	t.Nil(err)
}

func (t T) TargetCloseTarget() {
	c := &Client{}
	_, err := proto.TargetCloseTarget{}.Call(c)
	t.Nil(err)
}

func (t T) TargetExposeDevToolsProtocol() {
	c := &Client{}
	err := proto.TargetExposeDevToolsProtocol{}.Call(c)
	t.Nil(err)
}

func (t T) TargetCreateBrowserContext() {
	c := &Client{}
	_, err := proto.TargetCreateBrowserContext{}.Call(c)
	t.Nil(err)
}

func (t T) TargetGetBrowserContexts() {
	c := &Client{}
	_, err := proto.TargetGetBrowserContexts{}.Call(c)
	t.Nil(err)
}

func (t T) TargetCreateTarget() {
	c := &Client{}
	_, err := proto.TargetCreateTarget{}.Call(c)
	t.Nil(err)
}

func (t T) TargetDetachFromTarget() {
	c := &Client{}
	err := proto.TargetDetachFromTarget{}.Call(c)
	t.Nil(err)
}

func (t T) TargetDisposeBrowserContext() {
	c := &Client{}
	err := proto.TargetDisposeBrowserContext{}.Call(c)
	t.Nil(err)
}

func (t T) TargetGetTargetInfo() {
	c := &Client{}
	_, err := proto.TargetGetTargetInfo{}.Call(c)
	t.Nil(err)
}

func (t T) TargetGetTargets() {
	c := &Client{}
	_, err := proto.TargetGetTargets{}.Call(c)
	t.Nil(err)
}

func (t T) TargetSendMessageToTarget() {
	c := &Client{}
	err := proto.TargetSendMessageToTarget{}.Call(c)
	t.Nil(err)
}

func (t T) TargetSetAutoAttach() {
	c := &Client{}
	err := proto.TargetSetAutoAttach{}.Call(c)
	t.Nil(err)
}

func (t T) TargetAutoAttachRelated() {
	c := &Client{}
	err := proto.TargetAutoAttachRelated{}.Call(c)
	t.Nil(err)
}

func (t T) TargetSetDiscoverTargets() {
	c := &Client{}
	err := proto.TargetSetDiscoverTargets{}.Call(c)
	t.Nil(err)
}

func (t T) TargetSetRemoteLocations() {
	c := &Client{}
	err := proto.TargetSetRemoteLocations{}.Call(c)
	t.Nil(err)
}

func (t T) TargetAttachedToTarget() {
	e := proto.TargetAttachedToTarget{}
	t.Regex("", e.ProtoEvent())
}

func (t T) TargetDetachedFromTarget() {
	e := proto.TargetDetachedFromTarget{}
	t.Regex("", e.ProtoEvent())
}

func (t T) TargetReceivedMessageFromTarget() {
	e := proto.TargetReceivedMessageFromTarget{}
	t.Regex("", e.ProtoEvent())
}

func (t T) TargetTargetCreated() {
	e := proto.TargetTargetCreated{}
	t.Regex("", e.ProtoEvent())
}

func (t T) TargetTargetDestroyed() {
	e := proto.TargetTargetDestroyed{}
	t.Regex("", e.ProtoEvent())
}

func (t T) TargetTargetCrashed() {
	e := proto.TargetTargetCrashed{}
	t.Regex("", e.ProtoEvent())
}

func (t T) TargetTargetInfoChanged() {
	e := proto.TargetTargetInfoChanged{}
	t.Regex("", e.ProtoEvent())
}

func (t T) TetheringBind() {
	c := &Client{}
	err := proto.TetheringBind{}.Call(c)
	t.Nil(err)
}

func (t T) TetheringUnbind() {
	c := &Client{}
	err := proto.TetheringUnbind{}.Call(c)
	t.Nil(err)
}

func (t T) TetheringAccepted() {
	e := proto.TetheringAccepted{}
	t.Regex("", e.ProtoEvent())
}

func (t T) TracingEnd() {
	c := &Client{}
	err := proto.TracingEnd{}.Call(c)
	t.Nil(err)
}

func (t T) TracingGetCategories() {
	c := &Client{}
	_, err := proto.TracingGetCategories{}.Call(c)
	t.Nil(err)
}

func (t T) TracingRecordClockSyncMarker() {
	c := &Client{}
	err := proto.TracingRecordClockSyncMarker{}.Call(c)
	t.Nil(err)
}

func (t T) TracingRequestMemoryDump() {
	c := &Client{}
	_, err := proto.TracingRequestMemoryDump{}.Call(c)
	t.Nil(err)
}

func (t T) TracingStart() {
	c := &Client{}
	err := proto.TracingStart{}.Call(c)
	t.Nil(err)
}

func (t T) TracingBufferUsage() {
	e := proto.TracingBufferUsage{}
	t.Regex("", e.ProtoEvent())
}

func (t T) TracingDataCollected() {
	e := proto.TracingDataCollected{}
	t.Regex("", e.ProtoEvent())
}

func (t T) TracingTracingComplete() {
	e := proto.TracingTracingComplete{}
	t.Regex("", e.ProtoEvent())
}

func (t T) FetchDisable() {
	c := &Client{}
	err := proto.FetchDisable{}.Call(c)
	t.Nil(err)
}

func (t T) FetchEnable() {
	c := &Client{}
	err := proto.FetchEnable{}.Call(c)
	t.Nil(err)
}

func (t T) FetchFailRequest() {
	c := &Client{}
	err := proto.FetchFailRequest{}.Call(c)
	t.Nil(err)
}

func (t T) FetchFulfillRequest() {
	c := &Client{}
	err := proto.FetchFulfillRequest{}.Call(c)
	t.Nil(err)
}

func (t T) FetchContinueRequest() {
	c := &Client{}
	err := proto.FetchContinueRequest{}.Call(c)
	t.Nil(err)
}

func (t T) FetchContinueWithAuth() {
	c := &Client{}
	err := proto.FetchContinueWithAuth{}.Call(c)
	t.Nil(err)
}

func (t T) FetchContinueResponse() {
	c := &Client{}
	err := proto.FetchContinueResponse{}.Call(c)
	t.Nil(err)
}

func (t T) FetchGetResponseBody() {
	c := &Client{}
	_, err := proto.FetchGetResponseBody{}.Call(c)
	t.Nil(err)
}

func (t T) FetchTakeResponseBodyAsStream() {
	c := &Client{}
	_, err := proto.FetchTakeResponseBodyAsStream{}.Call(c)
	t.Nil(err)
}

func (t T) FetchRequestPaused() {
	e := proto.FetchRequestPaused{}
	t.Regex("", e.ProtoEvent())
}

func (t T) FetchAuthRequired() {
	e := proto.FetchAuthRequired{}
	t.Regex("", e.ProtoEvent())
}

func (t T) WebAudioEnable() {
	c := &Client{}
	err := proto.WebAudioEnable{}.Call(c)
	t.Nil(err)
}

func (t T) WebAudioDisable() {
	c := &Client{}
	err := proto.WebAudioDisable{}.Call(c)
	t.Nil(err)
}

func (t T) WebAudioGetRealtimeData() {
	c := &Client{}
	_, err := proto.WebAudioGetRealtimeData{}.Call(c)
	t.Nil(err)
}

func (t T) WebAudioContextCreated() {
	e := proto.WebAudioContextCreated{}
	t.Regex("", e.ProtoEvent())
}

func (t T) WebAudioContextWillBeDestroyed() {
	e := proto.WebAudioContextWillBeDestroyed{}
	t.Regex("", e.ProtoEvent())
}

func (t T) WebAudioContextChanged() {
	e := proto.WebAudioContextChanged{}
	t.Regex("", e.ProtoEvent())
}

func (t T) WebAudioAudioListenerCreated() {
	e := proto.WebAudioAudioListenerCreated{}
	t.Regex("", e.ProtoEvent())
}

func (t T) WebAudioAudioListenerWillBeDestroyed() {
	e := proto.WebAudioAudioListenerWillBeDestroyed{}
	t.Regex("", e.ProtoEvent())
}

func (t T) WebAudioAudioNodeCreated() {
	e := proto.WebAudioAudioNodeCreated{}
	t.Regex("", e.ProtoEvent())
}

func (t T) WebAudioAudioNodeWillBeDestroyed() {
	e := proto.WebAudioAudioNodeWillBeDestroyed{}
	t.Regex("", e.ProtoEvent())
}

func (t T) WebAudioAudioParamCreated() {
	e := proto.WebAudioAudioParamCreated{}
	t.Regex("", e.ProtoEvent())
}

func (t T) WebAudioAudioParamWillBeDestroyed() {
	e := proto.WebAudioAudioParamWillBeDestroyed{}
	t.Regex("", e.ProtoEvent())
}

func (t T) WebAudioNodesConnected() {
	e := proto.WebAudioNodesConnected{}
	t.Regex("", e.ProtoEvent())
}

func (t T) WebAudioNodesDisconnected() {
	e := proto.WebAudioNodesDisconnected{}
	t.Regex("", e.ProtoEvent())
}

func (t T) WebAudioNodeParamConnected() {
	e := proto.WebAudioNodeParamConnected{}
	t.Regex("", e.ProtoEvent())
}

func (t T) WebAudioNodeParamDisconnected() {
	e := proto.WebAudioNodeParamDisconnected{}
	t.Regex("", e.ProtoEvent())
}

func (t T) WebAuthnEnable() {
	c := &Client{}
	err := proto.WebAuthnEnable{}.Call(c)
	t.Nil(err)
}

func (t T) WebAuthnDisable() {
	c := &Client{}
	err := proto.WebAuthnDisable{}.Call(c)
	t.Nil(err)
}

func (t T) WebAuthnAddVirtualAuthenticator() {
	c := &Client{}
	_, err := proto.WebAuthnAddVirtualAuthenticator{}.Call(c)
	t.Nil(err)
}

func (t T) WebAuthnSetResponseOverrideBits() {
	c := &Client{}
	err := proto.WebAuthnSetResponseOverrideBits{}.Call(c)
	t.Nil(err)
}

func (t T) WebAuthnRemoveVirtualAuthenticator() {
	c := &Client{}
	err := proto.WebAuthnRemoveVirtualAuthenticator{}.Call(c)
	t.Nil(err)
}

func (t T) WebAuthnAddCredential() {
	c := &Client{}
	err := proto.WebAuthnAddCredential{}.Call(c)
	t.Nil(err)
}

func (t T) WebAuthnGetCredential() {
	c := &Client{}
	_, err := proto.WebAuthnGetCredential{}.Call(c)
	t.Nil(err)
}

func (t T) WebAuthnGetCredentials() {
	c := &Client{}
	_, err := proto.WebAuthnGetCredentials{}.Call(c)
	t.Nil(err)
}

func (t T) WebAuthnRemoveCredential() {
	c := &Client{}
	err := proto.WebAuthnRemoveCredential{}.Call(c)
	t.Nil(err)
}

func (t T) WebAuthnClearCredentials() {
	c := &Client{}
	err := proto.WebAuthnClearCredentials{}.Call(c)
	t.Nil(err)
}

func (t T) WebAuthnSetUserVerified() {
	c := &Client{}
	err := proto.WebAuthnSetUserVerified{}.Call(c)
	t.Nil(err)
}

func (t T) WebAuthnSetAutomaticPresenceSimulation() {
	c := &Client{}
	err := proto.WebAuthnSetAutomaticPresenceSimulation{}.Call(c)
	t.Nil(err)
}

func (t T) WebAuthnCredentialAdded() {
	e := proto.WebAuthnCredentialAdded{}
	t.Regex("", e.ProtoEvent())
}

func (t T) WebAuthnCredentialAsserted() {
	e := proto.WebAuthnCredentialAsserted{}
	t.Regex("", e.ProtoEvent())
}

func (t T) MediaEnable() {
	c := &Client{}
	err := proto.MediaEnable{}.Call(c)
	t.Nil(err)
}

func (t T) MediaDisable() {
	c := &Client{}
	err := proto.MediaDisable{}.Call(c)
	t.Nil(err)
}

func (t T) MediaPlayerPropertiesChanged() {
	e := proto.MediaPlayerPropertiesChanged{}
	t.Regex("", e.ProtoEvent())
}

func (t T) MediaPlayerEventsAdded() {
	e := proto.MediaPlayerEventsAdded{}
	t.Regex("", e.ProtoEvent())
}

func (t T) MediaPlayerMessagesLogged() {
	e := proto.MediaPlayerMessagesLogged{}
	t.Regex("", e.ProtoEvent())
}

func (t T) MediaPlayerErrorsRaised() {
	e := proto.MediaPlayerErrorsRaised{}
	t.Regex("", e.ProtoEvent())
}

func (t T) MediaPlayersCreated() {
	e := proto.MediaPlayersCreated{}
	t.Regex("", e.ProtoEvent())
}

func (t T) DeviceAccessEnable() {
	c := &Client{}
	err := proto.DeviceAccessEnable{}.Call(c)
	t.Nil(err)
}

func (t T) DeviceAccessDisable() {
	c := &Client{}
	err := proto.DeviceAccessDisable{}.Call(c)
	t.Nil(err)
}

func (t T) DeviceAccessSelectPrompt() {
	c := &Client{}
	err := proto.DeviceAccessSelectPrompt{}.Call(c)
	t.Nil(err)
}

func (t T) DeviceAccessCancelPrompt() {
	c := &Client{}
	err := proto.DeviceAccessCancelPrompt{}.Call(c)
	t.Nil(err)
}

func (t T) DeviceAccessDeviceRequestPrompted() {
	e := proto.DeviceAccessDeviceRequestPrompted{}
	t.Regex("", e.ProtoEvent())
}

func (t T) PreloadEnable() {
	c := &Client{}
	err := proto.PreloadEnable{}.Call(c)
	t.Nil(err)
}

func (t T) PreloadDisable() {
	c := &Client{}
	err := proto.PreloadDisable{}.Call(c)
	t.Nil(err)
}

func (t T) PreloadRuleSetUpdated() {
	e := proto.PreloadRuleSetUpdated{}
	t.Regex("", e.ProtoEvent())
}

func (t T) PreloadRuleSetRemoved() {
	e := proto.PreloadRuleSetRemoved{}
	t.Regex("", e.ProtoEvent())
}

func (t T) PreloadPrerenderAttemptCompleted() {
	e := proto.PreloadPrerenderAttemptCompleted{}
	t.Regex("", e.ProtoEvent())
}

func (t T) PreloadPrefetchStatusUpdated() {
	e := proto.PreloadPrefetchStatusUpdated{}
	t.Regex("", e.ProtoEvent())
}

func (t T) PreloadPrerenderStatusUpdated() {
	e := proto.PreloadPrerenderStatusUpdated{}
	t.Regex("", e.ProtoEvent())
}

func (t T) PreloadPreloadingAttemptSourcesUpdated() {
	e := proto.PreloadPreloadingAttemptSourcesUpdated{}
	t.Regex("", e.ProtoEvent())
}

func (t T) FedCmEnable() {
	c := &Client{}
	err := proto.FedCmEnable{}.Call(c)
	t.Nil(err)
}

func (t T) FedCmDisable() {
	c := &Client{}
	err := proto.FedCmDisable{}.Call(c)
	t.Nil(err)
}

func (t T) FedCmSelectAccount() {
	c := &Client{}
	err := proto.FedCmSelectAccount{}.Call(c)
	t.Nil(err)
}

func (t T) FedCmDismissDialog() {
	c := &Client{}
	err := proto.FedCmDismissDialog{}.Call(c)
	t.Nil(err)
}

func (t T) FedCmResetCooldown() {
	c := &Client{}
	err := proto.FedCmResetCooldown{}.Call(c)
	t.Nil(err)
}

func (t T) FedCmDialogShown() {
	e := proto.FedCmDialogShown{}
	t.Regex("", e.ProtoEvent())
}

func (t T) ConsoleClearMessages() {
	c := &Client{}
	err := proto.ConsoleClearMessages{}.Call(c)
	t.Nil(err)
}

func (t T) ConsoleDisable() {
	c := &Client{}
	err := proto.ConsoleDisable{}.Call(c)
	t.Nil(err)
}

func (t T) ConsoleEnable() {
	c := &Client{}
	err := proto.ConsoleEnable{}.Call(c)
	t.Nil(err)
}

func (t T) ConsoleMessageAdded() {
	e := proto.ConsoleMessageAdded{}
	t.Regex("", e.ProtoEvent())
}

func (t T) DebuggerContinueToLocation() {
	c := &Client{}
	err := proto.DebuggerContinueToLocation{}.Call(c)
	t.Nil(err)
}

func (t T) DebuggerDisable() {
	c := &Client{}
	err := proto.DebuggerDisable{}.Call(c)
	t.Nil(err)
}

func (t T) DebuggerEnable() {
	c := &Client{}
	_, err := proto.DebuggerEnable{}.Call(c)
	t.Nil(err)
}

func (t T) DebuggerEvaluateOnCallFrame() {
	c := &Client{}
	_, err := proto.DebuggerEvaluateOnCallFrame{}.Call(c)
	t.Nil(err)
}

func (t T) DebuggerGetPossibleBreakpoints() {
	c := &Client{}
	_, err := proto.DebuggerGetPossibleBreakpoints{}.Call(c)
	t.Nil(err)
}

func (t T) DebuggerGetScriptSource() {
	c := &Client{}
	_, err := proto.DebuggerGetScriptSource{}.Call(c)
	t.Nil(err)
}

func (t T) DebuggerDisassembleWasmModule() {
	c := &Client{}
	_, err := proto.DebuggerDisassembleWasmModule{}.Call(c)
	t.Nil(err)
}

func (t T) DebuggerNextWasmDisassemblyChunk() {
	c := &Client{}
	_, err := proto.DebuggerNextWasmDisassemblyChunk{}.Call(c)
	t.Nil(err)
}

func (t T) DebuggerGetWasmBytecode() {
	c := &Client{}
	_, err := proto.DebuggerGetWasmBytecode{}.Call(c)
	t.Nil(err)
}

func (t T) DebuggerGetStackTrace() {
	c := &Client{}
	_, err := proto.DebuggerGetStackTrace{}.Call(c)
	t.Nil(err)
}

func (t T) DebuggerPause() {
	c := &Client{}
	err := proto.DebuggerPause{}.Call(c)
	t.Nil(err)
}

func (t T) DebuggerPauseOnAsyncCall() {
	c := &Client{}
	err := proto.DebuggerPauseOnAsyncCall{}.Call(c)
	t.Nil(err)
}

func (t T) DebuggerRemoveBreakpoint() {
	c := &Client{}
	err := proto.DebuggerRemoveBreakpoint{}.Call(c)
	t.Nil(err)
}

func (t T) DebuggerRestartFrame() {
	c := &Client{}
	_, err := proto.DebuggerRestartFrame{}.Call(c)
	t.Nil(err)
}

func (t T) DebuggerResume() {
	c := &Client{}
	err := proto.DebuggerResume{}.Call(c)
	t.Nil(err)
}

func (t T) DebuggerSearchInContent() {
	c := &Client{}
	_, err := proto.DebuggerSearchInContent{}.Call(c)
	t.Nil(err)
}

func (t T) DebuggerSetAsyncCallStackDepth() {
	c := &Client{}
	err := proto.DebuggerSetAsyncCallStackDepth{}.Call(c)
	t.Nil(err)
}

func (t T) DebuggerSetBlackboxPatterns() {
	c := &Client{}
	err := proto.DebuggerSetBlackboxPatterns{}.Call(c)
	t.Nil(err)
}

func (t T) DebuggerSetBlackboxedRanges() {
	c := &Client{}
	err := proto.DebuggerSetBlackboxedRanges{}.Call(c)
	t.Nil(err)
}

func (t T) DebuggerSetBreakpoint() {
	c := &Client{}
	_, err := proto.DebuggerSetBreakpoint{}.Call(c)
	t.Nil(err)
}

func (t T) DebuggerSetInstrumentationBreakpoint() {
	c := &Client{}
	_, err := proto.DebuggerSetInstrumentationBreakpoint{}.Call(c)
	t.Nil(err)
}

func (t T) DebuggerSetBreakpointByURL() {
	c := &Client{}
	_, err := proto.DebuggerSetBreakpointByURL{}.Call(c)
	t.Nil(err)
}

func (t T) DebuggerSetBreakpointOnFunctionCall() {
	c := &Client{}
	_, err := proto.DebuggerSetBreakpointOnFunctionCall{}.Call(c)
	t.Nil(err)
}

func (t T) DebuggerSetBreakpointsActive() {
	c := &Client{}
	err := proto.DebuggerSetBreakpointsActive{}.Call(c)
	t.Nil(err)
}

func (t T) DebuggerSetPauseOnExceptions() {
	c := &Client{}
	err := proto.DebuggerSetPauseOnExceptions{}.Call(c)
	t.Nil(err)
}

func (t T) DebuggerSetReturnValue() {
	c := &Client{}
	err := proto.DebuggerSetReturnValue{}.Call(c)
	t.Nil(err)
}

func (t T) DebuggerSetScriptSource() {
	c := &Client{}
	_, err := proto.DebuggerSetScriptSource{}.Call(c)
	t.Nil(err)
}

func (t T) DebuggerSetSkipAllPauses() {
	c := &Client{}
	err := proto.DebuggerSetSkipAllPauses{}.Call(c)
	t.Nil(err)
}

func (t T) DebuggerSetVariableValue() {
	c := &Client{}
	err := proto.DebuggerSetVariableValue{}.Call(c)
	t.Nil(err)
}

func (t T) DebuggerStepInto() {
	c := &Client{}
	err := proto.DebuggerStepInto{}.Call(c)
	t.Nil(err)
}

func (t T) DebuggerStepOut() {
	c := &Client{}
	err := proto.DebuggerStepOut{}.Call(c)
	t.Nil(err)
}

func (t T) DebuggerStepOver() {
	c := &Client{}
	err := proto.DebuggerStepOver{}.Call(c)
	t.Nil(err)
}

func (t T) DebuggerBreakpointResolved() {
	e := proto.DebuggerBreakpointResolved{}
	t.Regex("", e.ProtoEvent())
}

func (t T) DebuggerPaused() {
	e := proto.DebuggerPaused{}
	t.Regex("", e.ProtoEvent())
}

func (t T) DebuggerResumed() {
	e := proto.DebuggerResumed{}
	t.Regex("", e.ProtoEvent())
}

func (t T) DebuggerScriptFailedToParse() {
	e := proto.DebuggerScriptFailedToParse{}
	t.Regex("", e.ProtoEvent())
}

func (t T) DebuggerScriptParsed() {
	e := proto.DebuggerScriptParsed{}
	t.Regex("", e.ProtoEvent())
}

func (t T) HeapProfilerAddInspectedHeapObject() {
	c := &Client{}
	err := proto.HeapProfilerAddInspectedHeapObject{}.Call(c)
	t.Nil(err)
}

func (t T) HeapProfilerCollectGarbage() {
	c := &Client{}
	err := proto.HeapProfilerCollectGarbage{}.Call(c)
	t.Nil(err)
}

func (t T) HeapProfilerDisable() {
	c := &Client{}
	err := proto.HeapProfilerDisable{}.Call(c)
	t.Nil(err)
}

func (t T) HeapProfilerEnable() {
	c := &Client{}
	err := proto.HeapProfilerEnable{}.Call(c)
	t.Nil(err)
}

func (t T) HeapProfilerGetHeapObjectID() {
	c := &Client{}
	_, err := proto.HeapProfilerGetHeapObjectID{}.Call(c)
	t.Nil(err)
}

func (t T) HeapProfilerGetObjectByHeapObjectID() {
	c := &Client{}
	_, err := proto.HeapProfilerGetObjectByHeapObjectID{}.Call(c)
	t.Nil(err)
}

func (t T) HeapProfilerGetSamplingProfile() {
	c := &Client{}
	_, err := proto.HeapProfilerGetSamplingProfile{}.Call(c)
	t.Nil(err)
}

func (t T) HeapProfilerStartSampling() {
	c := &Client{}
	err := proto.HeapProfilerStartSampling{}.Call(c)
	t.Nil(err)
}

func (t T) HeapProfilerStartTrackingHeapObjects() {
	c := &Client{}
	err := proto.HeapProfilerStartTrackingHeapObjects{}.Call(c)
	t.Nil(err)
}

func (t T) HeapProfilerStopSampling() {
	c := &Client{}
	_, err := proto.HeapProfilerStopSampling{}.Call(c)
	t.Nil(err)
}

func (t T) HeapProfilerStopTrackingHeapObjects() {
	c := &Client{}
	err := proto.HeapProfilerStopTrackingHeapObjects{}.Call(c)
	t.Nil(err)
}

func (t T) HeapProfilerTakeHeapSnapshot() {
	c := &Client{}
	err := proto.HeapProfilerTakeHeapSnapshot{}.Call(c)
	t.Nil(err)
}

func (t T) HeapProfilerAddHeapSnapshotChunk() {
	e := proto.HeapProfilerAddHeapSnapshotChunk{}
	t.Regex("", e.ProtoEvent())
}

func (t T) HeapProfilerHeapStatsUpdate() {
	e := proto.HeapProfilerHeapStatsUpdate{}
	t.Regex("", e.ProtoEvent())
}

func (t T) HeapProfilerLastSeenObjectID() {
	e := proto.HeapProfilerLastSeenObjectID{}
	t.Regex("", e.ProtoEvent())
}

func (t T) HeapProfilerReportHeapSnapshotProgress() {
	e := proto.HeapProfilerReportHeapSnapshotProgress{}
	t.Regex("", e.ProtoEvent())
}

func (t T) HeapProfilerResetProfiles() {
	e := proto.HeapProfilerResetProfiles{}
	t.Regex("", e.ProtoEvent())
}

func (t T) ProfilerDisable() {
	c := &Client{}
	err := proto.ProfilerDisable{}.Call(c)
	t.Nil(err)
}

func (t T) ProfilerEnable() {
	c := &Client{}
	err := proto.ProfilerEnable{}.Call(c)
	t.Nil(err)
}

func (t T) ProfilerGetBestEffortCoverage() {
	c := &Client{}
	_, err := proto.ProfilerGetBestEffortCoverage{}.Call(c)
	t.Nil(err)
}

func (t T) ProfilerSetSamplingInterval() {
	c := &Client{}
	err := proto.ProfilerSetSamplingInterval{}.Call(c)
	t.Nil(err)
}

func (t T) ProfilerStart() {
	c := &Client{}
	err := proto.ProfilerStart{}.Call(c)
	t.Nil(err)
}

func (t T) ProfilerStartPreciseCoverage() {
	c := &Client{}
	_, err := proto.ProfilerStartPreciseCoverage{}.Call(c)
	t.Nil(err)
}

func (t T) ProfilerStop() {
	c := &Client{}
	_, err := proto.ProfilerStop{}.Call(c)
	t.Nil(err)
}

func (t T) ProfilerStopPreciseCoverage() {
	c := &Client{}
	err := proto.ProfilerStopPreciseCoverage{}.Call(c)
	t.Nil(err)
}

func (t T) ProfilerTakePreciseCoverage() {
	c := &Client{}
	_, err := proto.ProfilerTakePreciseCoverage{}.Call(c)
	t.Nil(err)
}

func (t T) ProfilerConsoleProfileFinished() {
	e := proto.ProfilerConsoleProfileFinished{}
	t.Regex("", e.ProtoEvent())
}

func (t T) ProfilerConsoleProfileStarted() {
	e := proto.ProfilerConsoleProfileStarted{}
	t.Regex("", e.ProtoEvent())
}

func (t T) ProfilerPreciseCoverageDeltaUpdate() {
	e := proto.ProfilerPreciseCoverageDeltaUpdate{}
	t.Regex("", e.ProtoEvent())
}

func (t T) RuntimeAwaitPromise() {
	c := &Client{}
	_, err := proto.RuntimeAwaitPromise{}.Call(c)
	t.Nil(err)
}

func (t T) RuntimeCallFunctionOn() {
	c := &Client{}
	_, err := proto.RuntimeCallFunctionOn{}.Call(c)
	t.Nil(err)
}

func (t T) RuntimeCompileScript() {
	c := &Client{}
	_, err := proto.RuntimeCompileScript{}.Call(c)
	t.Nil(err)
}

func (t T) RuntimeDisable() {
	c := &Client{}
	err := proto.RuntimeDisable{}.Call(c)
	t.Nil(err)
}

func (t T) RuntimeDiscardConsoleEntries() {
	c := &Client{}
	err := proto.RuntimeDiscardConsoleEntries{}.Call(c)
	t.Nil(err)
}

func (t T) RuntimeEnable() {
	c := &Client{}
	err := proto.RuntimeEnable{}.Call(c)
	t.Nil(err)
}

func (t T) RuntimeEvaluate() {
	c := &Client{}
	_, err := proto.RuntimeEvaluate{}.Call(c)
	t.Nil(err)
}

func (t T) RuntimeGetIsolateID() {
	c := &Client{}
	_, err := proto.RuntimeGetIsolateID{}.Call(c)
	t.Nil(err)
}

func (t T) RuntimeGetHeapUsage() {
	c := &Client{}
	_, err := proto.RuntimeGetHeapUsage{}.Call(c)
	t.Nil(err)
}

func (t T) RuntimeGetProperties() {
	c := &Client{}
	_, err := proto.RuntimeGetProperties{}.Call(c)
	t.Nil(err)
}

func (t T) RuntimeGlobalLexicalScopeNames() {
	c := &Client{}
	_, err := proto.RuntimeGlobalLexicalScopeNames{}.Call(c)
	t.Nil(err)
}

func (t T) RuntimeQueryObjects() {
	c := &Client{}
	_, err := proto.RuntimeQueryObjects{}.Call(c)
	t.Nil(err)
}

func (t T) RuntimeReleaseObject() {
	c := &Client{}
	err := proto.RuntimeReleaseObject{}.Call(c)
	t.Nil(err)
}

func (t T) RuntimeReleaseObjectGroup() {
	c := &Client{}
	err := proto.RuntimeReleaseObjectGroup{}.Call(c)
	t.Nil(err)
}

func (t T) RuntimeRunIfWaitingForDebugger() {
	c := &Client{}
	err := proto.RuntimeRunIfWaitingForDebugger{}.Call(c)
	t.Nil(err)
}

func (t T) RuntimeRunScript() {
	c := &Client{}
	_, err := proto.RuntimeRunScript{}.Call(c)
	t.Nil(err)
}

func (t T) RuntimeSetAsyncCallStackDepth() {
	c := &Client{}
	err := proto.RuntimeSetAsyncCallStackDepth{}.Call(c)
	t.Nil(err)
}

func (t T) RuntimeSetCustomObjectFormatterEnabled() {
	c := &Client{}
	err := proto.RuntimeSetCustomObjectFormatterEnabled{}.Call(c)
	t.Nil(err)
}

func (t T) RuntimeSetMaxCallStackSizeToCapture() {
	c := &Client{}
	err := proto.RuntimeSetMaxCallStackSizeToCapture{}.Call(c)
	t.Nil(err)
}

func (t T) RuntimeTerminateExecution() {
	c := &Client{}
	err := proto.RuntimeTerminateExecution{}.Call(c)
	t.Nil(err)
}

func (t T) RuntimeAddBinding() {
	c := &Client{}
	err := proto.RuntimeAddBinding{}.Call(c)
	t.Nil(err)
}

func (t T) RuntimeRemoveBinding() {
	c := &Client{}
	err := proto.RuntimeRemoveBinding{}.Call(c)
	t.Nil(err)
}

func (t T) RuntimeGetExceptionDetails() {
	c := &Client{}
	_, err := proto.RuntimeGetExceptionDetails{}.Call(c)
	t.Nil(err)
}

func (t T) RuntimeBindingCalled() {
	e := proto.RuntimeBindingCalled{}
	t.Regex("", e.ProtoEvent())
}

func (t T) RuntimeConsoleAPICalled() {
	e := proto.RuntimeConsoleAPICalled{}
	t.Regex("", e.ProtoEvent())
}

func (t T) RuntimeExceptionRevoked() {
	e := proto.RuntimeExceptionRevoked{}
	t.Regex("", e.ProtoEvent())
}

func (t T) RuntimeExceptionThrown() {
	e := proto.RuntimeExceptionThrown{}
	t.Regex("", e.ProtoEvent())
}

func (t T) RuntimeExecutionContextCreated() {
	e := proto.RuntimeExecutionContextCreated{}
	t.Regex("", e.ProtoEvent())
}

func (t T) RuntimeExecutionContextDestroyed() {
	e := proto.RuntimeExecutionContextDestroyed{}
	t.Regex("", e.ProtoEvent())
}

func (t T) RuntimeExecutionContextsCleared() {
	e := proto.RuntimeExecutionContextsCleared{}
	t.Regex("", e.ProtoEvent())
}

func (t T) RuntimeInspectRequested() {
	e := proto.RuntimeInspectRequested{}
	t.Regex("", e.ProtoEvent())
}

func (t T) SchemaGetDomains() {
	c := &Client{}
	_, err := proto.SchemaGetDomains{}.Call(c)
	t.Nil(err)
}
