func (d *domainClient) HandleFileChooser(ctx context.Context, args *HandleFileChooserArgs) (err error) {
	if args != nil {
		err = rpcc.Invoke(ctx, "Page.handleFileChooser", args, nil, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Page.handleFileChooser", nil, nil, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Page", Op: "HandleFileChooser", Err: err}
	}
	return
}
HandleFileChooser invokes the Page method. Accepts or cancels an
intercepted file chooser dialog.
package page
import (
	"context"
	"github.com/mafredri/cdp/protocol/internal"
	"github.com/mafredri/cdp/rpcc"
)
type domainClient struct{ conn *rpcc.Conn }
func NewClient(conn *rpcc.Conn) *domainClient {
	return &domainClient{conn: conn}
}
func (d *domainClient) AddScriptToEvaluateOnLoad(ctx context.Context, args *AddScriptToEvaluateOnLoadArgs) (reply *AddScriptToEvaluateOnLoadReply, err error) {
	reply = new(AddScriptToEvaluateOnLoadReply)
	if args != nil {
		err = rpcc.Invoke(ctx, "Page.addScriptToEvaluateOnLoad", args, reply, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Page.addScriptToEvaluateOnLoad", nil, reply, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Page", Op: "AddScriptToEvaluateOnLoad", Err: err}
	}
	return
}
func (d *domainClient) AddScriptToEvaluateOnNewDocument(ctx context.Context, args *AddScriptToEvaluateOnNewDocumentArgs) (reply *AddScriptToEvaluateOnNewDocumentReply, err error) {
	reply = new(AddScriptToEvaluateOnNewDocumentReply)
	if args != nil {
		err = rpcc.Invoke(ctx, "Page.addScriptToEvaluateOnNewDocument", args, reply, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Page.addScriptToEvaluateOnNewDocument", nil, reply, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Page", Op: "AddScriptToEvaluateOnNewDocument", Err: err}
	}
	return
}
func (d *domainClient) BringToFront(ctx context.Context) (err error) {
	err = rpcc.Invoke(ctx, "Page.bringToFront", nil, nil, d.conn)
	if err != nil {
		err = &internal.OpError{Domain: "Page", Op: "BringToFront", Err: err}
	}
	return
}
func (d *domainClient) CaptureScreenshot(ctx context.Context, args *CaptureScreenshotArgs) (reply *CaptureScreenshotReply, err error) {
	reply = new(CaptureScreenshotReply)
	if args != nil {
		err = rpcc.Invoke(ctx, "Page.captureScreenshot", args, reply, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Page.captureScreenshot", nil, reply, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Page", Op: "CaptureScreenshot", Err: err}
	}
	return
}
func (d *domainClient) CaptureSnapshot(ctx context.Context, args *CaptureSnapshotArgs) (reply *CaptureSnapshotReply, err error) {
	reply = new(CaptureSnapshotReply)
	if args != nil {
		err = rpcc.Invoke(ctx, "Page.captureSnapshot", args, reply, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Page.captureSnapshot", nil, reply, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Page", Op: "CaptureSnapshot", Err: err}
	}
	return
}
func (d *domainClient) CreateIsolatedWorld(ctx context.Context, args *CreateIsolatedWorldArgs) (reply *CreateIsolatedWorldReply, err error) {
	reply = new(CreateIsolatedWorldReply)
	if args != nil {
		err = rpcc.Invoke(ctx, "Page.createIsolatedWorld", args, reply, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Page.createIsolatedWorld", nil, reply, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Page", Op: "CreateIsolatedWorld", Err: err}
	}
	return
}
func (d *domainClient) Disable(ctx context.Context) (err error) {
	err = rpcc.Invoke(ctx, "Page.disable", nil, nil, d.conn)
	if err != nil {
		err = &internal.OpError{Domain: "Page", Op: "Disable", Err: err}
	}
	return
}
func (d *domainClient) Enable(ctx context.Context) (err error) {
	err = rpcc.Invoke(ctx, "Page.enable", nil, nil, d.conn)
	if err != nil {
		err = &internal.OpError{Domain: "Page", Op: "Enable", Err: err}
	}
	return
}
func (d *domainClient) GetAppManifest(ctx context.Context) (reply *GetAppManifestReply, err error) {
	reply = new(GetAppManifestReply)
	err = rpcc.Invoke(ctx, "Page.getAppManifest", nil, reply, d.conn)
	if err != nil {
		err = &internal.OpError{Domain: "Page", Op: "GetAppManifest", Err: err}
	}
	return
}
func (d *domainClient) GetInstallabilityErrors(ctx context.Context) (reply *GetInstallabilityErrorsReply, err error) {
	reply = new(GetInstallabilityErrorsReply)
	err = rpcc.Invoke(ctx, "Page.getInstallabilityErrors", nil, reply, d.conn)
	if err != nil {
		err = &internal.OpError{Domain: "Page", Op: "GetInstallabilityErrors", Err: err}
	}
	return
}
func (d *domainClient) GetFrameTree(ctx context.Context) (reply *GetFrameTreeReply, err error) {
	reply = new(GetFrameTreeReply)
	err = rpcc.Invoke(ctx, "Page.getFrameTree", nil, reply, d.conn)
	if err != nil {
		err = &internal.OpError{Domain: "Page", Op: "GetFrameTree", Err: err}
	}
	return
}
func (d *domainClient) GetLayoutMetrics(ctx context.Context) (reply *GetLayoutMetricsReply, err error) {
	reply = new(GetLayoutMetricsReply)
	err = rpcc.Invoke(ctx, "Page.getLayoutMetrics", nil, reply, d.conn)
	if err != nil {
		err = &internal.OpError{Domain: "Page", Op: "GetLayoutMetrics", Err: err}
	}
	return
}
func (d *domainClient) GetNavigationHistory(ctx context.Context) (reply *GetNavigationHistoryReply, err error) {
	reply = new(GetNavigationHistoryReply)
	err = rpcc.Invoke(ctx, "Page.getNavigationHistory", nil, reply, d.conn)
	if err != nil {
		err = &internal.OpError{Domain: "Page", Op: "GetNavigationHistory", Err: err}
	}
	return
}
func (d *domainClient) ResetNavigationHistory(ctx context.Context) (err error) {
	err = rpcc.Invoke(ctx, "Page.resetNavigationHistory", nil, nil, d.conn)
	if err != nil {
		err = &internal.OpError{Domain: "Page", Op: "ResetNavigationHistory", Err: err}
	}
	return
}
func (d *domainClient) GetResourceContent(ctx context.Context, args *GetResourceContentArgs) (reply *GetResourceContentReply, err error) {
	reply = new(GetResourceContentReply)
	if args != nil {
		err = rpcc.Invoke(ctx, "Page.getResourceContent", args, reply, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Page.getResourceContent", nil, reply, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Page", Op: "GetResourceContent", Err: err}
	}
	return
}
func (d *domainClient) GetResourceTree(ctx context.Context) (reply *GetResourceTreeReply, err error) {
	reply = new(GetResourceTreeReply)
	err = rpcc.Invoke(ctx, "Page.getResourceTree", nil, reply, d.conn)
	if err != nil {
		err = &internal.OpError{Domain: "Page", Op: "GetResourceTree", Err: err}
	}
	return
}
func (d *domainClient) HandleJavaScriptDialog(ctx context.Context, args *HandleJavaScriptDialogArgs) (err error) {
	if args != nil {
		err = rpcc.Invoke(ctx, "Page.handleJavaScriptDialog", args, nil, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Page.handleJavaScriptDialog", nil, nil, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Page", Op: "HandleJavaScriptDialog", Err: err}
	}
	return
}
func (d *domainClient) Navigate(ctx context.Context, args *NavigateArgs) (reply *NavigateReply, err error) {
	reply = new(NavigateReply)
	if args != nil {
		err = rpcc.Invoke(ctx, "Page.navigate", args, reply, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Page.navigate", nil, reply, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Page", Op: "Navigate", Err: err}
	}
	return
}
func (d *domainClient) NavigateToHistoryEntry(ctx context.Context, args *NavigateToHistoryEntryArgs) (err error) {
	if args != nil {
		err = rpcc.Invoke(ctx, "Page.navigateToHistoryEntry", args, nil, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Page.navigateToHistoryEntry", nil, nil, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Page", Op: "NavigateToHistoryEntry", Err: err}
	}
	return
}
func (d *domainClient) PrintToPDF(ctx context.Context, args *PrintToPDFArgs) (reply *PrintToPDFReply, err error) {
	reply = new(PrintToPDFReply)
	if args != nil {
		err = rpcc.Invoke(ctx, "Page.printToPDF", args, reply, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Page.printToPDF", nil, reply, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Page", Op: "PrintToPDF", Err: err}
	}
	return
}
func (d *domainClient) Reload(ctx context.Context, args *ReloadArgs) (err error) {
	if args != nil {
		err = rpcc.Invoke(ctx, "Page.reload", args, nil, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Page.reload", nil, nil, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Page", Op: "Reload", Err: err}
	}
	return
}
func (d *domainClient) RemoveScriptToEvaluateOnLoad(ctx context.Context, args *RemoveScriptToEvaluateOnLoadArgs) (err error) {
	if args != nil {
		err = rpcc.Invoke(ctx, "Page.removeScriptToEvaluateOnLoad", args, nil, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Page.removeScriptToEvaluateOnLoad", nil, nil, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Page", Op: "RemoveScriptToEvaluateOnLoad", Err: err}
	}
	return
}
func (d *domainClient) RemoveScriptToEvaluateOnNewDocument(ctx context.Context, args *RemoveScriptToEvaluateOnNewDocumentArgs) (err error) {
	if args != nil {
		err = rpcc.Invoke(ctx, "Page.removeScriptToEvaluateOnNewDocument", args, nil, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Page.removeScriptToEvaluateOnNewDocument", nil, nil, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Page", Op: "RemoveScriptToEvaluateOnNewDocument", Err: err}
	}
	return
}
func (d *domainClient) ScreencastFrameAck(ctx context.Context, args *ScreencastFrameAckArgs) (err error) {
	if args != nil {
		err = rpcc.Invoke(ctx, "Page.screencastFrameAck", args, nil, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Page.screencastFrameAck", nil, nil, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Page", Op: "ScreencastFrameAck", Err: err}
	}
	return
}
func (d *domainClient) SearchInResource(ctx context.Context, args *SearchInResourceArgs) (reply *SearchInResourceReply, err error) {
	reply = new(SearchInResourceReply)
	if args != nil {
		err = rpcc.Invoke(ctx, "Page.searchInResource", args, reply, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Page.searchInResource", nil, reply, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Page", Op: "SearchInResource", Err: err}
	}
	return
}
func (d *domainClient) SetAdBlockingEnabled(ctx context.Context, args *SetAdBlockingEnabledArgs) (err error) {
	if args != nil {
		err = rpcc.Invoke(ctx, "Page.setAdBlockingEnabled", args, nil, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Page.setAdBlockingEnabled", nil, nil, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Page", Op: "SetAdBlockingEnabled", Err: err}
	}
	return
}
func (d *domainClient) SetBypassCSP(ctx context.Context, args *SetBypassCSPArgs) (err error) {
	if args != nil {
		err = rpcc.Invoke(ctx, "Page.setBypassCSP", args, nil, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Page.setBypassCSP", nil, nil, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Page", Op: "SetBypassCSP", Err: err}
	}
	return
}
func (d *domainClient) SetFontFamilies(ctx context.Context, args *SetFontFamiliesArgs) (err error) {
	if args != nil {
		err = rpcc.Invoke(ctx, "Page.setFontFamilies", args, nil, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Page.setFontFamilies", nil, nil, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Page", Op: "SetFontFamilies", Err: err}
	}
	return
}
func (d *domainClient) SetFontSizes(ctx context.Context, args *SetFontSizesArgs) (err error) {
	if args != nil {
		err = rpcc.Invoke(ctx, "Page.setFontSizes", args, nil, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Page.setFontSizes", nil, nil, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Page", Op: "SetFontSizes", Err: err}
	}
	return
}
func (d *domainClient) SetDocumentContent(ctx context.Context, args *SetDocumentContentArgs) (err error) {
	if args != nil {
		err = rpcc.Invoke(ctx, "Page.setDocumentContent", args, nil, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Page.setDocumentContent", nil, nil, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Page", Op: "SetDocumentContent", Err: err}
	}
	return
}
func (d *domainClient) SetDownloadBehavior(ctx context.Context, args *SetDownloadBehaviorArgs) (err error) {
	if args != nil {
		err = rpcc.Invoke(ctx, "Page.setDownloadBehavior", args, nil, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Page.setDownloadBehavior", nil, nil, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Page", Op: "SetDownloadBehavior", Err: err}
	}
	return
}
func (d *domainClient) SetLifecycleEventsEnabled(ctx context.Context, args *SetLifecycleEventsEnabledArgs) (err error) {
	if args != nil {
		err = rpcc.Invoke(ctx, "Page.setLifecycleEventsEnabled", args, nil, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Page.setLifecycleEventsEnabled", nil, nil, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Page", Op: "SetLifecycleEventsEnabled", Err: err}
	}
	return
}
func (d *domainClient) StartScreencast(ctx context.Context, args *StartScreencastArgs) (err error) {
	if args != nil {
		err = rpcc.Invoke(ctx, "Page.startScreencast", args, nil, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Page.startScreencast", nil, nil, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Page", Op: "StartScreencast", Err: err}
	}
	return
}
func (d *domainClient) StopLoading(ctx context.Context) (err error) {
	err = rpcc.Invoke(ctx, "Page.stopLoading", nil, nil, d.conn)
	if err != nil {
		err = &internal.OpError{Domain: "Page", Op: "StopLoading", Err: err}
	}
	return
}
func (d *domainClient) Crash(ctx context.Context) (err error) {
	err = rpcc.Invoke(ctx, "Page.crash", nil, nil, d.conn)
	if err != nil {
		err = &internal.OpError{Domain: "Page", Op: "Crash", Err: err}
	}
	return
}
func (d *domainClient) Close(ctx context.Context) (err error) {
	err = rpcc.Invoke(ctx, "Page.close", nil, nil, d.conn)
	if err != nil {
		err = &internal.OpError{Domain: "Page", Op: "Close", Err: err}
	}
	return
}
func (d *domainClient) SetWebLifecycleState(ctx context.Context, args *SetWebLifecycleStateArgs) (err error) {
	if args != nil {
		err = rpcc.Invoke(ctx, "Page.setWebLifecycleState", args, nil, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Page.setWebLifecycleState", nil, nil, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Page", Op: "SetWebLifecycleState", Err: err}
	}
	return
}
func (d *domainClient) StopScreencast(ctx context.Context) (err error) {
	err = rpcc.Invoke(ctx, "Page.stopScreencast", nil, nil, d.conn)
	if err != nil {
		err = &internal.OpError{Domain: "Page", Op: "StopScreencast", Err: err}
	}
	return
}
func (d *domainClient) SetProduceCompilationCache(ctx context.Context, args *SetProduceCompilationCacheArgs) (err error) {
	if args != nil {
		err = rpcc.Invoke(ctx, "Page.setProduceCompilationCache", args, nil, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Page.setProduceCompilationCache", nil, nil, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Page", Op: "SetProduceCompilationCache", Err: err}
	}
	return
}
func (d *domainClient) AddCompilationCache(ctx context.Context, args *AddCompilationCacheArgs) (err error) {
	if args != nil {
		err = rpcc.Invoke(ctx, "Page.addCompilationCache", args, nil, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Page.addCompilationCache", nil, nil, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Page", Op: "AddCompilationCache", Err: err}
	}
	return
}
func (d *domainClient) ClearCompilationCache(ctx context.Context) (err error) {
	err = rpcc.Invoke(ctx, "Page.clearCompilationCache", nil, nil, d.conn)
	if err != nil {
		err = &internal.OpError{Domain: "Page", Op: "ClearCompilationCache", Err: err}
	}
	return
}
func (d *domainClient) GenerateTestReport(ctx context.Context, args *GenerateTestReportArgs) (err error) {
	if args != nil {
		err = rpcc.Invoke(ctx, "Page.generateTestReport", args, nil, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Page.generateTestReport", nil, nil, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Page", Op: "GenerateTestReport", Err: err}
	}
	return
}
func (d *domainClient) WaitForDebugger(ctx context.Context) (err error) {
	err = rpcc.Invoke(ctx, "Page.waitForDebugger", nil, nil, d.conn)
	if err != nil {
		err = &internal.OpError{Domain: "Page", Op: "WaitForDebugger", Err: err}
	}
	return
}
func (d *domainClient) SetInterceptFileChooserDialog(ctx context.Context, args *SetInterceptFileChooserDialogArgs) (err error) {
	if args != nil {
		err = rpcc.Invoke(ctx, "Page.setInterceptFileChooserDialog", args, nil, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Page.setInterceptFileChooserDialog", nil, nil, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Page", Op: "SetInterceptFileChooserDialog", Err: err}
	}
	return
}