// Code generated by easyjson for marshaling/unmarshaling. DO NOT EDIT.

package page

import (
	json "encoding/json"
	cdp "github.com/chromedp/cdproto/cdp"
	debugger "github.com/chromedp/cdproto/debugger"
	dom "github.com/chromedp/cdproto/dom"
	io "github.com/chromedp/cdproto/io"
	runtime "github.com/chromedp/cdproto/runtime"
	easyjson "github.com/mailru/easyjson"
	jlexer "github.com/mailru/easyjson/jlexer"
	jwriter "github.com/mailru/easyjson/jwriter"
)

// suppress unused package warning
var (
	_ *json.RawMessage
	_ *jlexer.Lexer
	_ *jwriter.Writer
	_ easyjson.Marshaler
)

func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage(in *jlexer.Lexer, out *WaitForDebuggerParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage(out *jwriter.Writer, in WaitForDebuggerParams) {
	out.RawByte('{')
	first := true
	_ = first
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v WaitForDebuggerParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v WaitForDebuggerParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *WaitForDebuggerParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *WaitForDebuggerParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage1(in *jlexer.Lexer, out *VisualViewport) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "offsetX":
			out.OffsetX = float64(in.Float64())
		case "offsetY":
			out.OffsetY = float64(in.Float64())
		case "pageX":
			out.PageX = float64(in.Float64())
		case "pageY":
			out.PageY = float64(in.Float64())
		case "clientWidth":
			out.ClientWidth = float64(in.Float64())
		case "clientHeight":
			out.ClientHeight = float64(in.Float64())
		case "scale":
			out.Scale = float64(in.Float64())
		case "zoom":
			out.Zoom = float64(in.Float64())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage1(out *jwriter.Writer, in VisualViewport) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"offsetX\":"
		out.RawString(prefix[1:])
		out.Float64(float64(in.OffsetX))
	}
	{
		const prefix string = ",\"offsetY\":"
		out.RawString(prefix)
		out.Float64(float64(in.OffsetY))
	}
	{
		const prefix string = ",\"pageX\":"
		out.RawString(prefix)
		out.Float64(float64(in.PageX))
	}
	{
		const prefix string = ",\"pageY\":"
		out.RawString(prefix)
		out.Float64(float64(in.PageY))
	}
	{
		const prefix string = ",\"clientWidth\":"
		out.RawString(prefix)
		out.Float64(float64(in.ClientWidth))
	}
	{
		const prefix string = ",\"clientHeight\":"
		out.RawString(prefix)
		out.Float64(float64(in.ClientHeight))
	}
	{
		const prefix string = ",\"scale\":"
		out.RawString(prefix)
		out.Float64(float64(in.Scale))
	}
	if in.Zoom != 0 {
		const prefix string = ",\"zoom\":"
		out.RawString(prefix)
		out.Float64(float64(in.Zoom))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v VisualViewport) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage1(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v VisualViewport) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage1(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *VisualViewport) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage1(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *VisualViewport) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage1(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage2(in *jlexer.Lexer, out *Viewport) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "x":
			out.X = float64(in.Float64())
		case "y":
			out.Y = float64(in.Float64())
		case "width":
			out.Width = float64(in.Float64())
		case "height":
			out.Height = float64(in.Float64())
		case "scale":
			out.Scale = float64(in.Float64())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage2(out *jwriter.Writer, in Viewport) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"x\":"
		out.RawString(prefix[1:])
		out.Float64(float64(in.X))
	}
	{
		const prefix string = ",\"y\":"
		out.RawString(prefix)
		out.Float64(float64(in.Y))
	}
	{
		const prefix string = ",\"width\":"
		out.RawString(prefix)
		out.Float64(float64(in.Width))
	}
	{
		const prefix string = ",\"height\":"
		out.RawString(prefix)
		out.Float64(float64(in.Height))
	}
	{
		const prefix string = ",\"scale\":"
		out.RawString(prefix)
		out.Float64(float64(in.Scale))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v Viewport) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage2(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v Viewport) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage2(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *Viewport) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage2(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *Viewport) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage2(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage3(in *jlexer.Lexer, out *StopScreencastParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage3(out *jwriter.Writer, in StopScreencastParams) {
	out.RawByte('{')
	first := true
	_ = first
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v StopScreencastParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage3(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v StopScreencastParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage3(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *StopScreencastParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage3(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *StopScreencastParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage3(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage4(in *jlexer.Lexer, out *StopLoadingParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage4(out *jwriter.Writer, in StopLoadingParams) {
	out.RawByte('{')
	first := true
	_ = first
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v StopLoadingParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage4(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v StopLoadingParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage4(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *StopLoadingParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage4(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *StopLoadingParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage4(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage5(in *jlexer.Lexer, out *StartScreencastParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "format":
			(out.Format).UnmarshalEasyJSON(in)
		case "quality":
			out.Quality = int64(in.Int64())
		case "maxWidth":
			out.MaxWidth = int64(in.Int64())
		case "maxHeight":
			out.MaxHeight = int64(in.Int64())
		case "everyNthFrame":
			out.EveryNthFrame = int64(in.Int64())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage5(out *jwriter.Writer, in StartScreencastParams) {
	out.RawByte('{')
	first := true
	_ = first
	if in.Format != "" {
		const prefix string = ",\"format\":"
		first = false
		out.RawString(prefix[1:])
		(in.Format).MarshalEasyJSON(out)
	}
	if in.Quality != 0 {
		const prefix string = ",\"quality\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.Int64(int64(in.Quality))
	}
	if in.MaxWidth != 0 {
		const prefix string = ",\"maxWidth\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.Int64(int64(in.MaxWidth))
	}
	if in.MaxHeight != 0 {
		const prefix string = ",\"maxHeight\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.Int64(int64(in.MaxHeight))
	}
	if in.EveryNthFrame != 0 {
		const prefix string = ",\"everyNthFrame\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.Int64(int64(in.EveryNthFrame))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v StartScreencastParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage5(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v StartScreencastParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage5(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *StartScreencastParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage5(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *StartScreencastParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage5(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage6(in *jlexer.Lexer, out *SetWebLifecycleStateParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "state":
			(out.State).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage6(out *jwriter.Writer, in SetWebLifecycleStateParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"state\":"
		out.RawString(prefix[1:])
		(in.State).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v SetWebLifecycleStateParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage6(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v SetWebLifecycleStateParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage6(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *SetWebLifecycleStateParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage6(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetWebLifecycleStateParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage6(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage7(in *jlexer.Lexer, out *SetSPCTransactionModeParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "mode":
			(out.Mode).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage7(out *jwriter.Writer, in SetSPCTransactionModeParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"mode\":"
		out.RawString(prefix[1:])
		(in.Mode).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v SetSPCTransactionModeParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage7(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v SetSPCTransactionModeParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage7(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *SetSPCTransactionModeParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage7(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetSPCTransactionModeParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage7(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage8(in *jlexer.Lexer, out *SetRPHRegistrationModeParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "mode":
			(out.Mode).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage8(out *jwriter.Writer, in SetRPHRegistrationModeParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"mode\":"
		out.RawString(prefix[1:])
		(in.Mode).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v SetRPHRegistrationModeParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage8(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v SetRPHRegistrationModeParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage8(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *SetRPHRegistrationModeParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage8(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetRPHRegistrationModeParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage8(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage9(in *jlexer.Lexer, out *SetPrerenderingAllowedParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "isAllowed":
			out.IsAllowed = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage9(out *jwriter.Writer, in SetPrerenderingAllowedParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"isAllowed\":"
		out.RawString(prefix[1:])
		out.Bool(bool(in.IsAllowed))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v SetPrerenderingAllowedParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage9(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v SetPrerenderingAllowedParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage9(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *SetPrerenderingAllowedParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage9(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetPrerenderingAllowedParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage9(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage10(in *jlexer.Lexer, out *SetLifecycleEventsEnabledParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "enabled":
			out.Enabled = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage10(out *jwriter.Writer, in SetLifecycleEventsEnabledParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"enabled\":"
		out.RawString(prefix[1:])
		out.Bool(bool(in.Enabled))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v SetLifecycleEventsEnabledParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage10(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v SetLifecycleEventsEnabledParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage10(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *SetLifecycleEventsEnabledParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage10(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetLifecycleEventsEnabledParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage10(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage11(in *jlexer.Lexer, out *SetInterceptFileChooserDialogParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "enabled":
			out.Enabled = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage11(out *jwriter.Writer, in SetInterceptFileChooserDialogParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"enabled\":"
		out.RawString(prefix[1:])
		out.Bool(bool(in.Enabled))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v SetInterceptFileChooserDialogParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage11(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v SetInterceptFileChooserDialogParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage11(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *SetInterceptFileChooserDialogParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage11(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetInterceptFileChooserDialogParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage11(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage12(in *jlexer.Lexer, out *SetFontSizesParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "fontSizes":
			if in.IsNull() {
				in.Skip()
				out.FontSizes = nil
			} else {
				if out.FontSizes == nil {
					out.FontSizes = new(FontSizes)
				}
				(*out.FontSizes).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage12(out *jwriter.Writer, in SetFontSizesParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"fontSizes\":"
		out.RawString(prefix[1:])
		if in.FontSizes == nil {
			out.RawString("null")
		} else {
			(*in.FontSizes).MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v SetFontSizesParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage12(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v SetFontSizesParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage12(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *SetFontSizesParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage12(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetFontSizesParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage12(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage13(in *jlexer.Lexer, out *SetFontFamiliesParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "fontFamilies":
			if in.IsNull() {
				in.Skip()
				out.FontFamilies = nil
			} else {
				if out.FontFamilies == nil {
					out.FontFamilies = new(FontFamilies)
				}
				(*out.FontFamilies).UnmarshalEasyJSON(in)
			}
		case "forScripts":
			if in.IsNull() {
				in.Skip()
				out.ForScripts = nil
			} else {
				in.Delim('[')
				if out.ForScripts == nil {
					if !in.IsDelim(']') {
						out.ForScripts = make([]*ScriptFontFamilies, 0, 8)
					} else {
						out.ForScripts = []*ScriptFontFamilies{}
					}
				} else {
					out.ForScripts = (out.ForScripts)[:0]
				}
				for !in.IsDelim(']') {
					var v1 *ScriptFontFamilies
					if in.IsNull() {
						in.Skip()
						v1 = nil
					} else {
						if v1 == nil {
							v1 = new(ScriptFontFamilies)
						}
						(*v1).UnmarshalEasyJSON(in)
					}
					out.ForScripts = append(out.ForScripts, v1)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage13(out *jwriter.Writer, in SetFontFamiliesParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"fontFamilies\":"
		out.RawString(prefix[1:])
		if in.FontFamilies == nil {
			out.RawString("null")
		} else {
			(*in.FontFamilies).MarshalEasyJSON(out)
		}
	}
	if len(in.ForScripts) != 0 {
		const prefix string = ",\"forScripts\":"
		out.RawString(prefix)
		{
			out.RawByte('[')
			for v2, v3 := range in.ForScripts {
				if v2 > 0 {
					out.RawByte(',')
				}
				if v3 == nil {
					out.RawString("null")
				} else {
					(*v3).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v SetFontFamiliesParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage13(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v SetFontFamiliesParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage13(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *SetFontFamiliesParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage13(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetFontFamiliesParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage13(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage14(in *jlexer.Lexer, out *SetDocumentContentParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "frameId":
			(out.FrameID).UnmarshalEasyJSON(in)
		case "html":
			out.HTML = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage14(out *jwriter.Writer, in SetDocumentContentParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"frameId\":"
		out.RawString(prefix[1:])
		out.String(string(in.FrameID))
	}
	{
		const prefix string = ",\"html\":"
		out.RawString(prefix)
		out.String(string(in.HTML))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v SetDocumentContentParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage14(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v SetDocumentContentParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage14(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *SetDocumentContentParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage14(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetDocumentContentParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage14(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage15(in *jlexer.Lexer, out *SetBypassCSPParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "enabled":
			out.Enabled = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage15(out *jwriter.Writer, in SetBypassCSPParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"enabled\":"
		out.RawString(prefix[1:])
		out.Bool(bool(in.Enabled))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v SetBypassCSPParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage15(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v SetBypassCSPParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage15(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *SetBypassCSPParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage15(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetBypassCSPParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage15(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage16(in *jlexer.Lexer, out *SetAdBlockingEnabledParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "enabled":
			out.Enabled = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage16(out *jwriter.Writer, in SetAdBlockingEnabledParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"enabled\":"
		out.RawString(prefix[1:])
		out.Bool(bool(in.Enabled))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v SetAdBlockingEnabledParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage16(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v SetAdBlockingEnabledParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage16(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *SetAdBlockingEnabledParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage16(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetAdBlockingEnabledParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage16(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage17(in *jlexer.Lexer, out *SearchInResourceReturns) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "result":
			if in.IsNull() {
				in.Skip()
				out.Result = nil
			} else {
				in.Delim('[')
				if out.Result == nil {
					if !in.IsDelim(']') {
						out.Result = make([]*debugger.SearchMatch, 0, 8)
					} else {
						out.Result = []*debugger.SearchMatch{}
					}
				} else {
					out.Result = (out.Result)[:0]
				}
				for !in.IsDelim(']') {
					var v4 *debugger.SearchMatch
					if in.IsNull() {
						in.Skip()
						v4 = nil
					} else {
						if v4 == nil {
							v4 = new(debugger.SearchMatch)
						}
						(*v4).UnmarshalEasyJSON(in)
					}
					out.Result = append(out.Result, v4)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage17(out *jwriter.Writer, in SearchInResourceReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if len(in.Result) != 0 {
		const prefix string = ",\"result\":"
		first = false
		out.RawString(prefix[1:])
		{
			out.RawByte('[')
			for v5, v6 := range in.Result {
				if v5 > 0 {
					out.RawByte(',')
				}
				if v6 == nil {
					out.RawString("null")
				} else {
					(*v6).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v SearchInResourceReturns) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage17(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v SearchInResourceReturns) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage17(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *SearchInResourceReturns) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage17(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SearchInResourceReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage17(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage18(in *jlexer.Lexer, out *SearchInResourceParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "frameId":
			(out.FrameID).UnmarshalEasyJSON(in)
		case "url":
			out.URL = string(in.String())
		case "query":
			out.Query = string(in.String())
		case "caseSensitive":
			out.CaseSensitive = bool(in.Bool())
		case "isRegex":
			out.IsRegex = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage18(out *jwriter.Writer, in SearchInResourceParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"frameId\":"
		out.RawString(prefix[1:])
		out.String(string(in.FrameID))
	}
	{
		const prefix string = ",\"url\":"
		out.RawString(prefix)
		out.String(string(in.URL))
	}
	{
		const prefix string = ",\"query\":"
		out.RawString(prefix)
		out.String(string(in.Query))
	}
	if in.CaseSensitive {
		const prefix string = ",\"caseSensitive\":"
		out.RawString(prefix)
		out.Bool(bool(in.CaseSensitive))
	}
	if in.IsRegex {
		const prefix string = ",\"isRegex\":"
		out.RawString(prefix)
		out.Bool(bool(in.IsRegex))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v SearchInResourceParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage18(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v SearchInResourceParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage18(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *SearchInResourceParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage18(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SearchInResourceParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage18(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage19(in *jlexer.Lexer, out *ScriptFontFamilies) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "script":
			out.Script = string(in.String())
		case "fontFamilies":
			if in.IsNull() {
				in.Skip()
				out.FontFamilies = nil
			} else {
				if out.FontFamilies == nil {
					out.FontFamilies = new(FontFamilies)
				}
				(*out.FontFamilies).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage19(out *jwriter.Writer, in ScriptFontFamilies) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"script\":"
		out.RawString(prefix[1:])
		out.String(string(in.Script))
	}
	{
		const prefix string = ",\"fontFamilies\":"
		out.RawString(prefix)
		if in.FontFamilies == nil {
			out.RawString("null")
		} else {
			(*in.FontFamilies).MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v ScriptFontFamilies) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage19(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v ScriptFontFamilies) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage19(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *ScriptFontFamilies) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage19(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *ScriptFontFamilies) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage19(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage20(in *jlexer.Lexer, out *ScreencastFrameMetadata) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "offsetTop":
			out.OffsetTop = float64(in.Float64())
		case "pageScaleFactor":
			out.PageScaleFactor = float64(in.Float64())
		case "deviceWidth":
			out.DeviceWidth = float64(in.Float64())
		case "deviceHeight":
			out.DeviceHeight = float64(in.Float64())
		case "scrollOffsetX":
			out.ScrollOffsetX = float64(in.Float64())
		case "scrollOffsetY":
			out.ScrollOffsetY = float64(in.Float64())
		case "timestamp":
			if in.IsNull() {
				in.Skip()
				out.Timestamp = nil
			} else {
				if out.Timestamp == nil {
					out.Timestamp = new(cdp.TimeSinceEpoch)
				}
				(*out.Timestamp).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage20(out *jwriter.Writer, in ScreencastFrameMetadata) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"offsetTop\":"
		out.RawString(prefix[1:])
		out.Float64(float64(in.OffsetTop))
	}
	{
		const prefix string = ",\"pageScaleFactor\":"
		out.RawString(prefix)
		out.Float64(float64(in.PageScaleFactor))
	}
	{
		const prefix string = ",\"deviceWidth\":"
		out.RawString(prefix)
		out.Float64(float64(in.DeviceWidth))
	}
	{
		const prefix string = ",\"deviceHeight\":"
		out.RawString(prefix)
		out.Float64(float64(in.DeviceHeight))
	}
	{
		const prefix string = ",\"scrollOffsetX\":"
		out.RawString(prefix)
		out.Float64(float64(in.ScrollOffsetX))
	}
	{
		const prefix string = ",\"scrollOffsetY\":"
		out.RawString(prefix)
		out.Float64(float64(in.ScrollOffsetY))
	}
	if in.Timestamp != nil {
		const prefix string = ",\"timestamp\":"
		out.RawString(prefix)
		(*in.Timestamp).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v ScreencastFrameMetadata) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage20(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v ScreencastFrameMetadata) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage20(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *ScreencastFrameMetadata) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage20(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *ScreencastFrameMetadata) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage20(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage21(in *jlexer.Lexer, out *ScreencastFrameAckParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "sessionId":
			out.SessionID = int64(in.Int64())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage21(out *jwriter.Writer, in ScreencastFrameAckParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"sessionId\":"
		out.RawString(prefix[1:])
		out.Int64(int64(in.SessionID))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v ScreencastFrameAckParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage21(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v ScreencastFrameAckParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage21(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *ScreencastFrameAckParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage21(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *ScreencastFrameAckParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage21(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage22(in *jlexer.Lexer, out *ResetNavigationHistoryParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage22(out *jwriter.Writer, in ResetNavigationHistoryParams) {
	out.RawByte('{')
	first := true
	_ = first
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v ResetNavigationHistoryParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage22(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v ResetNavigationHistoryParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage22(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *ResetNavigationHistoryParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage22(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *ResetNavigationHistoryParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage22(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage23(in *jlexer.Lexer, out *RemoveScriptToEvaluateOnNewDocumentParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "identifier":
			out.Identifier = ScriptIdentifier(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage23(out *jwriter.Writer, in RemoveScriptToEvaluateOnNewDocumentParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"identifier\":"
		out.RawString(prefix[1:])
		out.String(string(in.Identifier))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v RemoveScriptToEvaluateOnNewDocumentParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage23(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v RemoveScriptToEvaluateOnNewDocumentParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage23(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *RemoveScriptToEvaluateOnNewDocumentParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage23(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *RemoveScriptToEvaluateOnNewDocumentParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage23(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage24(in *jlexer.Lexer, out *ReloadParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "ignoreCache":
			out.IgnoreCache = bool(in.Bool())
		case "scriptToEvaluateOnLoad":
			out.ScriptToEvaluateOnLoad = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage24(out *jwriter.Writer, in ReloadParams) {
	out.RawByte('{')
	first := true
	_ = first
	if in.IgnoreCache {
		const prefix string = ",\"ignoreCache\":"
		first = false
		out.RawString(prefix[1:])
		out.Bool(bool(in.IgnoreCache))
	}
	if in.ScriptToEvaluateOnLoad != "" {
		const prefix string = ",\"scriptToEvaluateOnLoad\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.String(string(in.ScriptToEvaluateOnLoad))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v ReloadParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage24(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v ReloadParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage24(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *ReloadParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage24(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *ReloadParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage24(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage25(in *jlexer.Lexer, out *ProduceCompilationCacheParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "scripts":
			if in.IsNull() {
				in.Skip()
				out.Scripts = nil
			} else {
				in.Delim('[')
				if out.Scripts == nil {
					if !in.IsDelim(']') {
						out.Scripts = make([]*CompilationCacheParams, 0, 8)
					} else {
						out.Scripts = []*CompilationCacheParams{}
					}
				} else {
					out.Scripts = (out.Scripts)[:0]
				}
				for !in.IsDelim(']') {
					var v7 *CompilationCacheParams
					if in.IsNull() {
						in.Skip()
						v7 = nil
					} else {
						if v7 == nil {
							v7 = new(CompilationCacheParams)
						}
						(*v7).UnmarshalEasyJSON(in)
					}
					out.Scripts = append(out.Scripts, v7)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage25(out *jwriter.Writer, in ProduceCompilationCacheParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"scripts\":"
		out.RawString(prefix[1:])
		if in.Scripts == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v8, v9 := range in.Scripts {
				if v8 > 0 {
					out.RawByte(',')
				}
				if v9 == nil {
					out.RawString("null")
				} else {
					(*v9).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v ProduceCompilationCacheParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage25(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v ProduceCompilationCacheParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage25(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *ProduceCompilationCacheParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage25(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *ProduceCompilationCacheParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage25(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage26(in *jlexer.Lexer, out *PrintToPDFReturns) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "data":
			out.Data = string(in.String())
		case "stream":
			out.Stream = io.StreamHandle(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage26(out *jwriter.Writer, in PrintToPDFReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if in.Data != "" {
		const prefix string = ",\"data\":"
		first = false
		out.RawString(prefix[1:])
		out.String(string(in.Data))
	}
	if in.Stream != "" {
		const prefix string = ",\"stream\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.String(string(in.Stream))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v PrintToPDFReturns) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage26(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v PrintToPDFReturns) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage26(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *PrintToPDFReturns) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage26(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *PrintToPDFReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage26(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage27(in *jlexer.Lexer, out *PrintToPDFParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "landscape":
			out.Landscape = bool(in.Bool())
		case "displayHeaderFooter":
			out.DisplayHeaderFooter = bool(in.Bool())
		case "printBackground":
			out.PrintBackground = bool(in.Bool())
		case "scale":
			out.Scale = float64(in.Float64())
		case "paperWidth":
			out.PaperWidth = float64(in.Float64())
		case "paperHeight":
			out.PaperHeight = float64(in.Float64())
		case "marginTop":
			out.MarginTop = float64(in.Float64())
		case "marginBottom":
			out.MarginBottom = float64(in.Float64())
		case "marginLeft":
			out.MarginLeft = float64(in.Float64())
		case "marginRight":
			out.MarginRight = float64(in.Float64())
		case "pageRanges":
			out.PageRanges = string(in.String())
		case "headerTemplate":
			out.HeaderTemplate = string(in.String())
		case "footerTemplate":
			out.FooterTemplate = string(in.String())
		case "preferCSSPageSize":
			out.PreferCSSPageSize = bool(in.Bool())
		case "transferMode":
			(out.TransferMode).UnmarshalEasyJSON(in)
		case "generateTaggedPDF":
			out.GenerateTaggedPDF = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage27(out *jwriter.Writer, in PrintToPDFParams) {
	out.RawByte('{')
	first := true
	_ = first
	if in.Landscape {
		const prefix string = ",\"landscape\":"
		first = false
		out.RawString(prefix[1:])
		out.Bool(bool(in.Landscape))
	}
	if in.DisplayHeaderFooter {
		const prefix string = ",\"displayHeaderFooter\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.Bool(bool(in.DisplayHeaderFooter))
	}
	if in.PrintBackground {
		const prefix string = ",\"printBackground\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.Bool(bool(in.PrintBackground))
	}
	if in.Scale != 0 {
		const prefix string = ",\"scale\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.Float64(float64(in.Scale))
	}
	if in.PaperWidth != 0 {
		const prefix string = ",\"paperWidth\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.Float64(float64(in.PaperWidth))
	}
	if in.PaperHeight != 0 {
		const prefix string = ",\"paperHeight\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.Float64(float64(in.PaperHeight))
	}
	{
		const prefix string = ",\"marginTop\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.Float64(float64(in.MarginTop))
	}
	{
		const prefix string = ",\"marginBottom\":"
		out.RawString(prefix)
		out.Float64(float64(in.MarginBottom))
	}
	{
		const prefix string = ",\"marginLeft\":"
		out.RawString(prefix)
		out.Float64(float64(in.MarginLeft))
	}
	{
		const prefix string = ",\"marginRight\":"
		out.RawString(prefix)
		out.Float64(float64(in.MarginRight))
	}
	if in.PageRanges != "" {
		const prefix string = ",\"pageRanges\":"
		out.RawString(prefix)
		out.String(string(in.PageRanges))
	}
	if in.HeaderTemplate != "" {
		const prefix string = ",\"headerTemplate\":"
		out.RawString(prefix)
		out.String(string(in.HeaderTemplate))
	}
	if in.FooterTemplate != "" {
		const prefix string = ",\"footerTemplate\":"
		out.RawString(prefix)
		out.String(string(in.FooterTemplate))
	}
	if in.PreferCSSPageSize {
		const prefix string = ",\"preferCSSPageSize\":"
		out.RawString(prefix)
		out.Bool(bool(in.PreferCSSPageSize))
	}
	if in.TransferMode != "" {
		const prefix string = ",\"transferMode\":"
		out.RawString(prefix)
		(in.TransferMode).MarshalEasyJSON(out)
	}
	if in.GenerateTaggedPDF {
		const prefix string = ",\"generateTaggedPDF\":"
		out.RawString(prefix)
		out.Bool(bool(in.GenerateTaggedPDF))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v PrintToPDFParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage27(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v PrintToPDFParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage27(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *PrintToPDFParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage27(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *PrintToPDFParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage27(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage28(in *jlexer.Lexer, out *PermissionsPolicyFeatureState) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "feature":
			(out.Feature).UnmarshalEasyJSON(in)
		case "allowed":
			out.Allowed = bool(in.Bool())
		case "locator":
			if in.IsNull() {
				in.Skip()
				out.Locator = nil
			} else {
				if out.Locator == nil {
					out.Locator = new(PermissionsPolicyBlockLocator)
				}
				(*out.Locator).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage28(out *jwriter.Writer, in PermissionsPolicyFeatureState) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"feature\":"
		out.RawString(prefix[1:])
		(in.Feature).MarshalEasyJSON(out)
	}
	{
		const prefix string = ",\"allowed\":"
		out.RawString(prefix)
		out.Bool(bool(in.Allowed))
	}
	if in.Locator != nil {
		const prefix string = ",\"locator\":"
		out.RawString(prefix)
		(*in.Locator).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v PermissionsPolicyFeatureState) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage28(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v PermissionsPolicyFeatureState) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage28(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *PermissionsPolicyFeatureState) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage28(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *PermissionsPolicyFeatureState) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage28(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage29(in *jlexer.Lexer, out *PermissionsPolicyBlockLocator) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "frameId":
			(out.FrameID).UnmarshalEasyJSON(in)
		case "blockReason":
			(out.BlockReason).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage29(out *jwriter.Writer, in PermissionsPolicyBlockLocator) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"frameId\":"
		out.RawString(prefix[1:])
		out.String(string(in.FrameID))
	}
	{
		const prefix string = ",\"blockReason\":"
		out.RawString(prefix)
		(in.BlockReason).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v PermissionsPolicyBlockLocator) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage29(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v PermissionsPolicyBlockLocator) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage29(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *PermissionsPolicyBlockLocator) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage29(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *PermissionsPolicyBlockLocator) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage29(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage30(in *jlexer.Lexer, out *NavigationEntry) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "id":
			out.ID = int64(in.Int64())
		case "url":
			out.URL = string(in.String())
		case "userTypedURL":
			out.UserTypedURL = string(in.String())
		case "title":
			out.Title = string(in.String())
		case "transitionType":
			(out.TransitionType).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage30(out *jwriter.Writer, in NavigationEntry) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"id\":"
		out.RawString(prefix[1:])
		out.Int64(int64(in.ID))
	}
	{
		const prefix string = ",\"url\":"
		out.RawString(prefix)
		out.String(string(in.URL))
	}
	{
		const prefix string = ",\"userTypedURL\":"
		out.RawString(prefix)
		out.String(string(in.UserTypedURL))
	}
	{
		const prefix string = ",\"title\":"
		out.RawString(prefix)
		out.String(string(in.Title))
	}
	{
		const prefix string = ",\"transitionType\":"
		out.RawString(prefix)
		(in.TransitionType).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v NavigationEntry) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage30(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v NavigationEntry) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage30(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *NavigationEntry) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage30(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *NavigationEntry) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage30(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage31(in *jlexer.Lexer, out *NavigateToHistoryEntryParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "entryId":
			out.EntryID = int64(in.Int64())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage31(out *jwriter.Writer, in NavigateToHistoryEntryParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"entryId\":"
		out.RawString(prefix[1:])
		out.Int64(int64(in.EntryID))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v NavigateToHistoryEntryParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage31(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v NavigateToHistoryEntryParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage31(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *NavigateToHistoryEntryParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage31(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *NavigateToHistoryEntryParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage31(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage32(in *jlexer.Lexer, out *NavigateReturns) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "frameId":
			(out.FrameID).UnmarshalEasyJSON(in)
		case "loaderId":
			out.LoaderID = cdp.LoaderID(in.String())
		case "errorText":
			out.ErrorText = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage32(out *jwriter.Writer, in NavigateReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if in.FrameID != "" {
		const prefix string = ",\"frameId\":"
		first = false
		out.RawString(prefix[1:])
		out.String(string(in.FrameID))
	}
	if in.LoaderID != "" {
		const prefix string = ",\"loaderId\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.String(string(in.LoaderID))
	}
	if in.ErrorText != "" {
		const prefix string = ",\"errorText\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.String(string(in.ErrorText))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v NavigateReturns) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage32(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v NavigateReturns) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage32(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *NavigateReturns) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage32(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *NavigateReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage32(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage33(in *jlexer.Lexer, out *NavigateParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "url":
			out.URL = string(in.String())
		case "referrer":
			out.Referrer = string(in.String())
		case "transitionType":
			(out.TransitionType).UnmarshalEasyJSON(in)
		case "frameId":
			(out.FrameID).UnmarshalEasyJSON(in)
		case "referrerPolicy":
			(out.ReferrerPolicy).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage33(out *jwriter.Writer, in NavigateParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"url\":"
		out.RawString(prefix[1:])
		out.String(string(in.URL))
	}
	if in.Referrer != "" {
		const prefix string = ",\"referrer\":"
		out.RawString(prefix)
		out.String(string(in.Referrer))
	}
	if in.TransitionType != "" {
		const prefix string = ",\"transitionType\":"
		out.RawString(prefix)
		(in.TransitionType).MarshalEasyJSON(out)
	}
	if in.FrameID != "" {
		const prefix string = ",\"frameId\":"
		out.RawString(prefix)
		out.String(string(in.FrameID))
	}
	if in.ReferrerPolicy != "" {
		const prefix string = ",\"referrerPolicy\":"
		out.RawString(prefix)
		(in.ReferrerPolicy).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v NavigateParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage33(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v NavigateParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage33(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *NavigateParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage33(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *NavigateParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage33(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage34(in *jlexer.Lexer, out *LayoutViewport) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "pageX":
			out.PageX = int64(in.Int64())
		case "pageY":
			out.PageY = int64(in.Int64())
		case "clientWidth":
			out.ClientWidth = int64(in.Int64())
		case "clientHeight":
			out.ClientHeight = int64(in.Int64())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage34(out *jwriter.Writer, in LayoutViewport) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"pageX\":"
		out.RawString(prefix[1:])
		out.Int64(int64(in.PageX))
	}
	{
		const prefix string = ",\"pageY\":"
		out.RawString(prefix)
		out.Int64(int64(in.PageY))
	}
	{
		const prefix string = ",\"clientWidth\":"
		out.RawString(prefix)
		out.Int64(int64(in.ClientWidth))
	}
	{
		const prefix string = ",\"clientHeight\":"
		out.RawString(prefix)
		out.Int64(int64(in.ClientHeight))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v LayoutViewport) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage34(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v LayoutViewport) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage34(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *LayoutViewport) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage34(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *LayoutViewport) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage34(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage35(in *jlexer.Lexer, out *InstallabilityErrorArgument) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "name":
			out.Name = string(in.String())
		case "value":
			out.Value = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage35(out *jwriter.Writer, in InstallabilityErrorArgument) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"name\":"
		out.RawString(prefix[1:])
		out.String(string(in.Name))
	}
	{
		const prefix string = ",\"value\":"
		out.RawString(prefix)
		out.String(string(in.Value))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v InstallabilityErrorArgument) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage35(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v InstallabilityErrorArgument) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage35(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *InstallabilityErrorArgument) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage35(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *InstallabilityErrorArgument) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage35(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage36(in *jlexer.Lexer, out *InstallabilityError) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "errorId":
			out.ErrorID = string(in.String())
		case "errorArguments":
			if in.IsNull() {
				in.Skip()
				out.ErrorArguments = nil
			} else {
				in.Delim('[')
				if out.ErrorArguments == nil {
					if !in.IsDelim(']') {
						out.ErrorArguments = make([]*InstallabilityErrorArgument, 0, 8)
					} else {
						out.ErrorArguments = []*InstallabilityErrorArgument{}
					}
				} else {
					out.ErrorArguments = (out.ErrorArguments)[:0]
				}
				for !in.IsDelim(']') {
					var v10 *InstallabilityErrorArgument
					if in.IsNull() {
						in.Skip()
						v10 = nil
					} else {
						if v10 == nil {
							v10 = new(InstallabilityErrorArgument)
						}
						(*v10).UnmarshalEasyJSON(in)
					}
					out.ErrorArguments = append(out.ErrorArguments, v10)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage36(out *jwriter.Writer, in InstallabilityError) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"errorId\":"
		out.RawString(prefix[1:])
		out.String(string(in.ErrorID))
	}
	{
		const prefix string = ",\"errorArguments\":"
		out.RawString(prefix)
		if in.ErrorArguments == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v11, v12 := range in.ErrorArguments {
				if v11 > 0 {
					out.RawByte(',')
				}
				if v12 == nil {
					out.RawString("null")
				} else {
					(*v12).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v InstallabilityError) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage36(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v InstallabilityError) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage36(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *InstallabilityError) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage36(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *InstallabilityError) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage36(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage37(in *jlexer.Lexer, out *HandleJavaScriptDialogParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "accept":
			out.Accept = bool(in.Bool())
		case "promptText":
			out.PromptText = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage37(out *jwriter.Writer, in HandleJavaScriptDialogParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"accept\":"
		out.RawString(prefix[1:])
		out.Bool(bool(in.Accept))
	}
	if in.PromptText != "" {
		const prefix string = ",\"promptText\":"
		out.RawString(prefix)
		out.String(string(in.PromptText))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v HandleJavaScriptDialogParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage37(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v HandleJavaScriptDialogParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage37(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *HandleJavaScriptDialogParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage37(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *HandleJavaScriptDialogParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage37(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage38(in *jlexer.Lexer, out *GetResourceTreeReturns) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "frameTree":
			if in.IsNull() {
				in.Skip()
				out.FrameTree = nil
			} else {
				if out.FrameTree == nil {
					out.FrameTree = new(FrameResourceTree)
				}
				(*out.FrameTree).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage38(out *jwriter.Writer, in GetResourceTreeReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if in.FrameTree != nil {
		const prefix string = ",\"frameTree\":"
		first = false
		out.RawString(prefix[1:])
		(*in.FrameTree).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v GetResourceTreeReturns) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage38(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v GetResourceTreeReturns) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage38(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *GetResourceTreeReturns) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage38(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetResourceTreeReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage38(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage39(in *jlexer.Lexer, out *GetResourceTreeParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage39(out *jwriter.Writer, in GetResourceTreeParams) {
	out.RawByte('{')
	first := true
	_ = first
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v GetResourceTreeParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage39(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v GetResourceTreeParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage39(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *GetResourceTreeParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage39(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetResourceTreeParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage39(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage40(in *jlexer.Lexer, out *GetResourceContentReturns) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "content":
			out.Content = string(in.String())
		case "base64Encoded":
			out.Base64encoded = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage40(out *jwriter.Writer, in GetResourceContentReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if in.Content != "" {
		const prefix string = ",\"content\":"
		first = false
		out.RawString(prefix[1:])
		out.String(string(in.Content))
	}
	if in.Base64encoded {
		const prefix string = ",\"base64Encoded\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.Bool(bool(in.Base64encoded))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v GetResourceContentReturns) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage40(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v GetResourceContentReturns) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage40(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *GetResourceContentReturns) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage40(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetResourceContentReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage40(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage41(in *jlexer.Lexer, out *GetResourceContentParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "frameId":
			(out.FrameID).UnmarshalEasyJSON(in)
		case "url":
			out.URL = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage41(out *jwriter.Writer, in GetResourceContentParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"frameId\":"
		out.RawString(prefix[1:])
		out.String(string(in.FrameID))
	}
	{
		const prefix string = ",\"url\":"
		out.RawString(prefix)
		out.String(string(in.URL))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v GetResourceContentParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage41(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v GetResourceContentParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage41(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *GetResourceContentParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage41(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetResourceContentParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage41(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage42(in *jlexer.Lexer, out *GetPermissionsPolicyStateReturns) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "states":
			if in.IsNull() {
				in.Skip()
				out.States = nil
			} else {
				in.Delim('[')
				if out.States == nil {
					if !in.IsDelim(']') {
						out.States = make([]*PermissionsPolicyFeatureState, 0, 8)
					} else {
						out.States = []*PermissionsPolicyFeatureState{}
					}
				} else {
					out.States = (out.States)[:0]
				}
				for !in.IsDelim(']') {
					var v13 *PermissionsPolicyFeatureState
					if in.IsNull() {
						in.Skip()
						v13 = nil
					} else {
						if v13 == nil {
							v13 = new(PermissionsPolicyFeatureState)
						}
						(*v13).UnmarshalEasyJSON(in)
					}
					out.States = append(out.States, v13)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage42(out *jwriter.Writer, in GetPermissionsPolicyStateReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if len(in.States) != 0 {
		const prefix string = ",\"states\":"
		first = false
		out.RawString(prefix[1:])
		{
			out.RawByte('[')
			for v14, v15 := range in.States {
				if v14 > 0 {
					out.RawByte(',')
				}
				if v15 == nil {
					out.RawString("null")
				} else {
					(*v15).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v GetPermissionsPolicyStateReturns) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage42(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v GetPermissionsPolicyStateReturns) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage42(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *GetPermissionsPolicyStateReturns) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage42(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetPermissionsPolicyStateReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage42(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage43(in *jlexer.Lexer, out *GetPermissionsPolicyStateParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "frameId":
			(out.FrameID).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage43(out *jwriter.Writer, in GetPermissionsPolicyStateParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"frameId\":"
		out.RawString(prefix[1:])
		out.String(string(in.FrameID))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v GetPermissionsPolicyStateParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage43(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v GetPermissionsPolicyStateParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage43(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *GetPermissionsPolicyStateParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage43(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetPermissionsPolicyStateParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage43(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage44(in *jlexer.Lexer, out *GetOriginTrialsReturns) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "originTrials":
			if in.IsNull() {
				in.Skip()
				out.OriginTrials = nil
			} else {
				in.Delim('[')
				if out.OriginTrials == nil {
					if !in.IsDelim(']') {
						out.OriginTrials = make([]*cdp.OriginTrial, 0, 8)
					} else {
						out.OriginTrials = []*cdp.OriginTrial{}
					}
				} else {
					out.OriginTrials = (out.OriginTrials)[:0]
				}
				for !in.IsDelim(']') {
					var v16 *cdp.OriginTrial
					if in.IsNull() {
						in.Skip()
						v16 = nil
					} else {
						if v16 == nil {
							v16 = new(cdp.OriginTrial)
						}
						(*v16).UnmarshalEasyJSON(in)
					}
					out.OriginTrials = append(out.OriginTrials, v16)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage44(out *jwriter.Writer, in GetOriginTrialsReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if len(in.OriginTrials) != 0 {
		const prefix string = ",\"originTrials\":"
		first = false
		out.RawString(prefix[1:])
		{
			out.RawByte('[')
			for v17, v18 := range in.OriginTrials {
				if v17 > 0 {
					out.RawByte(',')
				}
				if v18 == nil {
					out.RawString("null")
				} else {
					(*v18).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v GetOriginTrialsReturns) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage44(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v GetOriginTrialsReturns) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage44(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *GetOriginTrialsReturns) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage44(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetOriginTrialsReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage44(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage45(in *jlexer.Lexer, out *GetOriginTrialsParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "frameId":
			(out.FrameID).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage45(out *jwriter.Writer, in GetOriginTrialsParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"frameId\":"
		out.RawString(prefix[1:])
		out.String(string(in.FrameID))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v GetOriginTrialsParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage45(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v GetOriginTrialsParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage45(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *GetOriginTrialsParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage45(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetOriginTrialsParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage45(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage46(in *jlexer.Lexer, out *GetNavigationHistoryReturns) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "currentIndex":
			out.CurrentIndex = int64(in.Int64())
		case "entries":
			if in.IsNull() {
				in.Skip()
				out.Entries = nil
			} else {
				in.Delim('[')
				if out.Entries == nil {
					if !in.IsDelim(']') {
						out.Entries = make([]*NavigationEntry, 0, 8)
					} else {
						out.Entries = []*NavigationEntry{}
					}
				} else {
					out.Entries = (out.Entries)[:0]
				}
				for !in.IsDelim(']') {
					var v19 *NavigationEntry
					if in.IsNull() {
						in.Skip()
						v19 = nil
					} else {
						if v19 == nil {
							v19 = new(NavigationEntry)
						}
						(*v19).UnmarshalEasyJSON(in)
					}
					out.Entries = append(out.Entries, v19)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage46(out *jwriter.Writer, in GetNavigationHistoryReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if in.CurrentIndex != 0 {
		const prefix string = ",\"currentIndex\":"
		first = false
		out.RawString(prefix[1:])
		out.Int64(int64(in.CurrentIndex))
	}
	if len(in.Entries) != 0 {
		const prefix string = ",\"entries\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		{
			out.RawByte('[')
			for v20, v21 := range in.Entries {
				if v20 > 0 {
					out.RawByte(',')
				}
				if v21 == nil {
					out.RawString("null")
				} else {
					(*v21).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v GetNavigationHistoryReturns) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage46(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v GetNavigationHistoryReturns) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage46(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *GetNavigationHistoryReturns) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage46(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetNavigationHistoryReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage46(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage47(in *jlexer.Lexer, out *GetNavigationHistoryParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage47(out *jwriter.Writer, in GetNavigationHistoryParams) {
	out.RawByte('{')
	first := true
	_ = first
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v GetNavigationHistoryParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage47(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v GetNavigationHistoryParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage47(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *GetNavigationHistoryParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage47(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetNavigationHistoryParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage47(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage48(in *jlexer.Lexer, out *GetLayoutMetricsReturns) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "layoutViewport":
			if in.IsNull() {
				in.Skip()
				out.LayoutViewport = nil
			} else {
				if out.LayoutViewport == nil {
					out.LayoutViewport = new(LayoutViewport)
				}
				(*out.LayoutViewport).UnmarshalEasyJSON(in)
			}
		case "visualViewport":
			if in.IsNull() {
				in.Skip()
				out.VisualViewport = nil
			} else {
				if out.VisualViewport == nil {
					out.VisualViewport = new(VisualViewport)
				}
				(*out.VisualViewport).UnmarshalEasyJSON(in)
			}
		case "contentSize":
			if in.IsNull() {
				in.Skip()
				out.ContentSize = nil
			} else {
				if out.ContentSize == nil {
					out.ContentSize = new(dom.Rect)
				}
				(*out.ContentSize).UnmarshalEasyJSON(in)
			}
		case "cssLayoutViewport":
			if in.IsNull() {
				in.Skip()
				out.CSSLayoutViewport = nil
			} else {
				if out.CSSLayoutViewport == nil {
					out.CSSLayoutViewport = new(LayoutViewport)
				}
				(*out.CSSLayoutViewport).UnmarshalEasyJSON(in)
			}
		case "cssVisualViewport":
			if in.IsNull() {
				in.Skip()
				out.CSSVisualViewport = nil
			} else {
				if out.CSSVisualViewport == nil {
					out.CSSVisualViewport = new(VisualViewport)
				}
				(*out.CSSVisualViewport).UnmarshalEasyJSON(in)
			}
		case "cssContentSize":
			if in.IsNull() {
				in.Skip()
				out.CSSContentSize = nil
			} else {
				if out.CSSContentSize == nil {
					out.CSSContentSize = new(dom.Rect)
				}
				(*out.CSSContentSize).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage48(out *jwriter.Writer, in GetLayoutMetricsReturns) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"layoutViewport\":"
		out.RawString(prefix[1:])
		if in.LayoutViewport == nil {
			out.RawString("null")
		} else {
			(*in.LayoutViewport).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"visualViewport\":"
		out.RawString(prefix)
		if in.VisualViewport == nil {
			out.RawString("null")
		} else {
			(*in.VisualViewport).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"contentSize\":"
		out.RawString(prefix)
		if in.ContentSize == nil {
			out.RawString("null")
		} else {
			(*in.ContentSize).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"cssLayoutViewport\":"
		out.RawString(prefix)
		if in.CSSLayoutViewport == nil {
			out.RawString("null")
		} else {
			(*in.CSSLayoutViewport).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"cssVisualViewport\":"
		out.RawString(prefix)
		if in.CSSVisualViewport == nil {
			out.RawString("null")
		} else {
			(*in.CSSVisualViewport).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"cssContentSize\":"
		out.RawString(prefix)
		if in.CSSContentSize == nil {
			out.RawString("null")
		} else {
			(*in.CSSContentSize).MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v GetLayoutMetricsReturns) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage48(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v GetLayoutMetricsReturns) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage48(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *GetLayoutMetricsReturns) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage48(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetLayoutMetricsReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage48(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage49(in *jlexer.Lexer, out *GetLayoutMetricsParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage49(out *jwriter.Writer, in GetLayoutMetricsParams) {
	out.RawByte('{')
	first := true
	_ = first
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v GetLayoutMetricsParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage49(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v GetLayoutMetricsParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage49(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *GetLayoutMetricsParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage49(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetLayoutMetricsParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage49(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage50(in *jlexer.Lexer, out *GetInstallabilityErrorsReturns) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "installabilityErrors":
			if in.IsNull() {
				in.Skip()
				out.InstallabilityErrors = nil
			} else {
				in.Delim('[')
				if out.InstallabilityErrors == nil {
					if !in.IsDelim(']') {
						out.InstallabilityErrors = make([]*InstallabilityError, 0, 8)
					} else {
						out.InstallabilityErrors = []*InstallabilityError{}
					}
				} else {
					out.InstallabilityErrors = (out.InstallabilityErrors)[:0]
				}
				for !in.IsDelim(']') {
					var v22 *InstallabilityError
					if in.IsNull() {
						in.Skip()
						v22 = nil
					} else {
						if v22 == nil {
							v22 = new(InstallabilityError)
						}
						(*v22).UnmarshalEasyJSON(in)
					}
					out.InstallabilityErrors = append(out.InstallabilityErrors, v22)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage50(out *jwriter.Writer, in GetInstallabilityErrorsReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if len(in.InstallabilityErrors) != 0 {
		const prefix string = ",\"installabilityErrors\":"
		first = false
		out.RawString(prefix[1:])
		{
			out.RawByte('[')
			for v23, v24 := range in.InstallabilityErrors {
				if v23 > 0 {
					out.RawByte(',')
				}
				if v24 == nil {
					out.RawString("null")
				} else {
					(*v24).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v GetInstallabilityErrorsReturns) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage50(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v GetInstallabilityErrorsReturns) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage50(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *GetInstallabilityErrorsReturns) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage50(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetInstallabilityErrorsReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage50(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage51(in *jlexer.Lexer, out *GetInstallabilityErrorsParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage51(out *jwriter.Writer, in GetInstallabilityErrorsParams) {
	out.RawByte('{')
	first := true
	_ = first
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v GetInstallabilityErrorsParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage51(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v GetInstallabilityErrorsParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage51(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *GetInstallabilityErrorsParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage51(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetInstallabilityErrorsParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage51(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage52(in *jlexer.Lexer, out *GetFrameTreeReturns) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "frameTree":
			if in.IsNull() {
				in.Skip()
				out.FrameTree = nil
			} else {
				if out.FrameTree == nil {
					out.FrameTree = new(FrameTree)
				}
				(*out.FrameTree).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage52(out *jwriter.Writer, in GetFrameTreeReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if in.FrameTree != nil {
		const prefix string = ",\"frameTree\":"
		first = false
		out.RawString(prefix[1:])
		(*in.FrameTree).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v GetFrameTreeReturns) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage52(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v GetFrameTreeReturns) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage52(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *GetFrameTreeReturns) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage52(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetFrameTreeReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage52(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage53(in *jlexer.Lexer, out *GetFrameTreeParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage53(out *jwriter.Writer, in GetFrameTreeParams) {
	out.RawByte('{')
	first := true
	_ = first
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v GetFrameTreeParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage53(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v GetFrameTreeParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage53(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *GetFrameTreeParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage53(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetFrameTreeParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage53(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage54(in *jlexer.Lexer, out *GetAppManifestReturns) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "url":
			out.URL = string(in.String())
		case "errors":
			if in.IsNull() {
				in.Skip()
				out.Errors = nil
			} else {
				in.Delim('[')
				if out.Errors == nil {
					if !in.IsDelim(']') {
						out.Errors = make([]*AppManifestError, 0, 8)
					} else {
						out.Errors = []*AppManifestError{}
					}
				} else {
					out.Errors = (out.Errors)[:0]
				}
				for !in.IsDelim(']') {
					var v25 *AppManifestError
					if in.IsNull() {
						in.Skip()
						v25 = nil
					} else {
						if v25 == nil {
							v25 = new(AppManifestError)
						}
						(*v25).UnmarshalEasyJSON(in)
					}
					out.Errors = append(out.Errors, v25)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "data":
			out.Data = string(in.String())
		case "parsed":
			if in.IsNull() {
				in.Skip()
				out.Parsed = nil
			} else {
				if out.Parsed == nil {
					out.Parsed = new(AppManifestParsedProperties)
				}
				(*out.Parsed).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage54(out *jwriter.Writer, in GetAppManifestReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if in.URL != "" {
		const prefix string = ",\"url\":"
		first = false
		out.RawString(prefix[1:])
		out.String(string(in.URL))
	}
	if len(in.Errors) != 0 {
		const prefix string = ",\"errors\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		{
			out.RawByte('[')
			for v26, v27 := range in.Errors {
				if v26 > 0 {
					out.RawByte(',')
				}
				if v27 == nil {
					out.RawString("null")
				} else {
					(*v27).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	if in.Data != "" {
		const prefix string = ",\"data\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.String(string(in.Data))
	}
	if in.Parsed != nil {
		const prefix string = ",\"parsed\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.Parsed).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v GetAppManifestReturns) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage54(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v GetAppManifestReturns) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage54(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *GetAppManifestReturns) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage54(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetAppManifestReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage54(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage55(in *jlexer.Lexer, out *GetAppManifestParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage55(out *jwriter.Writer, in GetAppManifestParams) {
	out.RawByte('{')
	first := true
	_ = first
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v GetAppManifestParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage55(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v GetAppManifestParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage55(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *GetAppManifestParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage55(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetAppManifestParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage55(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage56(in *jlexer.Lexer, out *GetAppIDReturns) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "appId":
			out.AppID = string(in.String())
		case "recommendedId":
			out.RecommendedID = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage56(out *jwriter.Writer, in GetAppIDReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if in.AppID != "" {
		const prefix string = ",\"appId\":"
		first = false
		out.RawString(prefix[1:])
		out.String(string(in.AppID))
	}
	if in.RecommendedID != "" {
		const prefix string = ",\"recommendedId\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.String(string(in.RecommendedID))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v GetAppIDReturns) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage56(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v GetAppIDReturns) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage56(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *GetAppIDReturns) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage56(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetAppIDReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage56(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage57(in *jlexer.Lexer, out *GetAppIDParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage57(out *jwriter.Writer, in GetAppIDParams) {
	out.RawByte('{')
	first := true
	_ = first
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v GetAppIDParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage57(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v GetAppIDParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage57(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *GetAppIDParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage57(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetAppIDParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage57(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage58(in *jlexer.Lexer, out *GetAdScriptIDReturns) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "adScriptId":
			if in.IsNull() {
				in.Skip()
				out.AdScriptID = nil
			} else {
				if out.AdScriptID == nil {
					out.AdScriptID = new(AdScriptID)
				}
				(*out.AdScriptID).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage58(out *jwriter.Writer, in GetAdScriptIDReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if in.AdScriptID != nil {
		const prefix string = ",\"adScriptId\":"
		first = false
		out.RawString(prefix[1:])
		(*in.AdScriptID).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v GetAdScriptIDReturns) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage58(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v GetAdScriptIDReturns) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage58(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *GetAdScriptIDReturns) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage58(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetAdScriptIDReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage58(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage59(in *jlexer.Lexer, out *GetAdScriptIDParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "frameId":
			(out.FrameID).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage59(out *jwriter.Writer, in GetAdScriptIDParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"frameId\":"
		out.RawString(prefix[1:])
		out.String(string(in.FrameID))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v GetAdScriptIDParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage59(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v GetAdScriptIDParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage59(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *GetAdScriptIDParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage59(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetAdScriptIDParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage59(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage60(in *jlexer.Lexer, out *GenerateTestReportParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "message":
			out.Message = string(in.String())
		case "group":
			out.Group = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage60(out *jwriter.Writer, in GenerateTestReportParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"message\":"
		out.RawString(prefix[1:])
		out.String(string(in.Message))
	}
	if in.Group != "" {
		const prefix string = ",\"group\":"
		out.RawString(prefix)
		out.String(string(in.Group))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v GenerateTestReportParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage60(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v GenerateTestReportParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage60(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *GenerateTestReportParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage60(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GenerateTestReportParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage60(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage61(in *jlexer.Lexer, out *FrameTree) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "frame":
			if in.IsNull() {
				in.Skip()
				out.Frame = nil
			} else {
				if out.Frame == nil {
					out.Frame = new(cdp.Frame)
				}
				(*out.Frame).UnmarshalEasyJSON(in)
			}
		case "childFrames":
			if in.IsNull() {
				in.Skip()
				out.ChildFrames = nil
			} else {
				in.Delim('[')
				if out.ChildFrames == nil {
					if !in.IsDelim(']') {
						out.ChildFrames = make([]*FrameTree, 0, 8)
					} else {
						out.ChildFrames = []*FrameTree{}
					}
				} else {
					out.ChildFrames = (out.ChildFrames)[:0]
				}
				for !in.IsDelim(']') {
					var v28 *FrameTree
					if in.IsNull() {
						in.Skip()
						v28 = nil
					} else {
						if v28 == nil {
							v28 = new(FrameTree)
						}
						(*v28).UnmarshalEasyJSON(in)
					}
					out.ChildFrames = append(out.ChildFrames, v28)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage61(out *jwriter.Writer, in FrameTree) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"frame\":"
		out.RawString(prefix[1:])
		if in.Frame == nil {
			out.RawString("null")
		} else {
			(*in.Frame).MarshalEasyJSON(out)
		}
	}
	if len(in.ChildFrames) != 0 {
		const prefix string = ",\"childFrames\":"
		out.RawString(prefix)
		{
			out.RawByte('[')
			for v29, v30 := range in.ChildFrames {
				if v29 > 0 {
					out.RawByte(',')
				}
				if v30 == nil {
					out.RawString("null")
				} else {
					(*v30).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v FrameTree) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage61(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v FrameTree) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage61(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *FrameTree) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage61(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *FrameTree) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage61(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage62(in *jlexer.Lexer, out *FrameResourceTree) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "frame":
			if in.IsNull() {
				in.Skip()
				out.Frame = nil
			} else {
				if out.Frame == nil {
					out.Frame = new(cdp.Frame)
				}
				(*out.Frame).UnmarshalEasyJSON(in)
			}
		case "childFrames":
			if in.IsNull() {
				in.Skip()
				out.ChildFrames = nil
			} else {
				in.Delim('[')
				if out.ChildFrames == nil {
					if !in.IsDelim(']') {
						out.ChildFrames = make([]*FrameResourceTree, 0, 8)
					} else {
						out.ChildFrames = []*FrameResourceTree{}
					}
				} else {
					out.ChildFrames = (out.ChildFrames)[:0]
				}
				for !in.IsDelim(']') {
					var v31 *FrameResourceTree
					if in.IsNull() {
						in.Skip()
						v31 = nil
					} else {
						if v31 == nil {
							v31 = new(FrameResourceTree)
						}
						(*v31).UnmarshalEasyJSON(in)
					}
					out.ChildFrames = append(out.ChildFrames, v31)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "resources":
			if in.IsNull() {
				in.Skip()
				out.Resources = nil
			} else {
				in.Delim('[')
				if out.Resources == nil {
					if !in.IsDelim(']') {
						out.Resources = make([]*FrameResource, 0, 8)
					} else {
						out.Resources = []*FrameResource{}
					}
				} else {
					out.Resources = (out.Resources)[:0]
				}
				for !in.IsDelim(']') {
					var v32 *FrameResource
					if in.IsNull() {
						in.Skip()
						v32 = nil
					} else {
						if v32 == nil {
							v32 = new(FrameResource)
						}
						(*v32).UnmarshalEasyJSON(in)
					}
					out.Resources = append(out.Resources, v32)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage62(out *jwriter.Writer, in FrameResourceTree) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"frame\":"
		out.RawString(prefix[1:])
		if in.Frame == nil {
			out.RawString("null")
		} else {
			(*in.Frame).MarshalEasyJSON(out)
		}
	}
	if len(in.ChildFrames) != 0 {
		const prefix string = ",\"childFrames\":"
		out.RawString(prefix)
		{
			out.RawByte('[')
			for v33, v34 := range in.ChildFrames {
				if v33 > 0 {
					out.RawByte(',')
				}
				if v34 == nil {
					out.RawString("null")
				} else {
					(*v34).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	{
		const prefix string = ",\"resources\":"
		out.RawString(prefix)
		if in.Resources == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v35, v36 := range in.Resources {
				if v35 > 0 {
					out.RawByte(',')
				}
				if v36 == nil {
					out.RawString("null")
				} else {
					(*v36).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v FrameResourceTree) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage62(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v FrameResourceTree) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage62(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *FrameResourceTree) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage62(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *FrameResourceTree) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage62(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage63(in *jlexer.Lexer, out *FrameResource) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "url":
			out.URL = string(in.String())
		case "type":
			(out.Type).UnmarshalEasyJSON(in)
		case "mimeType":
			out.MimeType = string(in.String())
		case "lastModified":
			if in.IsNull() {
				in.Skip()
				out.LastModified = nil
			} else {
				if out.LastModified == nil {
					out.LastModified = new(cdp.TimeSinceEpoch)
				}
				(*out.LastModified).UnmarshalEasyJSON(in)
			}
		case "contentSize":
			out.ContentSize = float64(in.Float64())
		case "failed":
			out.Failed = bool(in.Bool())
		case "canceled":
			out.Canceled = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage63(out *jwriter.Writer, in FrameResource) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"url\":"
		out.RawString(prefix[1:])
		out.String(string(in.URL))
	}
	{
		const prefix string = ",\"type\":"
		out.RawString(prefix)
		(in.Type).MarshalEasyJSON(out)
	}
	{
		const prefix string = ",\"mimeType\":"
		out.RawString(prefix)
		out.String(string(in.MimeType))
	}
	if in.LastModified != nil {
		const prefix string = ",\"lastModified\":"
		out.RawString(prefix)
		(*in.LastModified).MarshalEasyJSON(out)
	}
	if in.ContentSize != 0 {
		const prefix string = ",\"contentSize\":"
		out.RawString(prefix)
		out.Float64(float64(in.ContentSize))
	}
	if in.Failed {
		const prefix string = ",\"failed\":"
		out.RawString(prefix)
		out.Bool(bool(in.Failed))
	}
	if in.Canceled {
		const prefix string = ",\"canceled\":"
		out.RawString(prefix)
		out.Bool(bool(in.Canceled))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v FrameResource) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage63(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v FrameResource) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage63(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *FrameResource) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage63(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *FrameResource) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage63(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage64(in *jlexer.Lexer, out *FontSizes) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "standard":
			out.Standard = int64(in.Int64())
		case "fixed":
			out.Fixed = int64(in.Int64())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage64(out *jwriter.Writer, in FontSizes) {
	out.RawByte('{')
	first := true
	_ = first
	if in.Standard != 0 {
		const prefix string = ",\"standard\":"
		first = false
		out.RawString(prefix[1:])
		out.Int64(int64(in.Standard))
	}
	if in.Fixed != 0 {
		const prefix string = ",\"fixed\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.Int64(int64(in.Fixed))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v FontSizes) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage64(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v FontSizes) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage64(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *FontSizes) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage64(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *FontSizes) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage64(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage65(in *jlexer.Lexer, out *FontFamilies) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "standard":
			out.Standard = string(in.String())
		case "fixed":
			out.Fixed = string(in.String())
		case "serif":
			out.Serif = string(in.String())
		case "sansSerif":
			out.SansSerif = string(in.String())
		case "cursive":
			out.Cursive = string(in.String())
		case "fantasy":
			out.Fantasy = string(in.String())
		case "math":
			out.Math = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage65(out *jwriter.Writer, in FontFamilies) {
	out.RawByte('{')
	first := true
	_ = first
	if in.Standard != "" {
		const prefix string = ",\"standard\":"
		first = false
		out.RawString(prefix[1:])
		out.String(string(in.Standard))
	}
	if in.Fixed != "" {
		const prefix string = ",\"fixed\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.String(string(in.Fixed))
	}
	if in.Serif != "" {
		const prefix string = ",\"serif\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.String(string(in.Serif))
	}
	if in.SansSerif != "" {
		const prefix string = ",\"sansSerif\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.String(string(in.SansSerif))
	}
	if in.Cursive != "" {
		const prefix string = ",\"cursive\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.String(string(in.Cursive))
	}
	if in.Fantasy != "" {
		const prefix string = ",\"fantasy\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.String(string(in.Fantasy))
	}
	if in.Math != "" {
		const prefix string = ",\"math\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.String(string(in.Math))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v FontFamilies) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage65(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v FontFamilies) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage65(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *FontFamilies) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage65(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *FontFamilies) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage65(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage66(in *jlexer.Lexer, out *EventWindowOpen) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "url":
			out.URL = string(in.String())
		case "windowName":
			out.WindowName = string(in.String())
		case "windowFeatures":
			if in.IsNull() {
				in.Skip()
				out.WindowFeatures = nil
			} else {
				in.Delim('[')
				if out.WindowFeatures == nil {
					if !in.IsDelim(']') {
						out.WindowFeatures = make([]string, 0, 4)
					} else {
						out.WindowFeatures = []string{}
					}
				} else {
					out.WindowFeatures = (out.WindowFeatures)[:0]
				}
				for !in.IsDelim(']') {
					var v37 string
					v37 = string(in.String())
					out.WindowFeatures = append(out.WindowFeatures, v37)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "userGesture":
			out.UserGesture = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage66(out *jwriter.Writer, in EventWindowOpen) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"url\":"
		out.RawString(prefix[1:])
		out.String(string(in.URL))
	}
	{
		const prefix string = ",\"windowName\":"
		out.RawString(prefix)
		out.String(string(in.WindowName))
	}
	{
		const prefix string = ",\"windowFeatures\":"
		out.RawString(prefix)
		if in.WindowFeatures == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v38, v39 := range in.WindowFeatures {
				if v38 > 0 {
					out.RawByte(',')
				}
				out.String(string(v39))
			}
			out.RawByte(']')
		}
	}
	{
		const prefix string = ",\"userGesture\":"
		out.RawString(prefix)
		out.Bool(bool(in.UserGesture))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v EventWindowOpen) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage66(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v EventWindowOpen) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage66(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *EventWindowOpen) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage66(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventWindowOpen) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage66(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage67(in *jlexer.Lexer, out *EventScreencastVisibilityChanged) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "visible":
			out.Visible = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage67(out *jwriter.Writer, in EventScreencastVisibilityChanged) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"visible\":"
		out.RawString(prefix[1:])
		out.Bool(bool(in.Visible))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v EventScreencastVisibilityChanged) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage67(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v EventScreencastVisibilityChanged) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage67(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *EventScreencastVisibilityChanged) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage67(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventScreencastVisibilityChanged) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage67(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage68(in *jlexer.Lexer, out *EventScreencastFrame) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "data":
			out.Data = string(in.String())
		case "metadata":
			if in.IsNull() {
				in.Skip()
				out.Metadata = nil
			} else {
				if out.Metadata == nil {
					out.Metadata = new(ScreencastFrameMetadata)
				}
				(*out.Metadata).UnmarshalEasyJSON(in)
			}
		case "sessionId":
			out.SessionID = int64(in.Int64())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage68(out *jwriter.Writer, in EventScreencastFrame) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"data\":"
		out.RawString(prefix[1:])
		out.String(string(in.Data))
	}
	{
		const prefix string = ",\"metadata\":"
		out.RawString(prefix)
		if in.Metadata == nil {
			out.RawString("null")
		} else {
			(*in.Metadata).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"sessionId\":"
		out.RawString(prefix)
		out.Int64(int64(in.SessionID))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v EventScreencastFrame) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage68(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v EventScreencastFrame) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage68(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *EventScreencastFrame) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage68(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventScreencastFrame) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage68(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage69(in *jlexer.Lexer, out *EventNavigatedWithinDocument) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "frameId":
			(out.FrameID).UnmarshalEasyJSON(in)
		case "url":
			out.URL = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage69(out *jwriter.Writer, in EventNavigatedWithinDocument) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"frameId\":"
		out.RawString(prefix[1:])
		out.String(string(in.FrameID))
	}
	{
		const prefix string = ",\"url\":"
		out.RawString(prefix)
		out.String(string(in.URL))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v EventNavigatedWithinDocument) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage69(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v EventNavigatedWithinDocument) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage69(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *EventNavigatedWithinDocument) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage69(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventNavigatedWithinDocument) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage69(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage70(in *jlexer.Lexer, out *EventLoadEventFired) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "timestamp":
			if in.IsNull() {
				in.Skip()
				out.Timestamp = nil
			} else {
				if out.Timestamp == nil {
					out.Timestamp = new(cdp.MonotonicTime)
				}
				(*out.Timestamp).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage70(out *jwriter.Writer, in EventLoadEventFired) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"timestamp\":"
		out.RawString(prefix[1:])
		if in.Timestamp == nil {
			out.RawString("null")
		} else {
			(*in.Timestamp).MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v EventLoadEventFired) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage70(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v EventLoadEventFired) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage70(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *EventLoadEventFired) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage70(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventLoadEventFired) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage70(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage71(in *jlexer.Lexer, out *EventLifecycleEvent) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "frameId":
			(out.FrameID).UnmarshalEasyJSON(in)
		case "loaderId":
			out.LoaderID = cdp.LoaderID(in.String())
		case "name":
			out.Name = string(in.String())
		case "timestamp":
			if in.IsNull() {
				in.Skip()
				out.Timestamp = nil
			} else {
				if out.Timestamp == nil {
					out.Timestamp = new(cdp.MonotonicTime)
				}
				(*out.Timestamp).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage71(out *jwriter.Writer, in EventLifecycleEvent) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"frameId\":"
		out.RawString(prefix[1:])
		out.String(string(in.FrameID))
	}
	{
		const prefix string = ",\"loaderId\":"
		out.RawString(prefix)
		out.String(string(in.LoaderID))
	}
	{
		const prefix string = ",\"name\":"
		out.RawString(prefix)
		out.String(string(in.Name))
	}
	{
		const prefix string = ",\"timestamp\":"
		out.RawString(prefix)
		if in.Timestamp == nil {
			out.RawString("null")
		} else {
			(*in.Timestamp).MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v EventLifecycleEvent) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage71(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v EventLifecycleEvent) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage71(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *EventLifecycleEvent) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage71(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventLifecycleEvent) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage71(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage72(in *jlexer.Lexer, out *EventJavascriptDialogOpening) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "url":
			out.URL = string(in.String())
		case "message":
			out.Message = string(in.String())
		case "type":
			(out.Type).UnmarshalEasyJSON(in)
		case "hasBrowserHandler":
			out.HasBrowserHandler = bool(in.Bool())
		case "defaultPrompt":
			out.DefaultPrompt = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage72(out *jwriter.Writer, in EventJavascriptDialogOpening) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"url\":"
		out.RawString(prefix[1:])
		out.String(string(in.URL))
	}
	{
		const prefix string = ",\"message\":"
		out.RawString(prefix)
		out.String(string(in.Message))
	}
	{
		const prefix string = ",\"type\":"
		out.RawString(prefix)
		(in.Type).MarshalEasyJSON(out)
	}
	{
		const prefix string = ",\"hasBrowserHandler\":"
		out.RawString(prefix)
		out.Bool(bool(in.HasBrowserHandler))
	}
	if in.DefaultPrompt != "" {
		const prefix string = ",\"defaultPrompt\":"
		out.RawString(prefix)
		out.String(string(in.DefaultPrompt))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v EventJavascriptDialogOpening) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage72(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v EventJavascriptDialogOpening) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage72(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *EventJavascriptDialogOpening) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage72(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventJavascriptDialogOpening) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage72(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage73(in *jlexer.Lexer, out *EventJavascriptDialogClosed) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "result":
			out.Result = bool(in.Bool())
		case "userInput":
			out.UserInput = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage73(out *jwriter.Writer, in EventJavascriptDialogClosed) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"result\":"
		out.RawString(prefix[1:])
		out.Bool(bool(in.Result))
	}
	{
		const prefix string = ",\"userInput\":"
		out.RawString(prefix)
		out.String(string(in.UserInput))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v EventJavascriptDialogClosed) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage73(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v EventJavascriptDialogClosed) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage73(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *EventJavascriptDialogClosed) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage73(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventJavascriptDialogClosed) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage73(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage74(in *jlexer.Lexer, out *EventInterstitialShown) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage74(out *jwriter.Writer, in EventInterstitialShown) {
	out.RawByte('{')
	first := true
	_ = first
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v EventInterstitialShown) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage74(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v EventInterstitialShown) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage74(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *EventInterstitialShown) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage74(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventInterstitialShown) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage74(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage75(in *jlexer.Lexer, out *EventInterstitialHidden) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage75(out *jwriter.Writer, in EventInterstitialHidden) {
	out.RawByte('{')
	first := true
	_ = first
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v EventInterstitialHidden) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage75(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v EventInterstitialHidden) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage75(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *EventInterstitialHidden) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage75(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventInterstitialHidden) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage75(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage76(in *jlexer.Lexer, out *EventFrameStoppedLoading) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "frameId":
			(out.FrameID).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage76(out *jwriter.Writer, in EventFrameStoppedLoading) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"frameId\":"
		out.RawString(prefix[1:])
		out.String(string(in.FrameID))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v EventFrameStoppedLoading) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage76(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v EventFrameStoppedLoading) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage76(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *EventFrameStoppedLoading) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage76(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventFrameStoppedLoading) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage76(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage77(in *jlexer.Lexer, out *EventFrameStartedLoading) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "frameId":
			(out.FrameID).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage77(out *jwriter.Writer, in EventFrameStartedLoading) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"frameId\":"
		out.RawString(prefix[1:])
		out.String(string(in.FrameID))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v EventFrameStartedLoading) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage77(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v EventFrameStartedLoading) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage77(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *EventFrameStartedLoading) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage77(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventFrameStartedLoading) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage77(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage78(in *jlexer.Lexer, out *EventFrameResized) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage78(out *jwriter.Writer, in EventFrameResized) {
	out.RawByte('{')
	first := true
	_ = first
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v EventFrameResized) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage78(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v EventFrameResized) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage78(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *EventFrameResized) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage78(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventFrameResized) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage78(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage79(in *jlexer.Lexer, out *EventFrameRequestedNavigation) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "frameId":
			(out.FrameID).UnmarshalEasyJSON(in)
		case "reason":
			(out.Reason).UnmarshalEasyJSON(in)
		case "url":
			out.URL = string(in.String())
		case "disposition":
			(out.Disposition).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage79(out *jwriter.Writer, in EventFrameRequestedNavigation) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"frameId\":"
		out.RawString(prefix[1:])
		out.String(string(in.FrameID))
	}
	{
		const prefix string = ",\"reason\":"
		out.RawString(prefix)
		(in.Reason).MarshalEasyJSON(out)
	}
	{
		const prefix string = ",\"url\":"
		out.RawString(prefix)
		out.String(string(in.URL))
	}
	{
		const prefix string = ",\"disposition\":"
		out.RawString(prefix)
		(in.Disposition).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v EventFrameRequestedNavigation) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage79(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v EventFrameRequestedNavigation) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage79(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *EventFrameRequestedNavigation) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage79(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventFrameRequestedNavigation) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage79(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage80(in *jlexer.Lexer, out *EventFrameNavigated) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "frame":
			if in.IsNull() {
				in.Skip()
				out.Frame = nil
			} else {
				if out.Frame == nil {
					out.Frame = new(cdp.Frame)
				}
				(*out.Frame).UnmarshalEasyJSON(in)
			}
		case "type":
			(out.Type).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage80(out *jwriter.Writer, in EventFrameNavigated) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"frame\":"
		out.RawString(prefix[1:])
		if in.Frame == nil {
			out.RawString("null")
		} else {
			(*in.Frame).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"type\":"
		out.RawString(prefix)
		(in.Type).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v EventFrameNavigated) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage80(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v EventFrameNavigated) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage80(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *EventFrameNavigated) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage80(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventFrameNavigated) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage80(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage81(in *jlexer.Lexer, out *EventFrameDetached) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "frameId":
			(out.FrameID).UnmarshalEasyJSON(in)
		case "reason":
			(out.Reason).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage81(out *jwriter.Writer, in EventFrameDetached) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"frameId\":"
		out.RawString(prefix[1:])
		out.String(string(in.FrameID))
	}
	{
		const prefix string = ",\"reason\":"
		out.RawString(prefix)
		(in.Reason).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v EventFrameDetached) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage81(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v EventFrameDetached) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage81(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *EventFrameDetached) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage81(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventFrameDetached) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage81(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage82(in *jlexer.Lexer, out *EventFrameAttached) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "frameId":
			(out.FrameID).UnmarshalEasyJSON(in)
		case "parentFrameId":
			(out.ParentFrameID).UnmarshalEasyJSON(in)
		case "stack":
			if in.IsNull() {
				in.Skip()
				out.Stack = nil
			} else {
				if out.Stack == nil {
					out.Stack = new(runtime.StackTrace)
				}
				(*out.Stack).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage82(out *jwriter.Writer, in EventFrameAttached) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"frameId\":"
		out.RawString(prefix[1:])
		out.String(string(in.FrameID))
	}
	{
		const prefix string = ",\"parentFrameId\":"
		out.RawString(prefix)
		out.String(string(in.ParentFrameID))
	}
	if in.Stack != nil {
		const prefix string = ",\"stack\":"
		out.RawString(prefix)
		(*in.Stack).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v EventFrameAttached) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage82(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v EventFrameAttached) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage82(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *EventFrameAttached) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage82(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventFrameAttached) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage82(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage83(in *jlexer.Lexer, out *EventFileChooserOpened) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "frameId":
			(out.FrameID).UnmarshalEasyJSON(in)
		case "mode":
			(out.Mode).UnmarshalEasyJSON(in)
		case "backendNodeId":
			(out.BackendNodeID).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage83(out *jwriter.Writer, in EventFileChooserOpened) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"frameId\":"
		out.RawString(prefix[1:])
		out.String(string(in.FrameID))
	}
	{
		const prefix string = ",\"mode\":"
		out.RawString(prefix)
		(in.Mode).MarshalEasyJSON(out)
	}
	if in.BackendNodeID != 0 {
		const prefix string = ",\"backendNodeId\":"
		out.RawString(prefix)
		out.Int64(int64(in.BackendNodeID))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v EventFileChooserOpened) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage83(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v EventFileChooserOpened) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage83(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *EventFileChooserOpened) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage83(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventFileChooserOpened) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage83(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage84(in *jlexer.Lexer, out *EventDomContentEventFired) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "timestamp":
			if in.IsNull() {
				in.Skip()
				out.Timestamp = nil
			} else {
				if out.Timestamp == nil {
					out.Timestamp = new(cdp.MonotonicTime)
				}
				(*out.Timestamp).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage84(out *jwriter.Writer, in EventDomContentEventFired) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"timestamp\":"
		out.RawString(prefix[1:])
		if in.Timestamp == nil {
			out.RawString("null")
		} else {
			(*in.Timestamp).MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v EventDomContentEventFired) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage84(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v EventDomContentEventFired) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage84(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *EventDomContentEventFired) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage84(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventDomContentEventFired) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage84(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage85(in *jlexer.Lexer, out *EventDocumentOpened) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "frame":
			if in.IsNull() {
				in.Skip()
				out.Frame = nil
			} else {
				if out.Frame == nil {
					out.Frame = new(cdp.Frame)
				}
				(*out.Frame).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage85(out *jwriter.Writer, in EventDocumentOpened) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"frame\":"
		out.RawString(prefix[1:])
		if in.Frame == nil {
			out.RawString("null")
		} else {
			(*in.Frame).MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v EventDocumentOpened) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage85(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v EventDocumentOpened) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage85(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *EventDocumentOpened) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage85(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventDocumentOpened) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage85(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage86(in *jlexer.Lexer, out *EventCompilationCacheProduced) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "url":
			out.URL = string(in.String())
		case "data":
			out.Data = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage86(out *jwriter.Writer, in EventCompilationCacheProduced) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"url\":"
		out.RawString(prefix[1:])
		out.String(string(in.URL))
	}
	{
		const prefix string = ",\"data\":"
		out.RawString(prefix)
		out.String(string(in.Data))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v EventCompilationCacheProduced) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage86(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v EventCompilationCacheProduced) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage86(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *EventCompilationCacheProduced) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage86(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventCompilationCacheProduced) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage86(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage87(in *jlexer.Lexer, out *EventBackForwardCacheNotUsed) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "loaderId":
			out.LoaderID = cdp.LoaderID(in.String())
		case "frameId":
			(out.FrameID).UnmarshalEasyJSON(in)
		case "notRestoredExplanations":
			if in.IsNull() {
				in.Skip()
				out.NotRestoredExplanations = nil
			} else {
				in.Delim('[')
				if out.NotRestoredExplanations == nil {
					if !in.IsDelim(']') {
						out.NotRestoredExplanations = make([]*BackForwardCacheNotRestoredExplanation, 0, 8)
					} else {
						out.NotRestoredExplanations = []*BackForwardCacheNotRestoredExplanation{}
					}
				} else {
					out.NotRestoredExplanations = (out.NotRestoredExplanations)[:0]
				}
				for !in.IsDelim(']') {
					var v40 *BackForwardCacheNotRestoredExplanation
					if in.IsNull() {
						in.Skip()
						v40 = nil
					} else {
						if v40 == nil {
							v40 = new(BackForwardCacheNotRestoredExplanation)
						}
						(*v40).UnmarshalEasyJSON(in)
					}
					out.NotRestoredExplanations = append(out.NotRestoredExplanations, v40)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "notRestoredExplanationsTree":
			if in.IsNull() {
				in.Skip()
				out.NotRestoredExplanationsTree = nil
			} else {
				if out.NotRestoredExplanationsTree == nil {
					out.NotRestoredExplanationsTree = new(BackForwardCacheNotRestoredExplanationTree)
				}
				(*out.NotRestoredExplanationsTree).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage87(out *jwriter.Writer, in EventBackForwardCacheNotUsed) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"loaderId\":"
		out.RawString(prefix[1:])
		out.String(string(in.LoaderID))
	}
	{
		const prefix string = ",\"frameId\":"
		out.RawString(prefix)
		out.String(string(in.FrameID))
	}
	{
		const prefix string = ",\"notRestoredExplanations\":"
		out.RawString(prefix)
		if in.NotRestoredExplanations == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v41, v42 := range in.NotRestoredExplanations {
				if v41 > 0 {
					out.RawByte(',')
				}
				if v42 == nil {
					out.RawString("null")
				} else {
					(*v42).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	if in.NotRestoredExplanationsTree != nil {
		const prefix string = ",\"notRestoredExplanationsTree\":"
		out.RawString(prefix)
		(*in.NotRestoredExplanationsTree).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v EventBackForwardCacheNotUsed) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage87(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v EventBackForwardCacheNotUsed) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage87(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *EventBackForwardCacheNotUsed) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage87(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventBackForwardCacheNotUsed) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage87(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage88(in *jlexer.Lexer, out *EnableParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage88(out *jwriter.Writer, in EnableParams) {
	out.RawByte('{')
	first := true
	_ = first
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v EnableParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage88(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v EnableParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage88(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *EnableParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage88(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EnableParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage88(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage89(in *jlexer.Lexer, out *DisableParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage89(out *jwriter.Writer, in DisableParams) {
	out.RawByte('{')
	first := true
	_ = first
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v DisableParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage89(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v DisableParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage89(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *DisableParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage89(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *DisableParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage89(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage90(in *jlexer.Lexer, out *CreateIsolatedWorldReturns) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "executionContextId":
			out.ExecutionContextID = runtime.ExecutionContextID(in.Int64())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage90(out *jwriter.Writer, in CreateIsolatedWorldReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if in.ExecutionContextID != 0 {
		const prefix string = ",\"executionContextId\":"
		first = false
		out.RawString(prefix[1:])
		out.Int64(int64(in.ExecutionContextID))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v CreateIsolatedWorldReturns) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage90(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v CreateIsolatedWorldReturns) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage90(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *CreateIsolatedWorldReturns) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage90(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *CreateIsolatedWorldReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage90(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage91(in *jlexer.Lexer, out *CreateIsolatedWorldParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "frameId":
			(out.FrameID).UnmarshalEasyJSON(in)
		case "worldName":
			out.WorldName = string(in.String())
		case "grantUniveralAccess":
			out.GrantUniveralAccess = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage91(out *jwriter.Writer, in CreateIsolatedWorldParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"frameId\":"
		out.RawString(prefix[1:])
		out.String(string(in.FrameID))
	}
	if in.WorldName != "" {
		const prefix string = ",\"worldName\":"
		out.RawString(prefix)
		out.String(string(in.WorldName))
	}
	if in.GrantUniveralAccess {
		const prefix string = ",\"grantUniveralAccess\":"
		out.RawString(prefix)
		out.Bool(bool(in.GrantUniveralAccess))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v CreateIsolatedWorldParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage91(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v CreateIsolatedWorldParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage91(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *CreateIsolatedWorldParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage91(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *CreateIsolatedWorldParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage91(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage92(in *jlexer.Lexer, out *CrashParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage92(out *jwriter.Writer, in CrashParams) {
	out.RawByte('{')
	first := true
	_ = first
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v CrashParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage92(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v CrashParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage92(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *CrashParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage92(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *CrashParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage92(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage93(in *jlexer.Lexer, out *CompilationCacheParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "url":
			out.URL = string(in.String())
		case "eager":
			out.Eager = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage93(out *jwriter.Writer, in CompilationCacheParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"url\":"
		out.RawString(prefix[1:])
		out.String(string(in.URL))
	}
	if in.Eager {
		const prefix string = ",\"eager\":"
		out.RawString(prefix)
		out.Bool(bool(in.Eager))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v CompilationCacheParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage93(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v CompilationCacheParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage93(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *CompilationCacheParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage93(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *CompilationCacheParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage93(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage94(in *jlexer.Lexer, out *CloseParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage94(out *jwriter.Writer, in CloseParams) {
	out.RawByte('{')
	first := true
	_ = first
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v CloseParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage94(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v CloseParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage94(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *CloseParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage94(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *CloseParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage94(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage95(in *jlexer.Lexer, out *ClearCompilationCacheParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage95(out *jwriter.Writer, in ClearCompilationCacheParams) {
	out.RawByte('{')
	first := true
	_ = first
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v ClearCompilationCacheParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage95(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v ClearCompilationCacheParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage95(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *ClearCompilationCacheParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage95(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *ClearCompilationCacheParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage95(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage96(in *jlexer.Lexer, out *CaptureSnapshotReturns) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "data":
			out.Data = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage96(out *jwriter.Writer, in CaptureSnapshotReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if in.Data != "" {
		const prefix string = ",\"data\":"
		first = false
		out.RawString(prefix[1:])
		out.String(string(in.Data))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v CaptureSnapshotReturns) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage96(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v CaptureSnapshotReturns) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage96(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *CaptureSnapshotReturns) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage96(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *CaptureSnapshotReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage96(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage97(in *jlexer.Lexer, out *CaptureSnapshotParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "format":
			(out.Format).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage97(out *jwriter.Writer, in CaptureSnapshotParams) {
	out.RawByte('{')
	first := true
	_ = first
	if in.Format != "" {
		const prefix string = ",\"format\":"
		first = false
		out.RawString(prefix[1:])
		(in.Format).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v CaptureSnapshotParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage97(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v CaptureSnapshotParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage97(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *CaptureSnapshotParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage97(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *CaptureSnapshotParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage97(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage98(in *jlexer.Lexer, out *CaptureScreenshotReturns) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "data":
			out.Data = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage98(out *jwriter.Writer, in CaptureScreenshotReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if in.Data != "" {
		const prefix string = ",\"data\":"
		first = false
		out.RawString(prefix[1:])
		out.String(string(in.Data))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v CaptureScreenshotReturns) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage98(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v CaptureScreenshotReturns) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage98(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *CaptureScreenshotReturns) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage98(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *CaptureScreenshotReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage98(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage99(in *jlexer.Lexer, out *CaptureScreenshotParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "format":
			(out.Format).UnmarshalEasyJSON(in)
		case "quality":
			out.Quality = int64(in.Int64())
		case "clip":
			if in.IsNull() {
				in.Skip()
				out.Clip = nil
			} else {
				if out.Clip == nil {
					out.Clip = new(Viewport)
				}
				(*out.Clip).UnmarshalEasyJSON(in)
			}
		case "fromSurface":
			out.FromSurface = bool(in.Bool())
		case "captureBeyondViewport":
			out.CaptureBeyondViewport = bool(in.Bool())
		case "optimizeForSpeed":
			out.OptimizeForSpeed = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage99(out *jwriter.Writer, in CaptureScreenshotParams) {
	out.RawByte('{')
	first := true
	_ = first
	if in.Format != "" {
		const prefix string = ",\"format\":"
		first = false
		out.RawString(prefix[1:])
		(in.Format).MarshalEasyJSON(out)
	}
	if in.Quality != 0 {
		const prefix string = ",\"quality\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.Int64(int64(in.Quality))
	}
	if in.Clip != nil {
		const prefix string = ",\"clip\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.Clip).MarshalEasyJSON(out)
	}
	if in.FromSurface {
		const prefix string = ",\"fromSurface\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.Bool(bool(in.FromSurface))
	}
	if in.CaptureBeyondViewport {
		const prefix string = ",\"captureBeyondViewport\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.Bool(bool(in.CaptureBeyondViewport))
	}
	if in.OptimizeForSpeed {
		const prefix string = ",\"optimizeForSpeed\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.Bool(bool(in.OptimizeForSpeed))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v CaptureScreenshotParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage99(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v CaptureScreenshotParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage99(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *CaptureScreenshotParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage99(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *CaptureScreenshotParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage99(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage100(in *jlexer.Lexer, out *BringToFrontParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage100(out *jwriter.Writer, in BringToFrontParams) {
	out.RawByte('{')
	first := true
	_ = first
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v BringToFrontParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage100(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v BringToFrontParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage100(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *BringToFrontParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage100(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *BringToFrontParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage100(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage101(in *jlexer.Lexer, out *BackForwardCacheNotRestoredExplanationTree) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "url":
			out.URL = string(in.String())
		case "explanations":
			if in.IsNull() {
				in.Skip()
				out.Explanations = nil
			} else {
				in.Delim('[')
				if out.Explanations == nil {
					if !in.IsDelim(']') {
						out.Explanations = make([]*BackForwardCacheNotRestoredExplanation, 0, 8)
					} else {
						out.Explanations = []*BackForwardCacheNotRestoredExplanation{}
					}
				} else {
					out.Explanations = (out.Explanations)[:0]
				}
				for !in.IsDelim(']') {
					var v43 *BackForwardCacheNotRestoredExplanation
					if in.IsNull() {
						in.Skip()
						v43 = nil
					} else {
						if v43 == nil {
							v43 = new(BackForwardCacheNotRestoredExplanation)
						}
						(*v43).UnmarshalEasyJSON(in)
					}
					out.Explanations = append(out.Explanations, v43)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "children":
			if in.IsNull() {
				in.Skip()
				out.Children = nil
			} else {
				in.Delim('[')
				if out.Children == nil {
					if !in.IsDelim(']') {
						out.Children = make([]*BackForwardCacheNotRestoredExplanationTree, 0, 8)
					} else {
						out.Children = []*BackForwardCacheNotRestoredExplanationTree{}
					}
				} else {
					out.Children = (out.Children)[:0]
				}
				for !in.IsDelim(']') {
					var v44 *BackForwardCacheNotRestoredExplanationTree
					if in.IsNull() {
						in.Skip()
						v44 = nil
					} else {
						if v44 == nil {
							v44 = new(BackForwardCacheNotRestoredExplanationTree)
						}
						(*v44).UnmarshalEasyJSON(in)
					}
					out.Children = append(out.Children, v44)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage101(out *jwriter.Writer, in BackForwardCacheNotRestoredExplanationTree) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"url\":"
		out.RawString(prefix[1:])
		out.String(string(in.URL))
	}
	{
		const prefix string = ",\"explanations\":"
		out.RawString(prefix)
		if in.Explanations == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v45, v46 := range in.Explanations {
				if v45 > 0 {
					out.RawByte(',')
				}
				if v46 == nil {
					out.RawString("null")
				} else {
					(*v46).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	{
		const prefix string = ",\"children\":"
		out.RawString(prefix)
		if in.Children == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v47, v48 := range in.Children {
				if v47 > 0 {
					out.RawByte(',')
				}
				if v48 == nil {
					out.RawString("null")
				} else {
					(*v48).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v BackForwardCacheNotRestoredExplanationTree) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage101(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v BackForwardCacheNotRestoredExplanationTree) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage101(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *BackForwardCacheNotRestoredExplanationTree) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage101(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *BackForwardCacheNotRestoredExplanationTree) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage101(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage102(in *jlexer.Lexer, out *BackForwardCacheNotRestoredExplanation) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "type":
			(out.Type).UnmarshalEasyJSON(in)
		case "reason":
			(out.Reason).UnmarshalEasyJSON(in)
		case "context":
			out.Context = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage102(out *jwriter.Writer, in BackForwardCacheNotRestoredExplanation) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"type\":"
		out.RawString(prefix[1:])
		(in.Type).MarshalEasyJSON(out)
	}
	{
		const prefix string = ",\"reason\":"
		out.RawString(prefix)
		(in.Reason).MarshalEasyJSON(out)
	}
	if in.Context != "" {
		const prefix string = ",\"context\":"
		out.RawString(prefix)
		out.String(string(in.Context))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v BackForwardCacheNotRestoredExplanation) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage102(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v BackForwardCacheNotRestoredExplanation) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage102(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *BackForwardCacheNotRestoredExplanation) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage102(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *BackForwardCacheNotRestoredExplanation) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage102(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage103(in *jlexer.Lexer, out *AppManifestParsedProperties) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "scope":
			out.Scope = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage103(out *jwriter.Writer, in AppManifestParsedProperties) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"scope\":"
		out.RawString(prefix[1:])
		out.String(string(in.Scope))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v AppManifestParsedProperties) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage103(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v AppManifestParsedProperties) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage103(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *AppManifestParsedProperties) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage103(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *AppManifestParsedProperties) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage103(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage104(in *jlexer.Lexer, out *AppManifestError) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "message":
			out.Message = string(in.String())
		case "critical":
			out.Critical = int64(in.Int64())
		case "line":
			out.Line = int64(in.Int64())
		case "column":
			out.Column = int64(in.Int64())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage104(out *jwriter.Writer, in AppManifestError) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"message\":"
		out.RawString(prefix[1:])
		out.String(string(in.Message))
	}
	{
		const prefix string = ",\"critical\":"
		out.RawString(prefix)
		out.Int64(int64(in.Critical))
	}
	{
		const prefix string = ",\"line\":"
		out.RawString(prefix)
		out.Int64(int64(in.Line))
	}
	{
		const prefix string = ",\"column\":"
		out.RawString(prefix)
		out.Int64(int64(in.Column))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v AppManifestError) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage104(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v AppManifestError) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage104(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *AppManifestError) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage104(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *AppManifestError) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage104(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage105(in *jlexer.Lexer, out *AddScriptToEvaluateOnNewDocumentReturns) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "identifier":
			out.Identifier = ScriptIdentifier(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage105(out *jwriter.Writer, in AddScriptToEvaluateOnNewDocumentReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if in.Identifier != "" {
		const prefix string = ",\"identifier\":"
		first = false
		out.RawString(prefix[1:])
		out.String(string(in.Identifier))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v AddScriptToEvaluateOnNewDocumentReturns) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage105(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v AddScriptToEvaluateOnNewDocumentReturns) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage105(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *AddScriptToEvaluateOnNewDocumentReturns) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage105(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *AddScriptToEvaluateOnNewDocumentReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage105(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage106(in *jlexer.Lexer, out *AddScriptToEvaluateOnNewDocumentParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "source":
			out.Source = string(in.String())
		case "worldName":
			out.WorldName = string(in.String())
		case "includeCommandLineAPI":
			out.IncludeCommandLineAPI = bool(in.Bool())
		case "runImmediately":
			out.RunImmediately = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage106(out *jwriter.Writer, in AddScriptToEvaluateOnNewDocumentParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"source\":"
		out.RawString(prefix[1:])
		out.String(string(in.Source))
	}
	if in.WorldName != "" {
		const prefix string = ",\"worldName\":"
		out.RawString(prefix)
		out.String(string(in.WorldName))
	}
	if in.IncludeCommandLineAPI {
		const prefix string = ",\"includeCommandLineAPI\":"
		out.RawString(prefix)
		out.Bool(bool(in.IncludeCommandLineAPI))
	}
	if in.RunImmediately {
		const prefix string = ",\"runImmediately\":"
		out.RawString(prefix)
		out.Bool(bool(in.RunImmediately))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v AddScriptToEvaluateOnNewDocumentParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage106(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v AddScriptToEvaluateOnNewDocumentParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage106(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *AddScriptToEvaluateOnNewDocumentParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage106(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *AddScriptToEvaluateOnNewDocumentParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage106(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage107(in *jlexer.Lexer, out *AddCompilationCacheParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "url":
			out.URL = string(in.String())
		case "data":
			out.Data = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage107(out *jwriter.Writer, in AddCompilationCacheParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"url\":"
		out.RawString(prefix[1:])
		out.String(string(in.URL))
	}
	{
		const prefix string = ",\"data\":"
		out.RawString(prefix)
		out.String(string(in.Data))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v AddCompilationCacheParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage107(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v AddCompilationCacheParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage107(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *AddCompilationCacheParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage107(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *AddCompilationCacheParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage107(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage108(in *jlexer.Lexer, out *AdScriptID) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "scriptId":
			out.ScriptID = runtime.ScriptID(in.String())
		case "debuggerId":
			out.DebuggerID = runtime.UniqueDebuggerID(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage108(out *jwriter.Writer, in AdScriptID) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"scriptId\":"
		out.RawString(prefix[1:])
		out.String(string(in.ScriptID))
	}
	{
		const prefix string = ",\"debuggerId\":"
		out.RawString(prefix)
		out.String(string(in.DebuggerID))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v AdScriptID) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage108(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v AdScriptID) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoPage108(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *AdScriptID) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage108(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *AdScriptID) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage108(l, v)
}
