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

package overlay

import (
	json "encoding/json"
	cdp "github.com/chromedp/cdproto/cdp"
	dom "github.com/chromedp/cdproto/dom"
	page "github.com/chromedp/cdproto/page"
	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 easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay(in *jlexer.Lexer, out *SourceOrderConfig) {
	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 "parentOutlineColor":
			if in.IsNull() {
				in.Skip()
				out.ParentOutlineColor = nil
			} else {
				if out.ParentOutlineColor == nil {
					out.ParentOutlineColor = new(cdp.RGBA)
				}
				(*out.ParentOutlineColor).UnmarshalEasyJSON(in)
			}
		case "childOutlineColor":
			if in.IsNull() {
				in.Skip()
				out.ChildOutlineColor = nil
			} else {
				if out.ChildOutlineColor == nil {
					out.ChildOutlineColor = new(cdp.RGBA)
				}
				(*out.ChildOutlineColor).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay(out *jwriter.Writer, in SourceOrderConfig) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"parentOutlineColor\":"
		out.RawString(prefix[1:])
		if in.ParentOutlineColor == nil {
			out.RawString("null")
		} else {
			(*in.ParentOutlineColor).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"childOutlineColor\":"
		out.RawString(prefix)
		if in.ChildOutlineColor == nil {
			out.RawString("null")
		} else {
			(*in.ChildOutlineColor).MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SourceOrderConfig) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay1(in *jlexer.Lexer, out *SetShowWebVitalsParams) {
	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 "show":
			out.Show = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay1(out *jwriter.Writer, in SetShowWebVitalsParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"show\":"
		out.RawString(prefix[1:])
		out.Bool(bool(in.Show))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetShowWebVitalsParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay1(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay2(in *jlexer.Lexer, out *SetShowViewportSizeOnResizeParams) {
	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 "show":
			out.Show = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay2(out *jwriter.Writer, in SetShowViewportSizeOnResizeParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"show\":"
		out.RawString(prefix[1:])
		out.Bool(bool(in.Show))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetShowViewportSizeOnResizeParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay2(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay3(in *jlexer.Lexer, out *SetShowScrollSnapOverlaysParams) {
	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 "scrollSnapHighlightConfigs":
			if in.IsNull() {
				in.Skip()
				out.ScrollSnapHighlightConfigs = nil
			} else {
				in.Delim('[')
				if out.ScrollSnapHighlightConfigs == nil {
					if !in.IsDelim(']') {
						out.ScrollSnapHighlightConfigs = make([]*ScrollSnapHighlightConfig, 0, 8)
					} else {
						out.ScrollSnapHighlightConfigs = []*ScrollSnapHighlightConfig{}
					}
				} else {
					out.ScrollSnapHighlightConfigs = (out.ScrollSnapHighlightConfigs)[:0]
				}
				for !in.IsDelim(']') {
					var v1 *ScrollSnapHighlightConfig
					if in.IsNull() {
						in.Skip()
						v1 = nil
					} else {
						if v1 == nil {
							v1 = new(ScrollSnapHighlightConfig)
						}
						(*v1).UnmarshalEasyJSON(in)
					}
					out.ScrollSnapHighlightConfigs = append(out.ScrollSnapHighlightConfigs, v1)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay3(out *jwriter.Writer, in SetShowScrollSnapOverlaysParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"scrollSnapHighlightConfigs\":"
		out.RawString(prefix[1:])
		if in.ScrollSnapHighlightConfigs == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v2, v3 := range in.ScrollSnapHighlightConfigs {
				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 SetShowScrollSnapOverlaysParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay3(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetShowScrollSnapOverlaysParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay3(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay4(in *jlexer.Lexer, out *SetShowScrollBottleneckRectsParams) {
	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 "show":
			out.Show = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay4(out *jwriter.Writer, in SetShowScrollBottleneckRectsParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"show\":"
		out.RawString(prefix[1:])
		out.Bool(bool(in.Show))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetShowScrollBottleneckRectsParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay4(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay5(in *jlexer.Lexer, out *SetShowPaintRectsParams) {
	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())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay5(out *jwriter.Writer, in SetShowPaintRectsParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"result\":"
		out.RawString(prefix[1:])
		out.Bool(bool(in.Result))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetShowPaintRectsParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay5(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay6(in *jlexer.Lexer, out *SetShowLayoutShiftRegionsParams) {
	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())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay6(out *jwriter.Writer, in SetShowLayoutShiftRegionsParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"result\":"
		out.RawString(prefix[1:])
		out.Bool(bool(in.Result))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetShowLayoutShiftRegionsParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay6(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay7(in *jlexer.Lexer, out *SetShowIsolatedElementsParams) {
	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 "isolatedElementHighlightConfigs":
			if in.IsNull() {
				in.Skip()
				out.IsolatedElementHighlightConfigs = nil
			} else {
				in.Delim('[')
				if out.IsolatedElementHighlightConfigs == nil {
					if !in.IsDelim(']') {
						out.IsolatedElementHighlightConfigs = make([]*IsolatedElementHighlightConfig, 0, 8)
					} else {
						out.IsolatedElementHighlightConfigs = []*IsolatedElementHighlightConfig{}
					}
				} else {
					out.IsolatedElementHighlightConfigs = (out.IsolatedElementHighlightConfigs)[:0]
				}
				for !in.IsDelim(']') {
					var v4 *IsolatedElementHighlightConfig
					if in.IsNull() {
						in.Skip()
						v4 = nil
					} else {
						if v4 == nil {
							v4 = new(IsolatedElementHighlightConfig)
						}
						(*v4).UnmarshalEasyJSON(in)
					}
					out.IsolatedElementHighlightConfigs = append(out.IsolatedElementHighlightConfigs, v4)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay7(out *jwriter.Writer, in SetShowIsolatedElementsParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"isolatedElementHighlightConfigs\":"
		out.RawString(prefix[1:])
		if in.IsolatedElementHighlightConfigs == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v5, v6 := range in.IsolatedElementHighlightConfigs {
				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 SetShowIsolatedElementsParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay7(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetShowIsolatedElementsParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay7(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay8(in *jlexer.Lexer, out *SetShowHingeParams) {
	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 "hingeConfig":
			if in.IsNull() {
				in.Skip()
				out.HingeConfig = nil
			} else {
				if out.HingeConfig == nil {
					out.HingeConfig = new(HingeConfig)
				}
				(*out.HingeConfig).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay8(out *jwriter.Writer, in SetShowHingeParams) {
	out.RawByte('{')
	first := true
	_ = first
	if in.HingeConfig != nil {
		const prefix string = ",\"hingeConfig\":"
		first = false
		out.RawString(prefix[1:])
		(*in.HingeConfig).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetShowHingeParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay8(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay9(in *jlexer.Lexer, out *SetShowGridOverlaysParams) {
	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 "gridNodeHighlightConfigs":
			if in.IsNull() {
				in.Skip()
				out.GridNodeHighlightConfigs = nil
			} else {
				in.Delim('[')
				if out.GridNodeHighlightConfigs == nil {
					if !in.IsDelim(']') {
						out.GridNodeHighlightConfigs = make([]*GridNodeHighlightConfig, 0, 8)
					} else {
						out.GridNodeHighlightConfigs = []*GridNodeHighlightConfig{}
					}
				} else {
					out.GridNodeHighlightConfigs = (out.GridNodeHighlightConfigs)[:0]
				}
				for !in.IsDelim(']') {
					var v7 *GridNodeHighlightConfig
					if in.IsNull() {
						in.Skip()
						v7 = nil
					} else {
						if v7 == nil {
							v7 = new(GridNodeHighlightConfig)
						}
						(*v7).UnmarshalEasyJSON(in)
					}
					out.GridNodeHighlightConfigs = append(out.GridNodeHighlightConfigs, v7)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay9(out *jwriter.Writer, in SetShowGridOverlaysParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"gridNodeHighlightConfigs\":"
		out.RawString(prefix[1:])
		if in.GridNodeHighlightConfigs == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v8, v9 := range in.GridNodeHighlightConfigs {
				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 SetShowGridOverlaysParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay9(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetShowGridOverlaysParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay9(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay10(in *jlexer.Lexer, out *SetShowFlexOverlaysParams) {
	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 "flexNodeHighlightConfigs":
			if in.IsNull() {
				in.Skip()
				out.FlexNodeHighlightConfigs = nil
			} else {
				in.Delim('[')
				if out.FlexNodeHighlightConfigs == nil {
					if !in.IsDelim(']') {
						out.FlexNodeHighlightConfigs = make([]*FlexNodeHighlightConfig, 0, 8)
					} else {
						out.FlexNodeHighlightConfigs = []*FlexNodeHighlightConfig{}
					}
				} else {
					out.FlexNodeHighlightConfigs = (out.FlexNodeHighlightConfigs)[:0]
				}
				for !in.IsDelim(']') {
					var v10 *FlexNodeHighlightConfig
					if in.IsNull() {
						in.Skip()
						v10 = nil
					} else {
						if v10 == nil {
							v10 = new(FlexNodeHighlightConfig)
						}
						(*v10).UnmarshalEasyJSON(in)
					}
					out.FlexNodeHighlightConfigs = append(out.FlexNodeHighlightConfigs, v10)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay10(out *jwriter.Writer, in SetShowFlexOverlaysParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"flexNodeHighlightConfigs\":"
		out.RawString(prefix[1:])
		if in.FlexNodeHighlightConfigs == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v11, v12 := range in.FlexNodeHighlightConfigs {
				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 SetShowFlexOverlaysParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay10(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetShowFlexOverlaysParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay10(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay11(in *jlexer.Lexer, out *SetShowFPSCounterParams) {
	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 "show":
			out.Show = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay11(out *jwriter.Writer, in SetShowFPSCounterParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"show\":"
		out.RawString(prefix[1:])
		out.Bool(bool(in.Show))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetShowFPSCounterParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay11(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay12(in *jlexer.Lexer, out *SetShowDebugBordersParams) {
	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 "show":
			out.Show = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay12(out *jwriter.Writer, in SetShowDebugBordersParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"show\":"
		out.RawString(prefix[1:])
		out.Bool(bool(in.Show))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetShowDebugBordersParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay12(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay13(in *jlexer.Lexer, out *SetShowContainerQueryOverlaysParams) {
	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 "containerQueryHighlightConfigs":
			if in.IsNull() {
				in.Skip()
				out.ContainerQueryHighlightConfigs = nil
			} else {
				in.Delim('[')
				if out.ContainerQueryHighlightConfigs == nil {
					if !in.IsDelim(']') {
						out.ContainerQueryHighlightConfigs = make([]*ContainerQueryHighlightConfig, 0, 8)
					} else {
						out.ContainerQueryHighlightConfigs = []*ContainerQueryHighlightConfig{}
					}
				} else {
					out.ContainerQueryHighlightConfigs = (out.ContainerQueryHighlightConfigs)[:0]
				}
				for !in.IsDelim(']') {
					var v13 *ContainerQueryHighlightConfig
					if in.IsNull() {
						in.Skip()
						v13 = nil
					} else {
						if v13 == nil {
							v13 = new(ContainerQueryHighlightConfig)
						}
						(*v13).UnmarshalEasyJSON(in)
					}
					out.ContainerQueryHighlightConfigs = append(out.ContainerQueryHighlightConfigs, v13)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay13(out *jwriter.Writer, in SetShowContainerQueryOverlaysParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"containerQueryHighlightConfigs\":"
		out.RawString(prefix[1:])
		if in.ContainerQueryHighlightConfigs == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v14, v15 := range in.ContainerQueryHighlightConfigs {
				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 SetShowContainerQueryOverlaysParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay13(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetShowContainerQueryOverlaysParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay13(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay14(in *jlexer.Lexer, out *SetShowAdHighlightsParams) {
	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 "show":
			out.Show = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay14(out *jwriter.Writer, in SetShowAdHighlightsParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"show\":"
		out.RawString(prefix[1:])
		out.Bool(bool(in.Show))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetShowAdHighlightsParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay14(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay15(in *jlexer.Lexer, out *SetPausedInDebuggerMessageParams) {
	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())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay15(out *jwriter.Writer, in SetPausedInDebuggerMessageParams) {
	out.RawByte('{')
	first := true
	_ = first
	if in.Message != "" {
		const prefix string = ",\"message\":"
		first = false
		out.RawString(prefix[1:])
		out.String(string(in.Message))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetPausedInDebuggerMessageParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay15(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay16(in *jlexer.Lexer, out *SetInspectModeParams) {
	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)
		case "highlightConfig":
			if in.IsNull() {
				in.Skip()
				out.HighlightConfig = nil
			} else {
				if out.HighlightConfig == nil {
					out.HighlightConfig = new(HighlightConfig)
				}
				(*out.HighlightConfig).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay16(out *jwriter.Writer, in SetInspectModeParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"mode\":"
		out.RawString(prefix[1:])
		(in.Mode).MarshalEasyJSON(out)
	}
	if in.HighlightConfig != nil {
		const prefix string = ",\"highlightConfig\":"
		out.RawString(prefix)
		(*in.HighlightConfig).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetInspectModeParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay16(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay17(in *jlexer.Lexer, out *ScrollSnapHighlightConfig) {
	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 "scrollSnapContainerHighlightConfig":
			if in.IsNull() {
				in.Skip()
				out.ScrollSnapContainerHighlightConfig = nil
			} else {
				if out.ScrollSnapContainerHighlightConfig == nil {
					out.ScrollSnapContainerHighlightConfig = new(ScrollSnapContainerHighlightConfig)
				}
				(*out.ScrollSnapContainerHighlightConfig).UnmarshalEasyJSON(in)
			}
		case "nodeId":
			(out.NodeID).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay17(out *jwriter.Writer, in ScrollSnapHighlightConfig) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"scrollSnapContainerHighlightConfig\":"
		out.RawString(prefix[1:])
		if in.ScrollSnapContainerHighlightConfig == nil {
			out.RawString("null")
		} else {
			(*in.ScrollSnapContainerHighlightConfig).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"nodeId\":"
		out.RawString(prefix)
		out.Int64(int64(in.NodeID))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *ScrollSnapHighlightConfig) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay17(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay18(in *jlexer.Lexer, out *ScrollSnapContainerHighlightConfig) {
	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 "snapportBorder":
			if in.IsNull() {
				in.Skip()
				out.SnapportBorder = nil
			} else {
				if out.SnapportBorder == nil {
					out.SnapportBorder = new(LineStyle)
				}
				(*out.SnapportBorder).UnmarshalEasyJSON(in)
			}
		case "snapAreaBorder":
			if in.IsNull() {
				in.Skip()
				out.SnapAreaBorder = nil
			} else {
				if out.SnapAreaBorder == nil {
					out.SnapAreaBorder = new(LineStyle)
				}
				(*out.SnapAreaBorder).UnmarshalEasyJSON(in)
			}
		case "scrollMarginColor":
			if in.IsNull() {
				in.Skip()
				out.ScrollMarginColor = nil
			} else {
				if out.ScrollMarginColor == nil {
					out.ScrollMarginColor = new(cdp.RGBA)
				}
				(*out.ScrollMarginColor).UnmarshalEasyJSON(in)
			}
		case "scrollPaddingColor":
			if in.IsNull() {
				in.Skip()
				out.ScrollPaddingColor = nil
			} else {
				if out.ScrollPaddingColor == nil {
					out.ScrollPaddingColor = new(cdp.RGBA)
				}
				(*out.ScrollPaddingColor).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay18(out *jwriter.Writer, in ScrollSnapContainerHighlightConfig) {
	out.RawByte('{')
	first := true
	_ = first
	if in.SnapportBorder != nil {
		const prefix string = ",\"snapportBorder\":"
		first = false
		out.RawString(prefix[1:])
		(*in.SnapportBorder).MarshalEasyJSON(out)
	}
	if in.SnapAreaBorder != nil {
		const prefix string = ",\"snapAreaBorder\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.SnapAreaBorder).MarshalEasyJSON(out)
	}
	if in.ScrollMarginColor != nil {
		const prefix string = ",\"scrollMarginColor\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.ScrollMarginColor).MarshalEasyJSON(out)
	}
	if in.ScrollPaddingColor != nil {
		const prefix string = ",\"scrollPaddingColor\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.ScrollPaddingColor).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *ScrollSnapContainerHighlightConfig) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay18(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay19(in *jlexer.Lexer, out *LineStyle) {
	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 "color":
			if in.IsNull() {
				in.Skip()
				out.Color = nil
			} else {
				if out.Color == nil {
					out.Color = new(cdp.RGBA)
				}
				(*out.Color).UnmarshalEasyJSON(in)
			}
		case "pattern":
			(out.Pattern).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay19(out *jwriter.Writer, in LineStyle) {
	out.RawByte('{')
	first := true
	_ = first
	if in.Color != nil {
		const prefix string = ",\"color\":"
		first = false
		out.RawString(prefix[1:])
		(*in.Color).MarshalEasyJSON(out)
	}
	if in.Pattern != "" {
		const prefix string = ",\"pattern\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(in.Pattern).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *LineStyle) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay19(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay20(in *jlexer.Lexer, out *IsolationModeHighlightConfig) {
	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 "resizerColor":
			if in.IsNull() {
				in.Skip()
				out.ResizerColor = nil
			} else {
				if out.ResizerColor == nil {
					out.ResizerColor = new(cdp.RGBA)
				}
				(*out.ResizerColor).UnmarshalEasyJSON(in)
			}
		case "resizerHandleColor":
			if in.IsNull() {
				in.Skip()
				out.ResizerHandleColor = nil
			} else {
				if out.ResizerHandleColor == nil {
					out.ResizerHandleColor = new(cdp.RGBA)
				}
				(*out.ResizerHandleColor).UnmarshalEasyJSON(in)
			}
		case "maskColor":
			if in.IsNull() {
				in.Skip()
				out.MaskColor = nil
			} else {
				if out.MaskColor == nil {
					out.MaskColor = new(cdp.RGBA)
				}
				(*out.MaskColor).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay20(out *jwriter.Writer, in IsolationModeHighlightConfig) {
	out.RawByte('{')
	first := true
	_ = first
	if in.ResizerColor != nil {
		const prefix string = ",\"resizerColor\":"
		first = false
		out.RawString(prefix[1:])
		(*in.ResizerColor).MarshalEasyJSON(out)
	}
	if in.ResizerHandleColor != nil {
		const prefix string = ",\"resizerHandleColor\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.ResizerHandleColor).MarshalEasyJSON(out)
	}
	if in.MaskColor != nil {
		const prefix string = ",\"maskColor\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.MaskColor).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *IsolationModeHighlightConfig) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay20(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay21(in *jlexer.Lexer, out *IsolatedElementHighlightConfig) {
	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 "isolationModeHighlightConfig":
			if in.IsNull() {
				in.Skip()
				out.IsolationModeHighlightConfig = nil
			} else {
				if out.IsolationModeHighlightConfig == nil {
					out.IsolationModeHighlightConfig = new(IsolationModeHighlightConfig)
				}
				(*out.IsolationModeHighlightConfig).UnmarshalEasyJSON(in)
			}
		case "nodeId":
			(out.NodeID).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay21(out *jwriter.Writer, in IsolatedElementHighlightConfig) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"isolationModeHighlightConfig\":"
		out.RawString(prefix[1:])
		if in.IsolationModeHighlightConfig == nil {
			out.RawString("null")
		} else {
			(*in.IsolationModeHighlightConfig).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"nodeId\":"
		out.RawString(prefix)
		out.Int64(int64(in.NodeID))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *IsolatedElementHighlightConfig) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay21(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay22(in *jlexer.Lexer, out *HingeConfig) {
	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 "rect":
			if in.IsNull() {
				in.Skip()
				out.Rect = nil
			} else {
				if out.Rect == nil {
					out.Rect = new(dom.Rect)
				}
				(*out.Rect).UnmarshalEasyJSON(in)
			}
		case "contentColor":
			if in.IsNull() {
				in.Skip()
				out.ContentColor = nil
			} else {
				if out.ContentColor == nil {
					out.ContentColor = new(cdp.RGBA)
				}
				(*out.ContentColor).UnmarshalEasyJSON(in)
			}
		case "outlineColor":
			if in.IsNull() {
				in.Skip()
				out.OutlineColor = nil
			} else {
				if out.OutlineColor == nil {
					out.OutlineColor = new(cdp.RGBA)
				}
				(*out.OutlineColor).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay22(out *jwriter.Writer, in HingeConfig) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"rect\":"
		out.RawString(prefix[1:])
		if in.Rect == nil {
			out.RawString("null")
		} else {
			(*in.Rect).MarshalEasyJSON(out)
		}
	}
	if in.ContentColor != nil {
		const prefix string = ",\"contentColor\":"
		out.RawString(prefix)
		(*in.ContentColor).MarshalEasyJSON(out)
	}
	if in.OutlineColor != nil {
		const prefix string = ",\"outlineColor\":"
		out.RawString(prefix)
		(*in.OutlineColor).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *HingeConfig) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay22(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay23(in *jlexer.Lexer, out *HighlightSourceOrderParams) {
	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 "sourceOrderConfig":
			if in.IsNull() {
				in.Skip()
				out.SourceOrderConfig = nil
			} else {
				if out.SourceOrderConfig == nil {
					out.SourceOrderConfig = new(SourceOrderConfig)
				}
				(*out.SourceOrderConfig).UnmarshalEasyJSON(in)
			}
		case "nodeId":
			(out.NodeID).UnmarshalEasyJSON(in)
		case "backendNodeId":
			(out.BackendNodeID).UnmarshalEasyJSON(in)
		case "objectId":
			out.ObjectID = runtime.RemoteObjectID(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay23(out *jwriter.Writer, in HighlightSourceOrderParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"sourceOrderConfig\":"
		out.RawString(prefix[1:])
		if in.SourceOrderConfig == nil {
			out.RawString("null")
		} else {
			(*in.SourceOrderConfig).MarshalEasyJSON(out)
		}
	}
	if in.NodeID != 0 {
		const prefix string = ",\"nodeId\":"
		out.RawString(prefix)
		out.Int64(int64(in.NodeID))
	}
	if in.BackendNodeID != 0 {
		const prefix string = ",\"backendNodeId\":"
		out.RawString(prefix)
		out.Int64(int64(in.BackendNodeID))
	}
	if in.ObjectID != "" {
		const prefix string = ",\"objectId\":"
		out.RawString(prefix)
		out.String(string(in.ObjectID))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *HighlightSourceOrderParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay23(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay24(in *jlexer.Lexer, out *HighlightRectParams) {
	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 = int64(in.Int64())
		case "y":
			out.Y = int64(in.Int64())
		case "width":
			out.Width = int64(in.Int64())
		case "height":
			out.Height = int64(in.Int64())
		case "color":
			if in.IsNull() {
				in.Skip()
				out.Color = nil
			} else {
				if out.Color == nil {
					out.Color = new(cdp.RGBA)
				}
				(*out.Color).UnmarshalEasyJSON(in)
			}
		case "outlineColor":
			if in.IsNull() {
				in.Skip()
				out.OutlineColor = nil
			} else {
				if out.OutlineColor == nil {
					out.OutlineColor = new(cdp.RGBA)
				}
				(*out.OutlineColor).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay24(out *jwriter.Writer, in HighlightRectParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"x\":"
		out.RawString(prefix[1:])
		out.Int64(int64(in.X))
	}
	{
		const prefix string = ",\"y\":"
		out.RawString(prefix)
		out.Int64(int64(in.Y))
	}
	{
		const prefix string = ",\"width\":"
		out.RawString(prefix)
		out.Int64(int64(in.Width))
	}
	{
		const prefix string = ",\"height\":"
		out.RawString(prefix)
		out.Int64(int64(in.Height))
	}
	if in.Color != nil {
		const prefix string = ",\"color\":"
		out.RawString(prefix)
		(*in.Color).MarshalEasyJSON(out)
	}
	if in.OutlineColor != nil {
		const prefix string = ",\"outlineColor\":"
		out.RawString(prefix)
		(*in.OutlineColor).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *HighlightRectParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay24(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay25(in *jlexer.Lexer, out *HighlightQuadParams) {
	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 "quad":
			if in.IsNull() {
				in.Skip()
				out.Quad = nil
			} else {
				in.Delim('[')
				if out.Quad == nil {
					if !in.IsDelim(']') {
						out.Quad = make(dom.Quad, 0, 8)
					} else {
						out.Quad = dom.Quad{}
					}
				} else {
					out.Quad = (out.Quad)[:0]
				}
				for !in.IsDelim(']') {
					var v16 float64
					v16 = float64(in.Float64())
					out.Quad = append(out.Quad, v16)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "color":
			if in.IsNull() {
				in.Skip()
				out.Color = nil
			} else {
				if out.Color == nil {
					out.Color = new(cdp.RGBA)
				}
				(*out.Color).UnmarshalEasyJSON(in)
			}
		case "outlineColor":
			if in.IsNull() {
				in.Skip()
				out.OutlineColor = nil
			} else {
				if out.OutlineColor == nil {
					out.OutlineColor = new(cdp.RGBA)
				}
				(*out.OutlineColor).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay25(out *jwriter.Writer, in HighlightQuadParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"quad\":"
		out.RawString(prefix[1:])
		if in.Quad == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v17, v18 := range in.Quad {
				if v17 > 0 {
					out.RawByte(',')
				}
				out.Float64(float64(v18))
			}
			out.RawByte(']')
		}
	}
	if in.Color != nil {
		const prefix string = ",\"color\":"
		out.RawString(prefix)
		(*in.Color).MarshalEasyJSON(out)
	}
	if in.OutlineColor != nil {
		const prefix string = ",\"outlineColor\":"
		out.RawString(prefix)
		(*in.OutlineColor).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *HighlightQuadParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay25(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay26(in *jlexer.Lexer, out *HighlightNodeParams) {
	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 "highlightConfig":
			if in.IsNull() {
				in.Skip()
				out.HighlightConfig = nil
			} else {
				if out.HighlightConfig == nil {
					out.HighlightConfig = new(HighlightConfig)
				}
				(*out.HighlightConfig).UnmarshalEasyJSON(in)
			}
		case "nodeId":
			(out.NodeID).UnmarshalEasyJSON(in)
		case "backendNodeId":
			(out.BackendNodeID).UnmarshalEasyJSON(in)
		case "objectId":
			out.ObjectID = runtime.RemoteObjectID(in.String())
		case "selector":
			out.Selector = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay26(out *jwriter.Writer, in HighlightNodeParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"highlightConfig\":"
		out.RawString(prefix[1:])
		if in.HighlightConfig == nil {
			out.RawString("null")
		} else {
			(*in.HighlightConfig).MarshalEasyJSON(out)
		}
	}
	if in.NodeID != 0 {
		const prefix string = ",\"nodeId\":"
		out.RawString(prefix)
		out.Int64(int64(in.NodeID))
	}
	if in.BackendNodeID != 0 {
		const prefix string = ",\"backendNodeId\":"
		out.RawString(prefix)
		out.Int64(int64(in.BackendNodeID))
	}
	if in.ObjectID != "" {
		const prefix string = ",\"objectId\":"
		out.RawString(prefix)
		out.String(string(in.ObjectID))
	}
	if in.Selector != "" {
		const prefix string = ",\"selector\":"
		out.RawString(prefix)
		out.String(string(in.Selector))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *HighlightNodeParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay26(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay27(in *jlexer.Lexer, out *HighlightConfig) {
	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 "showInfo":
			out.ShowInfo = bool(in.Bool())
		case "showStyles":
			out.ShowStyles = bool(in.Bool())
		case "showRulers":
			out.ShowRulers = bool(in.Bool())
		case "showAccessibilityInfo":
			out.ShowAccessibilityInfo = bool(in.Bool())
		case "showExtensionLines":
			out.ShowExtensionLines = bool(in.Bool())
		case "contentColor":
			if in.IsNull() {
				in.Skip()
				out.ContentColor = nil
			} else {
				if out.ContentColor == nil {
					out.ContentColor = new(cdp.RGBA)
				}
				(*out.ContentColor).UnmarshalEasyJSON(in)
			}
		case "paddingColor":
			if in.IsNull() {
				in.Skip()
				out.PaddingColor = nil
			} else {
				if out.PaddingColor == nil {
					out.PaddingColor = new(cdp.RGBA)
				}
				(*out.PaddingColor).UnmarshalEasyJSON(in)
			}
		case "borderColor":
			if in.IsNull() {
				in.Skip()
				out.BorderColor = nil
			} else {
				if out.BorderColor == nil {
					out.BorderColor = new(cdp.RGBA)
				}
				(*out.BorderColor).UnmarshalEasyJSON(in)
			}
		case "marginColor":
			if in.IsNull() {
				in.Skip()
				out.MarginColor = nil
			} else {
				if out.MarginColor == nil {
					out.MarginColor = new(cdp.RGBA)
				}
				(*out.MarginColor).UnmarshalEasyJSON(in)
			}
		case "eventTargetColor":
			if in.IsNull() {
				in.Skip()
				out.EventTargetColor = nil
			} else {
				if out.EventTargetColor == nil {
					out.EventTargetColor = new(cdp.RGBA)
				}
				(*out.EventTargetColor).UnmarshalEasyJSON(in)
			}
		case "shapeColor":
			if in.IsNull() {
				in.Skip()
				out.ShapeColor = nil
			} else {
				if out.ShapeColor == nil {
					out.ShapeColor = new(cdp.RGBA)
				}
				(*out.ShapeColor).UnmarshalEasyJSON(in)
			}
		case "shapeMarginColor":
			if in.IsNull() {
				in.Skip()
				out.ShapeMarginColor = nil
			} else {
				if out.ShapeMarginColor == nil {
					out.ShapeMarginColor = new(cdp.RGBA)
				}
				(*out.ShapeMarginColor).UnmarshalEasyJSON(in)
			}
		case "cssGridColor":
			if in.IsNull() {
				in.Skip()
				out.CSSGridColor = nil
			} else {
				if out.CSSGridColor == nil {
					out.CSSGridColor = new(cdp.RGBA)
				}
				(*out.CSSGridColor).UnmarshalEasyJSON(in)
			}
		case "colorFormat":
			(out.ColorFormat).UnmarshalEasyJSON(in)
		case "gridHighlightConfig":
			if in.IsNull() {
				in.Skip()
				out.GridHighlightConfig = nil
			} else {
				if out.GridHighlightConfig == nil {
					out.GridHighlightConfig = new(GridHighlightConfig)
				}
				(*out.GridHighlightConfig).UnmarshalEasyJSON(in)
			}
		case "flexContainerHighlightConfig":
			if in.IsNull() {
				in.Skip()
				out.FlexContainerHighlightConfig = nil
			} else {
				if out.FlexContainerHighlightConfig == nil {
					out.FlexContainerHighlightConfig = new(FlexContainerHighlightConfig)
				}
				(*out.FlexContainerHighlightConfig).UnmarshalEasyJSON(in)
			}
		case "flexItemHighlightConfig":
			if in.IsNull() {
				in.Skip()
				out.FlexItemHighlightConfig = nil
			} else {
				if out.FlexItemHighlightConfig == nil {
					out.FlexItemHighlightConfig = new(FlexItemHighlightConfig)
				}
				(*out.FlexItemHighlightConfig).UnmarshalEasyJSON(in)
			}
		case "contrastAlgorithm":
			(out.ContrastAlgorithm).UnmarshalEasyJSON(in)
		case "containerQueryContainerHighlightConfig":
			if in.IsNull() {
				in.Skip()
				out.ContainerQueryContainerHighlightConfig = nil
			} else {
				if out.ContainerQueryContainerHighlightConfig == nil {
					out.ContainerQueryContainerHighlightConfig = new(ContainerQueryContainerHighlightConfig)
				}
				(*out.ContainerQueryContainerHighlightConfig).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay27(out *jwriter.Writer, in HighlightConfig) {
	out.RawByte('{')
	first := true
	_ = first
	if in.ShowInfo {
		const prefix string = ",\"showInfo\":"
		first = false
		out.RawString(prefix[1:])
		out.Bool(bool(in.ShowInfo))
	}
	if in.ShowStyles {
		const prefix string = ",\"showStyles\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.Bool(bool(in.ShowStyles))
	}
	if in.ShowRulers {
		const prefix string = ",\"showRulers\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.Bool(bool(in.ShowRulers))
	}
	if in.ShowAccessibilityInfo {
		const prefix string = ",\"showAccessibilityInfo\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.Bool(bool(in.ShowAccessibilityInfo))
	}
	if in.ShowExtensionLines {
		const prefix string = ",\"showExtensionLines\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.Bool(bool(in.ShowExtensionLines))
	}
	if in.ContentColor != nil {
		const prefix string = ",\"contentColor\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.ContentColor).MarshalEasyJSON(out)
	}
	if in.PaddingColor != nil {
		const prefix string = ",\"paddingColor\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.PaddingColor).MarshalEasyJSON(out)
	}
	if in.BorderColor != nil {
		const prefix string = ",\"borderColor\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.BorderColor).MarshalEasyJSON(out)
	}
	if in.MarginColor != nil {
		const prefix string = ",\"marginColor\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.MarginColor).MarshalEasyJSON(out)
	}
	if in.EventTargetColor != nil {
		const prefix string = ",\"eventTargetColor\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.EventTargetColor).MarshalEasyJSON(out)
	}
	if in.ShapeColor != nil {
		const prefix string = ",\"shapeColor\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.ShapeColor).MarshalEasyJSON(out)
	}
	if in.ShapeMarginColor != nil {
		const prefix string = ",\"shapeMarginColor\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.ShapeMarginColor).MarshalEasyJSON(out)
	}
	if in.CSSGridColor != nil {
		const prefix string = ",\"cssGridColor\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.CSSGridColor).MarshalEasyJSON(out)
	}
	if in.ColorFormat != "" {
		const prefix string = ",\"colorFormat\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(in.ColorFormat).MarshalEasyJSON(out)
	}
	if in.GridHighlightConfig != nil {
		const prefix string = ",\"gridHighlightConfig\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.GridHighlightConfig).MarshalEasyJSON(out)
	}
	if in.FlexContainerHighlightConfig != nil {
		const prefix string = ",\"flexContainerHighlightConfig\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.FlexContainerHighlightConfig).MarshalEasyJSON(out)
	}
	if in.FlexItemHighlightConfig != nil {
		const prefix string = ",\"flexItemHighlightConfig\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.FlexItemHighlightConfig).MarshalEasyJSON(out)
	}
	if in.ContrastAlgorithm != "" {
		const prefix string = ",\"contrastAlgorithm\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(in.ContrastAlgorithm).MarshalEasyJSON(out)
	}
	if in.ContainerQueryContainerHighlightConfig != nil {
		const prefix string = ",\"containerQueryContainerHighlightConfig\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.ContainerQueryContainerHighlightConfig).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *HighlightConfig) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay27(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay28(in *jlexer.Lexer, out *HideHighlightParams) {
	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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay28(out *jwriter.Writer, in HideHighlightParams) {
	out.RawByte('{')
	first := true
	_ = first
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *HideHighlightParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay28(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay29(in *jlexer.Lexer, out *GridNodeHighlightConfig) {
	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 "gridHighlightConfig":
			if in.IsNull() {
				in.Skip()
				out.GridHighlightConfig = nil
			} else {
				if out.GridHighlightConfig == nil {
					out.GridHighlightConfig = new(GridHighlightConfig)
				}
				(*out.GridHighlightConfig).UnmarshalEasyJSON(in)
			}
		case "nodeId":
			(out.NodeID).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay29(out *jwriter.Writer, in GridNodeHighlightConfig) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"gridHighlightConfig\":"
		out.RawString(prefix[1:])
		if in.GridHighlightConfig == nil {
			out.RawString("null")
		} else {
			(*in.GridHighlightConfig).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"nodeId\":"
		out.RawString(prefix)
		out.Int64(int64(in.NodeID))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GridNodeHighlightConfig) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay29(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay30(in *jlexer.Lexer, out *GridHighlightConfig) {
	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 "showGridExtensionLines":
			out.ShowGridExtensionLines = bool(in.Bool())
		case "showPositiveLineNumbers":
			out.ShowPositiveLineNumbers = bool(in.Bool())
		case "showNegativeLineNumbers":
			out.ShowNegativeLineNumbers = bool(in.Bool())
		case "showAreaNames":
			out.ShowAreaNames = bool(in.Bool())
		case "showLineNames":
			out.ShowLineNames = bool(in.Bool())
		case "showTrackSizes":
			out.ShowTrackSizes = bool(in.Bool())
		case "gridBorderColor":
			if in.IsNull() {
				in.Skip()
				out.GridBorderColor = nil
			} else {
				if out.GridBorderColor == nil {
					out.GridBorderColor = new(cdp.RGBA)
				}
				(*out.GridBorderColor).UnmarshalEasyJSON(in)
			}
		case "rowLineColor":
			if in.IsNull() {
				in.Skip()
				out.RowLineColor = nil
			} else {
				if out.RowLineColor == nil {
					out.RowLineColor = new(cdp.RGBA)
				}
				(*out.RowLineColor).UnmarshalEasyJSON(in)
			}
		case "columnLineColor":
			if in.IsNull() {
				in.Skip()
				out.ColumnLineColor = nil
			} else {
				if out.ColumnLineColor == nil {
					out.ColumnLineColor = new(cdp.RGBA)
				}
				(*out.ColumnLineColor).UnmarshalEasyJSON(in)
			}
		case "gridBorderDash":
			out.GridBorderDash = bool(in.Bool())
		case "rowLineDash":
			out.RowLineDash = bool(in.Bool())
		case "columnLineDash":
			out.ColumnLineDash = bool(in.Bool())
		case "rowGapColor":
			if in.IsNull() {
				in.Skip()
				out.RowGapColor = nil
			} else {
				if out.RowGapColor == nil {
					out.RowGapColor = new(cdp.RGBA)
				}
				(*out.RowGapColor).UnmarshalEasyJSON(in)
			}
		case "rowHatchColor":
			if in.IsNull() {
				in.Skip()
				out.RowHatchColor = nil
			} else {
				if out.RowHatchColor == nil {
					out.RowHatchColor = new(cdp.RGBA)
				}
				(*out.RowHatchColor).UnmarshalEasyJSON(in)
			}
		case "columnGapColor":
			if in.IsNull() {
				in.Skip()
				out.ColumnGapColor = nil
			} else {
				if out.ColumnGapColor == nil {
					out.ColumnGapColor = new(cdp.RGBA)
				}
				(*out.ColumnGapColor).UnmarshalEasyJSON(in)
			}
		case "columnHatchColor":
			if in.IsNull() {
				in.Skip()
				out.ColumnHatchColor = nil
			} else {
				if out.ColumnHatchColor == nil {
					out.ColumnHatchColor = new(cdp.RGBA)
				}
				(*out.ColumnHatchColor).UnmarshalEasyJSON(in)
			}
		case "areaBorderColor":
			if in.IsNull() {
				in.Skip()
				out.AreaBorderColor = nil
			} else {
				if out.AreaBorderColor == nil {
					out.AreaBorderColor = new(cdp.RGBA)
				}
				(*out.AreaBorderColor).UnmarshalEasyJSON(in)
			}
		case "gridBackgroundColor":
			if in.IsNull() {
				in.Skip()
				out.GridBackgroundColor = nil
			} else {
				if out.GridBackgroundColor == nil {
					out.GridBackgroundColor = new(cdp.RGBA)
				}
				(*out.GridBackgroundColor).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay30(out *jwriter.Writer, in GridHighlightConfig) {
	out.RawByte('{')
	first := true
	_ = first
	if in.ShowGridExtensionLines {
		const prefix string = ",\"showGridExtensionLines\":"
		first = false
		out.RawString(prefix[1:])
		out.Bool(bool(in.ShowGridExtensionLines))
	}
	if in.ShowPositiveLineNumbers {
		const prefix string = ",\"showPositiveLineNumbers\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.Bool(bool(in.ShowPositiveLineNumbers))
	}
	if in.ShowNegativeLineNumbers {
		const prefix string = ",\"showNegativeLineNumbers\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.Bool(bool(in.ShowNegativeLineNumbers))
	}
	if in.ShowAreaNames {
		const prefix string = ",\"showAreaNames\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.Bool(bool(in.ShowAreaNames))
	}
	if in.ShowLineNames {
		const prefix string = ",\"showLineNames\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.Bool(bool(in.ShowLineNames))
	}
	if in.ShowTrackSizes {
		const prefix string = ",\"showTrackSizes\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.Bool(bool(in.ShowTrackSizes))
	}
	if in.GridBorderColor != nil {
		const prefix string = ",\"gridBorderColor\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.GridBorderColor).MarshalEasyJSON(out)
	}
	if in.RowLineColor != nil {
		const prefix string = ",\"rowLineColor\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.RowLineColor).MarshalEasyJSON(out)
	}
	if in.ColumnLineColor != nil {
		const prefix string = ",\"columnLineColor\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.ColumnLineColor).MarshalEasyJSON(out)
	}
	if in.GridBorderDash {
		const prefix string = ",\"gridBorderDash\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.Bool(bool(in.GridBorderDash))
	}
	if in.RowLineDash {
		const prefix string = ",\"rowLineDash\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.Bool(bool(in.RowLineDash))
	}
	if in.ColumnLineDash {
		const prefix string = ",\"columnLineDash\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.Bool(bool(in.ColumnLineDash))
	}
	if in.RowGapColor != nil {
		const prefix string = ",\"rowGapColor\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.RowGapColor).MarshalEasyJSON(out)
	}
	if in.RowHatchColor != nil {
		const prefix string = ",\"rowHatchColor\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.RowHatchColor).MarshalEasyJSON(out)
	}
	if in.ColumnGapColor != nil {
		const prefix string = ",\"columnGapColor\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.ColumnGapColor).MarshalEasyJSON(out)
	}
	if in.ColumnHatchColor != nil {
		const prefix string = ",\"columnHatchColor\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.ColumnHatchColor).MarshalEasyJSON(out)
	}
	if in.AreaBorderColor != nil {
		const prefix string = ",\"areaBorderColor\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.AreaBorderColor).MarshalEasyJSON(out)
	}
	if in.GridBackgroundColor != nil {
		const prefix string = ",\"gridBackgroundColor\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.GridBackgroundColor).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GridHighlightConfig) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay30(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay31(in *jlexer.Lexer, out *GetSourceOrderHighlightObjectForTestReturns) {
	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 "highlight":
			(out.Highlight).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay31(out *jwriter.Writer, in GetSourceOrderHighlightObjectForTestReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if (in.Highlight).IsDefined() {
		const prefix string = ",\"highlight\":"
		first = false
		out.RawString(prefix[1:])
		(in.Highlight).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetSourceOrderHighlightObjectForTestReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay31(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay32(in *jlexer.Lexer, out *GetSourceOrderHighlightObjectForTestParams) {
	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 "nodeId":
			(out.NodeID).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay32(out *jwriter.Writer, in GetSourceOrderHighlightObjectForTestParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"nodeId\":"
		out.RawString(prefix[1:])
		out.Int64(int64(in.NodeID))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetSourceOrderHighlightObjectForTestParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay32(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay33(in *jlexer.Lexer, out *GetHighlightObjectForTestReturns) {
	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 "highlight":
			(out.Highlight).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay33(out *jwriter.Writer, in GetHighlightObjectForTestReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if (in.Highlight).IsDefined() {
		const prefix string = ",\"highlight\":"
		first = false
		out.RawString(prefix[1:])
		(in.Highlight).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetHighlightObjectForTestReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay33(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay34(in *jlexer.Lexer, out *GetHighlightObjectForTestParams) {
	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 "nodeId":
			(out.NodeID).UnmarshalEasyJSON(in)
		case "includeDistance":
			out.IncludeDistance = bool(in.Bool())
		case "includeStyle":
			out.IncludeStyle = bool(in.Bool())
		case "colorFormat":
			(out.ColorFormat).UnmarshalEasyJSON(in)
		case "showAccessibilityInfo":
			out.ShowAccessibilityInfo = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay34(out *jwriter.Writer, in GetHighlightObjectForTestParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"nodeId\":"
		out.RawString(prefix[1:])
		out.Int64(int64(in.NodeID))
	}
	if in.IncludeDistance {
		const prefix string = ",\"includeDistance\":"
		out.RawString(prefix)
		out.Bool(bool(in.IncludeDistance))
	}
	if in.IncludeStyle {
		const prefix string = ",\"includeStyle\":"
		out.RawString(prefix)
		out.Bool(bool(in.IncludeStyle))
	}
	if in.ColorFormat != "" {
		const prefix string = ",\"colorFormat\":"
		out.RawString(prefix)
		(in.ColorFormat).MarshalEasyJSON(out)
	}
	if in.ShowAccessibilityInfo {
		const prefix string = ",\"showAccessibilityInfo\":"
		out.RawString(prefix)
		out.Bool(bool(in.ShowAccessibilityInfo))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetHighlightObjectForTestParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay34(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay35(in *jlexer.Lexer, out *GetGridHighlightObjectsForTestReturns) {
	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 "highlights":
			(out.Highlights).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay35(out *jwriter.Writer, in GetGridHighlightObjectsForTestReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if (in.Highlights).IsDefined() {
		const prefix string = ",\"highlights\":"
		first = false
		out.RawString(prefix[1:])
		(in.Highlights).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetGridHighlightObjectsForTestReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay35(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay36(in *jlexer.Lexer, out *GetGridHighlightObjectsForTestParams) {
	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 "nodeIds":
			if in.IsNull() {
				in.Skip()
				out.NodeIDs = nil
			} else {
				in.Delim('[')
				if out.NodeIDs == nil {
					if !in.IsDelim(']') {
						out.NodeIDs = make([]cdp.NodeID, 0, 8)
					} else {
						out.NodeIDs = []cdp.NodeID{}
					}
				} else {
					out.NodeIDs = (out.NodeIDs)[:0]
				}
				for !in.IsDelim(']') {
					var v19 cdp.NodeID
					(v19).UnmarshalEasyJSON(in)
					out.NodeIDs = append(out.NodeIDs, v19)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay36(out *jwriter.Writer, in GetGridHighlightObjectsForTestParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"nodeIds\":"
		out.RawString(prefix[1:])
		if in.NodeIDs == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v20, v21 := range in.NodeIDs {
				if v20 > 0 {
					out.RawByte(',')
				}
				out.Int64(int64(v21))
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetGridHighlightObjectsForTestParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay36(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay37(in *jlexer.Lexer, out *FlexNodeHighlightConfig) {
	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 "flexContainerHighlightConfig":
			if in.IsNull() {
				in.Skip()
				out.FlexContainerHighlightConfig = nil
			} else {
				if out.FlexContainerHighlightConfig == nil {
					out.FlexContainerHighlightConfig = new(FlexContainerHighlightConfig)
				}
				(*out.FlexContainerHighlightConfig).UnmarshalEasyJSON(in)
			}
		case "nodeId":
			(out.NodeID).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay37(out *jwriter.Writer, in FlexNodeHighlightConfig) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"flexContainerHighlightConfig\":"
		out.RawString(prefix[1:])
		if in.FlexContainerHighlightConfig == nil {
			out.RawString("null")
		} else {
			(*in.FlexContainerHighlightConfig).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"nodeId\":"
		out.RawString(prefix)
		out.Int64(int64(in.NodeID))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *FlexNodeHighlightConfig) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay37(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay38(in *jlexer.Lexer, out *FlexItemHighlightConfig) {
	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 "baseSizeBox":
			if in.IsNull() {
				in.Skip()
				out.BaseSizeBox = nil
			} else {
				if out.BaseSizeBox == nil {
					out.BaseSizeBox = new(BoxStyle)
				}
				(*out.BaseSizeBox).UnmarshalEasyJSON(in)
			}
		case "baseSizeBorder":
			if in.IsNull() {
				in.Skip()
				out.BaseSizeBorder = nil
			} else {
				if out.BaseSizeBorder == nil {
					out.BaseSizeBorder = new(LineStyle)
				}
				(*out.BaseSizeBorder).UnmarshalEasyJSON(in)
			}
		case "flexibilityArrow":
			if in.IsNull() {
				in.Skip()
				out.FlexibilityArrow = nil
			} else {
				if out.FlexibilityArrow == nil {
					out.FlexibilityArrow = new(LineStyle)
				}
				(*out.FlexibilityArrow).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay38(out *jwriter.Writer, in FlexItemHighlightConfig) {
	out.RawByte('{')
	first := true
	_ = first
	if in.BaseSizeBox != nil {
		const prefix string = ",\"baseSizeBox\":"
		first = false
		out.RawString(prefix[1:])
		(*in.BaseSizeBox).MarshalEasyJSON(out)
	}
	if in.BaseSizeBorder != nil {
		const prefix string = ",\"baseSizeBorder\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.BaseSizeBorder).MarshalEasyJSON(out)
	}
	if in.FlexibilityArrow != nil {
		const prefix string = ",\"flexibilityArrow\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.FlexibilityArrow).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *FlexItemHighlightConfig) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay38(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay39(in *jlexer.Lexer, out *FlexContainerHighlightConfig) {
	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 "containerBorder":
			if in.IsNull() {
				in.Skip()
				out.ContainerBorder = nil
			} else {
				if out.ContainerBorder == nil {
					out.ContainerBorder = new(LineStyle)
				}
				(*out.ContainerBorder).UnmarshalEasyJSON(in)
			}
		case "lineSeparator":
			if in.IsNull() {
				in.Skip()
				out.LineSeparator = nil
			} else {
				if out.LineSeparator == nil {
					out.LineSeparator = new(LineStyle)
				}
				(*out.LineSeparator).UnmarshalEasyJSON(in)
			}
		case "itemSeparator":
			if in.IsNull() {
				in.Skip()
				out.ItemSeparator = nil
			} else {
				if out.ItemSeparator == nil {
					out.ItemSeparator = new(LineStyle)
				}
				(*out.ItemSeparator).UnmarshalEasyJSON(in)
			}
		case "mainDistributedSpace":
			if in.IsNull() {
				in.Skip()
				out.MainDistributedSpace = nil
			} else {
				if out.MainDistributedSpace == nil {
					out.MainDistributedSpace = new(BoxStyle)
				}
				(*out.MainDistributedSpace).UnmarshalEasyJSON(in)
			}
		case "crossDistributedSpace":
			if in.IsNull() {
				in.Skip()
				out.CrossDistributedSpace = nil
			} else {
				if out.CrossDistributedSpace == nil {
					out.CrossDistributedSpace = new(BoxStyle)
				}
				(*out.CrossDistributedSpace).UnmarshalEasyJSON(in)
			}
		case "rowGapSpace":
			if in.IsNull() {
				in.Skip()
				out.RowGapSpace = nil
			} else {
				if out.RowGapSpace == nil {
					out.RowGapSpace = new(BoxStyle)
				}
				(*out.RowGapSpace).UnmarshalEasyJSON(in)
			}
		case "columnGapSpace":
			if in.IsNull() {
				in.Skip()
				out.ColumnGapSpace = nil
			} else {
				if out.ColumnGapSpace == nil {
					out.ColumnGapSpace = new(BoxStyle)
				}
				(*out.ColumnGapSpace).UnmarshalEasyJSON(in)
			}
		case "crossAlignment":
			if in.IsNull() {
				in.Skip()
				out.CrossAlignment = nil
			} else {
				if out.CrossAlignment == nil {
					out.CrossAlignment = new(LineStyle)
				}
				(*out.CrossAlignment).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay39(out *jwriter.Writer, in FlexContainerHighlightConfig) {
	out.RawByte('{')
	first := true
	_ = first
	if in.ContainerBorder != nil {
		const prefix string = ",\"containerBorder\":"
		first = false
		out.RawString(prefix[1:])
		(*in.ContainerBorder).MarshalEasyJSON(out)
	}
	if in.LineSeparator != nil {
		const prefix string = ",\"lineSeparator\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.LineSeparator).MarshalEasyJSON(out)
	}
	if in.ItemSeparator != nil {
		const prefix string = ",\"itemSeparator\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.ItemSeparator).MarshalEasyJSON(out)
	}
	if in.MainDistributedSpace != nil {
		const prefix string = ",\"mainDistributedSpace\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.MainDistributedSpace).MarshalEasyJSON(out)
	}
	if in.CrossDistributedSpace != nil {
		const prefix string = ",\"crossDistributedSpace\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.CrossDistributedSpace).MarshalEasyJSON(out)
	}
	if in.RowGapSpace != nil {
		const prefix string = ",\"rowGapSpace\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.RowGapSpace).MarshalEasyJSON(out)
	}
	if in.ColumnGapSpace != nil {
		const prefix string = ",\"columnGapSpace\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.ColumnGapSpace).MarshalEasyJSON(out)
	}
	if in.CrossAlignment != nil {
		const prefix string = ",\"crossAlignment\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.CrossAlignment).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *FlexContainerHighlightConfig) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay39(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay40(in *jlexer.Lexer, out *EventScreenshotRequested) {
	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 "viewport":
			if in.IsNull() {
				in.Skip()
				out.Viewport = nil
			} else {
				if out.Viewport == nil {
					out.Viewport = new(page.Viewport)
				}
				(*out.Viewport).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay40(out *jwriter.Writer, in EventScreenshotRequested) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"viewport\":"
		out.RawString(prefix[1:])
		if in.Viewport == nil {
			out.RawString("null")
		} else {
			(*in.Viewport).MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventScreenshotRequested) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay40(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay41(in *jlexer.Lexer, out *EventNodeHighlightRequested) {
	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 "nodeId":
			(out.NodeID).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay41(out *jwriter.Writer, in EventNodeHighlightRequested) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"nodeId\":"
		out.RawString(prefix[1:])
		out.Int64(int64(in.NodeID))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventNodeHighlightRequested) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay41(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay42(in *jlexer.Lexer, out *EventInspectNodeRequested) {
	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 "backendNodeId":
			(out.BackendNodeID).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay42(out *jwriter.Writer, in EventInspectNodeRequested) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"backendNodeId\":"
		out.RawString(prefix[1:])
		out.Int64(int64(in.BackendNodeID))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventInspectNodeRequested) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay42(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay43(in *jlexer.Lexer, out *EventInspectModeCanceled) {
	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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay43(out *jwriter.Writer, in EventInspectModeCanceled) {
	out.RawByte('{')
	first := true
	_ = first
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventInspectModeCanceled) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay43(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay44(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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay44(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay44(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EnableParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay44(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay45(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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay45(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay45(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *DisableParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay45(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay46(in *jlexer.Lexer, out *ContainerQueryHighlightConfig) {
	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 "containerQueryContainerHighlightConfig":
			if in.IsNull() {
				in.Skip()
				out.ContainerQueryContainerHighlightConfig = nil
			} else {
				if out.ContainerQueryContainerHighlightConfig == nil {
					out.ContainerQueryContainerHighlightConfig = new(ContainerQueryContainerHighlightConfig)
				}
				(*out.ContainerQueryContainerHighlightConfig).UnmarshalEasyJSON(in)
			}
		case "nodeId":
			(out.NodeID).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay46(out *jwriter.Writer, in ContainerQueryHighlightConfig) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"containerQueryContainerHighlightConfig\":"
		out.RawString(prefix[1:])
		if in.ContainerQueryContainerHighlightConfig == nil {
			out.RawString("null")
		} else {
			(*in.ContainerQueryContainerHighlightConfig).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"nodeId\":"
		out.RawString(prefix)
		out.Int64(int64(in.NodeID))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *ContainerQueryHighlightConfig) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay46(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay47(in *jlexer.Lexer, out *ContainerQueryContainerHighlightConfig) {
	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 "containerBorder":
			if in.IsNull() {
				in.Skip()
				out.ContainerBorder = nil
			} else {
				if out.ContainerBorder == nil {
					out.ContainerBorder = new(LineStyle)
				}
				(*out.ContainerBorder).UnmarshalEasyJSON(in)
			}
		case "descendantBorder":
			if in.IsNull() {
				in.Skip()
				out.DescendantBorder = nil
			} else {
				if out.DescendantBorder == nil {
					out.DescendantBorder = new(LineStyle)
				}
				(*out.DescendantBorder).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay47(out *jwriter.Writer, in ContainerQueryContainerHighlightConfig) {
	out.RawByte('{')
	first := true
	_ = first
	if in.ContainerBorder != nil {
		const prefix string = ",\"containerBorder\":"
		first = false
		out.RawString(prefix[1:])
		(*in.ContainerBorder).MarshalEasyJSON(out)
	}
	if in.DescendantBorder != nil {
		const prefix string = ",\"descendantBorder\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.DescendantBorder).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *ContainerQueryContainerHighlightConfig) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay47(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoOverlay48(in *jlexer.Lexer, out *BoxStyle) {
	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 "fillColor":
			if in.IsNull() {
				in.Skip()
				out.FillColor = nil
			} else {
				if out.FillColor == nil {
					out.FillColor = new(cdp.RGBA)
				}
				(*out.FillColor).UnmarshalEasyJSON(in)
			}
		case "hatchColor":
			if in.IsNull() {
				in.Skip()
				out.HatchColor = nil
			} else {
				if out.HatchColor == nil {
					out.HatchColor = new(cdp.RGBA)
				}
				(*out.HatchColor).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoOverlay48(out *jwriter.Writer, in BoxStyle) {
	out.RawByte('{')
	first := true
	_ = first
	if in.FillColor != nil {
		const prefix string = ",\"fillColor\":"
		first = false
		out.RawString(prefix[1:])
		(*in.FillColor).MarshalEasyJSON(out)
	}
	if in.HatchColor != nil {
		const prefix string = ",\"hatchColor\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.HatchColor).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

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