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

package css

import (
	json "encoding/json"
	cdp "github.com/chromedp/cdproto/cdp"
	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 easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss(in *jlexer.Lexer, out *Value) {
	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 "text":
			out.Text = string(in.String())
		case "range":
			if in.IsNull() {
				in.Skip()
				out.Range = nil
			} else {
				if out.Range == nil {
					out.Range = new(SourceRange)
				}
				(*out.Range).UnmarshalEasyJSON(in)
			}
		case "specificity":
			if in.IsNull() {
				in.Skip()
				out.Specificity = nil
			} else {
				if out.Specificity == nil {
					out.Specificity = new(Specificity)
				}
				(*out.Specificity).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss(out *jwriter.Writer, in Value) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"text\":"
		out.RawString(prefix[1:])
		out.String(string(in.Text))
	}
	if in.Range != nil {
		const prefix string = ",\"range\":"
		out.RawString(prefix)
		(*in.Range).MarshalEasyJSON(out)
	}
	if in.Specificity != nil {
		const prefix string = ",\"specificity\":"
		out.RawString(prefix)
		(*in.Specificity).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *Value) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss1(in *jlexer.Lexer, out *TryRule) {
	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 "styleSheetId":
			out.StyleSheetID = StyleSheetID(in.String())
		case "origin":
			(out.Origin).UnmarshalEasyJSON(in)
		case "style":
			if in.IsNull() {
				in.Skip()
				out.Style = nil
			} else {
				if out.Style == nil {
					out.Style = new(Style)
				}
				(*out.Style).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss1(out *jwriter.Writer, in TryRule) {
	out.RawByte('{')
	first := true
	_ = first
	if in.StyleSheetID != "" {
		const prefix string = ",\"styleSheetId\":"
		first = false
		out.RawString(prefix[1:])
		out.String(string(in.StyleSheetID))
	}
	{
		const prefix string = ",\"origin\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(in.Origin).MarshalEasyJSON(out)
	}
	{
		const prefix string = ",\"style\":"
		out.RawString(prefix)
		if in.Style == nil {
			out.RawString("null")
		} else {
			(*in.Style).MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

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

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

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

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *TrackComputedStyleUpdatesParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss2(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss3(in *jlexer.Lexer, out *TakeCoverageDeltaReturns) {
	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 "coverage":
			if in.IsNull() {
				in.Skip()
				out.Coverage = nil
			} else {
				in.Delim('[')
				if out.Coverage == nil {
					if !in.IsDelim(']') {
						out.Coverage = make([]*RuleUsage, 0, 8)
					} else {
						out.Coverage = []*RuleUsage{}
					}
				} else {
					out.Coverage = (out.Coverage)[:0]
				}
				for !in.IsDelim(']') {
					var v4 *RuleUsage
					if in.IsNull() {
						in.Skip()
						v4 = nil
					} else {
						if v4 == nil {
							v4 = new(RuleUsage)
						}
						(*v4).UnmarshalEasyJSON(in)
					}
					out.Coverage = append(out.Coverage, v4)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "timestamp":
			out.Timestamp = float64(in.Float64())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss3(out *jwriter.Writer, in TakeCoverageDeltaReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if len(in.Coverage) != 0 {
		const prefix string = ",\"coverage\":"
		first = false
		out.RawString(prefix[1:])
		{
			out.RawByte('[')
			for v5, v6 := range in.Coverage {
				if v5 > 0 {
					out.RawByte(',')
				}
				if v6 == nil {
					out.RawString("null")
				} else {
					(*v6).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	if in.Timestamp != 0 {
		const prefix string = ",\"timestamp\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.Float64(float64(in.Timestamp))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *TakeCoverageDeltaReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss3(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss4(in *jlexer.Lexer, out *TakeCoverageDeltaParams) {
	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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss4(out *jwriter.Writer, in TakeCoverageDeltaParams) {
	out.RawByte('{')
	first := true
	_ = first
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *TakeCoverageDeltaParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss4(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss5(in *jlexer.Lexer, out *TakeComputedStyleUpdatesReturns) {
	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 v7 cdp.NodeID
					(v7).UnmarshalEasyJSON(in)
					out.NodeIDs = append(out.NodeIDs, v7)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss5(out *jwriter.Writer, in TakeComputedStyleUpdatesReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if len(in.NodeIDs) != 0 {
		const prefix string = ",\"nodeIds\":"
		first = false
		out.RawString(prefix[1:])
		{
			out.RawByte('[')
			for v8, v9 := range in.NodeIDs {
				if v8 > 0 {
					out.RawByte(',')
				}
				out.Int64(int64(v9))
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *TakeComputedStyleUpdatesReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss5(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss6(in *jlexer.Lexer, out *TakeComputedStyleUpdatesParams) {
	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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss6(out *jwriter.Writer, in TakeComputedStyleUpdatesParams) {
	out.RawByte('{')
	first := true
	_ = first
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *TakeComputedStyleUpdatesParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss6(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss7(in *jlexer.Lexer, out *Supports) {
	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 "text":
			out.Text = string(in.String())
		case "active":
			out.Active = bool(in.Bool())
		case "range":
			if in.IsNull() {
				in.Skip()
				out.Range = nil
			} else {
				if out.Range == nil {
					out.Range = new(SourceRange)
				}
				(*out.Range).UnmarshalEasyJSON(in)
			}
		case "styleSheetId":
			out.StyleSheetID = StyleSheetID(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss7(out *jwriter.Writer, in Supports) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"text\":"
		out.RawString(prefix[1:])
		out.String(string(in.Text))
	}
	{
		const prefix string = ",\"active\":"
		out.RawString(prefix)
		out.Bool(bool(in.Active))
	}
	if in.Range != nil {
		const prefix string = ",\"range\":"
		out.RawString(prefix)
		(*in.Range).MarshalEasyJSON(out)
	}
	if in.StyleSheetID != "" {
		const prefix string = ",\"styleSheetId\":"
		out.RawString(prefix)
		out.String(string(in.StyleSheetID))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *Supports) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss7(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss8(in *jlexer.Lexer, out *StyleSheetHeader) {
	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 "styleSheetId":
			out.StyleSheetID = StyleSheetID(in.String())
		case "frameId":
			(out.FrameID).UnmarshalEasyJSON(in)
		case "sourceURL":
			out.SourceURL = string(in.String())
		case "sourceMapURL":
			out.SourceMapURL = string(in.String())
		case "origin":
			(out.Origin).UnmarshalEasyJSON(in)
		case "title":
			out.Title = string(in.String())
		case "ownerNode":
			(out.OwnerNode).UnmarshalEasyJSON(in)
		case "disabled":
			out.Disabled = bool(in.Bool())
		case "hasSourceURL":
			out.HasSourceURL = bool(in.Bool())
		case "isInline":
			out.IsInline = bool(in.Bool())
		case "isMutable":
			out.IsMutable = bool(in.Bool())
		case "isConstructed":
			out.IsConstructed = bool(in.Bool())
		case "startLine":
			out.StartLine = float64(in.Float64())
		case "startColumn":
			out.StartColumn = float64(in.Float64())
		case "length":
			out.Length = float64(in.Float64())
		case "endLine":
			out.EndLine = float64(in.Float64())
		case "endColumn":
			out.EndColumn = float64(in.Float64())
		case "loadingFailed":
			out.LoadingFailed = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss8(out *jwriter.Writer, in StyleSheetHeader) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"styleSheetId\":"
		out.RawString(prefix[1:])
		out.String(string(in.StyleSheetID))
	}
	{
		const prefix string = ",\"frameId\":"
		out.RawString(prefix)
		out.String(string(in.FrameID))
	}
	{
		const prefix string = ",\"sourceURL\":"
		out.RawString(prefix)
		out.String(string(in.SourceURL))
	}
	if in.SourceMapURL != "" {
		const prefix string = ",\"sourceMapURL\":"
		out.RawString(prefix)
		out.String(string(in.SourceMapURL))
	}
	{
		const prefix string = ",\"origin\":"
		out.RawString(prefix)
		(in.Origin).MarshalEasyJSON(out)
	}
	{
		const prefix string = ",\"title\":"
		out.RawString(prefix)
		out.String(string(in.Title))
	}
	if in.OwnerNode != 0 {
		const prefix string = ",\"ownerNode\":"
		out.RawString(prefix)
		out.Int64(int64(in.OwnerNode))
	}
	{
		const prefix string = ",\"disabled\":"
		out.RawString(prefix)
		out.Bool(bool(in.Disabled))
	}
	if in.HasSourceURL {
		const prefix string = ",\"hasSourceURL\":"
		out.RawString(prefix)
		out.Bool(bool(in.HasSourceURL))
	}
	{
		const prefix string = ",\"isInline\":"
		out.RawString(prefix)
		out.Bool(bool(in.IsInline))
	}
	{
		const prefix string = ",\"isMutable\":"
		out.RawString(prefix)
		out.Bool(bool(in.IsMutable))
	}
	{
		const prefix string = ",\"isConstructed\":"
		out.RawString(prefix)
		out.Bool(bool(in.IsConstructed))
	}
	{
		const prefix string = ",\"startLine\":"
		out.RawString(prefix)
		out.Float64(float64(in.StartLine))
	}
	{
		const prefix string = ",\"startColumn\":"
		out.RawString(prefix)
		out.Float64(float64(in.StartColumn))
	}
	{
		const prefix string = ",\"length\":"
		out.RawString(prefix)
		out.Float64(float64(in.Length))
	}
	{
		const prefix string = ",\"endLine\":"
		out.RawString(prefix)
		out.Float64(float64(in.EndLine))
	}
	{
		const prefix string = ",\"endColumn\":"
		out.RawString(prefix)
		out.Float64(float64(in.EndColumn))
	}
	if in.LoadingFailed {
		const prefix string = ",\"loadingFailed\":"
		out.RawString(prefix)
		out.Bool(bool(in.LoadingFailed))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *StyleSheetHeader) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss8(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss9(in *jlexer.Lexer, out *StyleDeclarationEdit) {
	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 "styleSheetId":
			out.StyleSheetID = StyleSheetID(in.String())
		case "range":
			if in.IsNull() {
				in.Skip()
				out.Range = nil
			} else {
				if out.Range == nil {
					out.Range = new(SourceRange)
				}
				(*out.Range).UnmarshalEasyJSON(in)
			}
		case "text":
			out.Text = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss9(out *jwriter.Writer, in StyleDeclarationEdit) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"styleSheetId\":"
		out.RawString(prefix[1:])
		out.String(string(in.StyleSheetID))
	}
	{
		const prefix string = ",\"range\":"
		out.RawString(prefix)
		if in.Range == nil {
			out.RawString("null")
		} else {
			(*in.Range).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"text\":"
		out.RawString(prefix)
		out.String(string(in.Text))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *StyleDeclarationEdit) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss9(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss10(in *jlexer.Lexer, out *Style) {
	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 "styleSheetId":
			out.StyleSheetID = StyleSheetID(in.String())
		case "cssProperties":
			if in.IsNull() {
				in.Skip()
				out.CSSProperties = nil
			} else {
				in.Delim('[')
				if out.CSSProperties == nil {
					if !in.IsDelim(']') {
						out.CSSProperties = make([]*Property, 0, 8)
					} else {
						out.CSSProperties = []*Property{}
					}
				} else {
					out.CSSProperties = (out.CSSProperties)[:0]
				}
				for !in.IsDelim(']') {
					var v10 *Property
					if in.IsNull() {
						in.Skip()
						v10 = nil
					} else {
						if v10 == nil {
							v10 = new(Property)
						}
						(*v10).UnmarshalEasyJSON(in)
					}
					out.CSSProperties = append(out.CSSProperties, v10)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "shorthandEntries":
			if in.IsNull() {
				in.Skip()
				out.ShorthandEntries = nil
			} else {
				in.Delim('[')
				if out.ShorthandEntries == nil {
					if !in.IsDelim(']') {
						out.ShorthandEntries = make([]*ShorthandEntry, 0, 8)
					} else {
						out.ShorthandEntries = []*ShorthandEntry{}
					}
				} else {
					out.ShorthandEntries = (out.ShorthandEntries)[:0]
				}
				for !in.IsDelim(']') {
					var v11 *ShorthandEntry
					if in.IsNull() {
						in.Skip()
						v11 = nil
					} else {
						if v11 == nil {
							v11 = new(ShorthandEntry)
						}
						(*v11).UnmarshalEasyJSON(in)
					}
					out.ShorthandEntries = append(out.ShorthandEntries, v11)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "cssText":
			out.CSSText = string(in.String())
		case "range":
			if in.IsNull() {
				in.Skip()
				out.Range = nil
			} else {
				if out.Range == nil {
					out.Range = new(SourceRange)
				}
				(*out.Range).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss10(out *jwriter.Writer, in Style) {
	out.RawByte('{')
	first := true
	_ = first
	if in.StyleSheetID != "" {
		const prefix string = ",\"styleSheetId\":"
		first = false
		out.RawString(prefix[1:])
		out.String(string(in.StyleSheetID))
	}
	{
		const prefix string = ",\"cssProperties\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		if in.CSSProperties == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v12, v13 := range in.CSSProperties {
				if v12 > 0 {
					out.RawByte(',')
				}
				if v13 == nil {
					out.RawString("null")
				} else {
					(*v13).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	{
		const prefix string = ",\"shorthandEntries\":"
		out.RawString(prefix)
		if in.ShorthandEntries == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v14, v15 := range in.ShorthandEntries {
				if v14 > 0 {
					out.RawByte(',')
				}
				if v15 == nil {
					out.RawString("null")
				} else {
					(*v15).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	if in.CSSText != "" {
		const prefix string = ",\"cssText\":"
		out.RawString(prefix)
		out.String(string(in.CSSText))
	}
	if in.Range != nil {
		const prefix string = ",\"range\":"
		out.RawString(prefix)
		(*in.Range).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *Style) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss10(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss11(in *jlexer.Lexer, out *StopRuleUsageTrackingReturns) {
	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 "ruleUsage":
			if in.IsNull() {
				in.Skip()
				out.RuleUsage = nil
			} else {
				in.Delim('[')
				if out.RuleUsage == nil {
					if !in.IsDelim(']') {
						out.RuleUsage = make([]*RuleUsage, 0, 8)
					} else {
						out.RuleUsage = []*RuleUsage{}
					}
				} else {
					out.RuleUsage = (out.RuleUsage)[:0]
				}
				for !in.IsDelim(']') {
					var v16 *RuleUsage
					if in.IsNull() {
						in.Skip()
						v16 = nil
					} else {
						if v16 == nil {
							v16 = new(RuleUsage)
						}
						(*v16).UnmarshalEasyJSON(in)
					}
					out.RuleUsage = append(out.RuleUsage, v16)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss11(out *jwriter.Writer, in StopRuleUsageTrackingReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if len(in.RuleUsage) != 0 {
		const prefix string = ",\"ruleUsage\":"
		first = false
		out.RawString(prefix[1:])
		{
			out.RawByte('[')
			for v17, v18 := range in.RuleUsage {
				if v17 > 0 {
					out.RawByte(',')
				}
				if v18 == nil {
					out.RawString("null")
				} else {
					(*v18).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *StopRuleUsageTrackingReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss11(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss12(in *jlexer.Lexer, out *StopRuleUsageTrackingParams) {
	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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss12(out *jwriter.Writer, in StopRuleUsageTrackingParams) {
	out.RawByte('{')
	first := true
	_ = first
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *StopRuleUsageTrackingParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss12(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss13(in *jlexer.Lexer, out *StartRuleUsageTrackingParams) {
	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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss13(out *jwriter.Writer, in StartRuleUsageTrackingParams) {
	out.RawByte('{')
	first := true
	_ = first
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *StartRuleUsageTrackingParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss13(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss14(in *jlexer.Lexer, out *Specificity) {
	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 "a":
			out.A = int64(in.Int64())
		case "b":
			out.B = int64(in.Int64())
		case "c":
			out.C = int64(in.Int64())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss14(out *jwriter.Writer, in Specificity) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"a\":"
		out.RawString(prefix[1:])
		out.Int64(int64(in.A))
	}
	{
		const prefix string = ",\"b\":"
		out.RawString(prefix)
		out.Int64(int64(in.B))
	}
	{
		const prefix string = ",\"c\":"
		out.RawString(prefix)
		out.Int64(int64(in.C))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *Specificity) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss14(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss15(in *jlexer.Lexer, out *SourceRange) {
	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 "startLine":
			out.StartLine = int64(in.Int64())
		case "startColumn":
			out.StartColumn = int64(in.Int64())
		case "endLine":
			out.EndLine = int64(in.Int64())
		case "endColumn":
			out.EndColumn = int64(in.Int64())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss15(out *jwriter.Writer, in SourceRange) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"startLine\":"
		out.RawString(prefix[1:])
		out.Int64(int64(in.StartLine))
	}
	{
		const prefix string = ",\"startColumn\":"
		out.RawString(prefix)
		out.Int64(int64(in.StartColumn))
	}
	{
		const prefix string = ",\"endLine\":"
		out.RawString(prefix)
		out.Int64(int64(in.EndLine))
	}
	{
		const prefix string = ",\"endColumn\":"
		out.RawString(prefix)
		out.Int64(int64(in.EndColumn))
	}
	out.RawByte('}')
}

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

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

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

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

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

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

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

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

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetSupportsTextReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss17(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss18(in *jlexer.Lexer, out *SetSupportsTextParams) {
	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 "styleSheetId":
			out.StyleSheetID = StyleSheetID(in.String())
		case "range":
			if in.IsNull() {
				in.Skip()
				out.Range = nil
			} else {
				if out.Range == nil {
					out.Range = new(SourceRange)
				}
				(*out.Range).UnmarshalEasyJSON(in)
			}
		case "text":
			out.Text = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss18(out *jwriter.Writer, in SetSupportsTextParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"styleSheetId\":"
		out.RawString(prefix[1:])
		out.String(string(in.StyleSheetID))
	}
	{
		const prefix string = ",\"range\":"
		out.RawString(prefix)
		if in.Range == nil {
			out.RawString("null")
		} else {
			(*in.Range).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"text\":"
		out.RawString(prefix)
		out.String(string(in.Text))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetSupportsTextParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss18(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss19(in *jlexer.Lexer, out *SetStyleTextsReturns) {
	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 "styles":
			if in.IsNull() {
				in.Skip()
				out.Styles = nil
			} else {
				in.Delim('[')
				if out.Styles == nil {
					if !in.IsDelim(']') {
						out.Styles = make([]*Style, 0, 8)
					} else {
						out.Styles = []*Style{}
					}
				} else {
					out.Styles = (out.Styles)[:0]
				}
				for !in.IsDelim(']') {
					var v19 *Style
					if in.IsNull() {
						in.Skip()
						v19 = nil
					} else {
						if v19 == nil {
							v19 = new(Style)
						}
						(*v19).UnmarshalEasyJSON(in)
					}
					out.Styles = append(out.Styles, v19)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss19(out *jwriter.Writer, in SetStyleTextsReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if len(in.Styles) != 0 {
		const prefix string = ",\"styles\":"
		first = false
		out.RawString(prefix[1:])
		{
			out.RawByte('[')
			for v20, v21 := range in.Styles {
				if v20 > 0 {
					out.RawByte(',')
				}
				if v21 == nil {
					out.RawString("null")
				} else {
					(*v21).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetStyleTextsReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss19(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss20(in *jlexer.Lexer, out *SetStyleTextsParams) {
	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 "edits":
			if in.IsNull() {
				in.Skip()
				out.Edits = nil
			} else {
				in.Delim('[')
				if out.Edits == nil {
					if !in.IsDelim(']') {
						out.Edits = make([]*StyleDeclarationEdit, 0, 8)
					} else {
						out.Edits = []*StyleDeclarationEdit{}
					}
				} else {
					out.Edits = (out.Edits)[:0]
				}
				for !in.IsDelim(']') {
					var v22 *StyleDeclarationEdit
					if in.IsNull() {
						in.Skip()
						v22 = nil
					} else {
						if v22 == nil {
							v22 = new(StyleDeclarationEdit)
						}
						(*v22).UnmarshalEasyJSON(in)
					}
					out.Edits = append(out.Edits, v22)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "nodeForPropertySyntaxValidation":
			(out.NodeForPropertySyntaxValidation).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss20(out *jwriter.Writer, in SetStyleTextsParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"edits\":"
		out.RawString(prefix[1:])
		if in.Edits == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v23, v24 := range in.Edits {
				if v23 > 0 {
					out.RawByte(',')
				}
				if v24 == nil {
					out.RawString("null")
				} else {
					(*v24).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	if in.NodeForPropertySyntaxValidation != 0 {
		const prefix string = ",\"nodeForPropertySyntaxValidation\":"
		out.RawString(prefix)
		out.Int64(int64(in.NodeForPropertySyntaxValidation))
	}
	out.RawByte('}')
}

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

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

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

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

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetStyleSheetTextReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss21(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss22(in *jlexer.Lexer, out *SetStyleSheetTextParams) {
	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 "styleSheetId":
			out.StyleSheetID = StyleSheetID(in.String())
		case "text":
			out.Text = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss22(out *jwriter.Writer, in SetStyleSheetTextParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"styleSheetId\":"
		out.RawString(prefix[1:])
		out.String(string(in.StyleSheetID))
	}
	{
		const prefix string = ",\"text\":"
		out.RawString(prefix)
		out.String(string(in.Text))
	}
	out.RawByte('}')
}

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

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

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

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

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetScopeTextReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss23(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss24(in *jlexer.Lexer, out *SetScopeTextParams) {
	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 "styleSheetId":
			out.StyleSheetID = StyleSheetID(in.String())
		case "range":
			if in.IsNull() {
				in.Skip()
				out.Range = nil
			} else {
				if out.Range == nil {
					out.Range = new(SourceRange)
				}
				(*out.Range).UnmarshalEasyJSON(in)
			}
		case "text":
			out.Text = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss24(out *jwriter.Writer, in SetScopeTextParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"styleSheetId\":"
		out.RawString(prefix[1:])
		out.String(string(in.StyleSheetID))
	}
	{
		const prefix string = ",\"range\":"
		out.RawString(prefix)
		if in.Range == nil {
			out.RawString("null")
		} else {
			(*in.Range).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"text\":"
		out.RawString(prefix)
		out.String(string(in.Text))
	}
	out.RawByte('}')
}

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

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

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

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

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetRuleSelectorReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss25(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss26(in *jlexer.Lexer, out *SetRuleSelectorParams) {
	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 "styleSheetId":
			out.StyleSheetID = StyleSheetID(in.String())
		case "range":
			if in.IsNull() {
				in.Skip()
				out.Range = nil
			} else {
				if out.Range == nil {
					out.Range = new(SourceRange)
				}
				(*out.Range).UnmarshalEasyJSON(in)
			}
		case "selector":
			out.Selector = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss26(out *jwriter.Writer, in SetRuleSelectorParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"styleSheetId\":"
		out.RawString(prefix[1:])
		out.String(string(in.StyleSheetID))
	}
	{
		const prefix string = ",\"range\":"
		out.RawString(prefix)
		if in.Range == nil {
			out.RawString("null")
		} else {
			(*in.Range).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"selector\":"
		out.RawString(prefix)
		out.String(string(in.Selector))
	}
	out.RawByte('}')
}

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

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

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

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

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetPropertyRulePropertyNameReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss27(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss28(in *jlexer.Lexer, out *SetPropertyRulePropertyNameParams) {
	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 "styleSheetId":
			out.StyleSheetID = StyleSheetID(in.String())
		case "range":
			if in.IsNull() {
				in.Skip()
				out.Range = nil
			} else {
				if out.Range == nil {
					out.Range = new(SourceRange)
				}
				(*out.Range).UnmarshalEasyJSON(in)
			}
		case "propertyName":
			out.PropertyName = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss28(out *jwriter.Writer, in SetPropertyRulePropertyNameParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"styleSheetId\":"
		out.RawString(prefix[1:])
		out.String(string(in.StyleSheetID))
	}
	{
		const prefix string = ",\"range\":"
		out.RawString(prefix)
		if in.Range == nil {
			out.RawString("null")
		} else {
			(*in.Range).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"propertyName\":"
		out.RawString(prefix)
		out.String(string(in.PropertyName))
	}
	out.RawByte('}')
}

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

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

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

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

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetMediaTextReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss29(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss30(in *jlexer.Lexer, out *SetMediaTextParams) {
	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 "styleSheetId":
			out.StyleSheetID = StyleSheetID(in.String())
		case "range":
			if in.IsNull() {
				in.Skip()
				out.Range = nil
			} else {
				if out.Range == nil {
					out.Range = new(SourceRange)
				}
				(*out.Range).UnmarshalEasyJSON(in)
			}
		case "text":
			out.Text = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss30(out *jwriter.Writer, in SetMediaTextParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"styleSheetId\":"
		out.RawString(prefix[1:])
		out.String(string(in.StyleSheetID))
	}
	{
		const prefix string = ",\"range\":"
		out.RawString(prefix)
		if in.Range == nil {
			out.RawString("null")
		} else {
			(*in.Range).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"text\":"
		out.RawString(prefix)
		out.String(string(in.Text))
	}
	out.RawByte('}')
}

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

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

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

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

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

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

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

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

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetKeyframeKeyReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss32(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss33(in *jlexer.Lexer, out *SetKeyframeKeyParams) {
	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 "styleSheetId":
			out.StyleSheetID = StyleSheetID(in.String())
		case "range":
			if in.IsNull() {
				in.Skip()
				out.Range = nil
			} else {
				if out.Range == nil {
					out.Range = new(SourceRange)
				}
				(*out.Range).UnmarshalEasyJSON(in)
			}
		case "keyText":
			out.KeyText = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss33(out *jwriter.Writer, in SetKeyframeKeyParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"styleSheetId\":"
		out.RawString(prefix[1:])
		out.String(string(in.StyleSheetID))
	}
	{
		const prefix string = ",\"range\":"
		out.RawString(prefix)
		if in.Range == nil {
			out.RawString("null")
		} else {
			(*in.Range).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"keyText\":"
		out.RawString(prefix)
		out.String(string(in.KeyText))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetKeyframeKeyParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss33(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss34(in *jlexer.Lexer, out *SetEffectivePropertyValueForNodeParams) {
	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 "propertyName":
			out.PropertyName = string(in.String())
		case "value":
			out.Value = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss34(out *jwriter.Writer, in SetEffectivePropertyValueForNodeParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"nodeId\":"
		out.RawString(prefix[1:])
		out.Int64(int64(in.NodeID))
	}
	{
		const prefix string = ",\"propertyName\":"
		out.RawString(prefix)
		out.String(string(in.PropertyName))
	}
	{
		const prefix string = ",\"value\":"
		out.RawString(prefix)
		out.String(string(in.Value))
	}
	out.RawByte('}')
}

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

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

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

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

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetContainerQueryTextReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss35(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss36(in *jlexer.Lexer, out *SetContainerQueryTextParams) {
	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 "styleSheetId":
			out.StyleSheetID = StyleSheetID(in.String())
		case "range":
			if in.IsNull() {
				in.Skip()
				out.Range = nil
			} else {
				if out.Range == nil {
					out.Range = new(SourceRange)
				}
				(*out.Range).UnmarshalEasyJSON(in)
			}
		case "text":
			out.Text = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss36(out *jwriter.Writer, in SetContainerQueryTextParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"styleSheetId\":"
		out.RawString(prefix[1:])
		out.String(string(in.StyleSheetID))
	}
	{
		const prefix string = ",\"range\":"
		out.RawString(prefix)
		if in.Range == nil {
			out.RawString("null")
		} else {
			(*in.Range).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"text\":"
		out.RawString(prefix)
		out.String(string(in.Text))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetContainerQueryTextParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss36(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss37(in *jlexer.Lexer, out *SelectorList) {
	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 "selectors":
			if in.IsNull() {
				in.Skip()
				out.Selectors = nil
			} else {
				in.Delim('[')
				if out.Selectors == nil {
					if !in.IsDelim(']') {
						out.Selectors = make([]*Value, 0, 8)
					} else {
						out.Selectors = []*Value{}
					}
				} else {
					out.Selectors = (out.Selectors)[:0]
				}
				for !in.IsDelim(']') {
					var v25 *Value
					if in.IsNull() {
						in.Skip()
						v25 = nil
					} else {
						if v25 == nil {
							v25 = new(Value)
						}
						(*v25).UnmarshalEasyJSON(in)
					}
					out.Selectors = append(out.Selectors, v25)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "text":
			out.Text = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss37(out *jwriter.Writer, in SelectorList) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"selectors\":"
		out.RawString(prefix[1:])
		if in.Selectors == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v26, v27 := range in.Selectors {
				if v26 > 0 {
					out.RawByte(',')
				}
				if v27 == nil {
					out.RawString("null")
				} else {
					(*v27).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	{
		const prefix string = ",\"text\":"
		out.RawString(prefix)
		out.String(string(in.Text))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SelectorList) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss37(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss38(in *jlexer.Lexer, out *Scope) {
	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 "text":
			out.Text = string(in.String())
		case "range":
			if in.IsNull() {
				in.Skip()
				out.Range = nil
			} else {
				if out.Range == nil {
					out.Range = new(SourceRange)
				}
				(*out.Range).UnmarshalEasyJSON(in)
			}
		case "styleSheetId":
			out.StyleSheetID = StyleSheetID(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss38(out *jwriter.Writer, in Scope) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"text\":"
		out.RawString(prefix[1:])
		out.String(string(in.Text))
	}
	if in.Range != nil {
		const prefix string = ",\"range\":"
		out.RawString(prefix)
		(*in.Range).MarshalEasyJSON(out)
	}
	if in.StyleSheetID != "" {
		const prefix string = ",\"styleSheetId\":"
		out.RawString(prefix)
		out.String(string(in.StyleSheetID))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *Scope) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss38(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss39(in *jlexer.Lexer, out *RuleUsage) {
	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 "styleSheetId":
			out.StyleSheetID = StyleSheetID(in.String())
		case "startOffset":
			out.StartOffset = float64(in.Float64())
		case "endOffset":
			out.EndOffset = float64(in.Float64())
		case "used":
			out.Used = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss39(out *jwriter.Writer, in RuleUsage) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"styleSheetId\":"
		out.RawString(prefix[1:])
		out.String(string(in.StyleSheetID))
	}
	{
		const prefix string = ",\"startOffset\":"
		out.RawString(prefix)
		out.Float64(float64(in.StartOffset))
	}
	{
		const prefix string = ",\"endOffset\":"
		out.RawString(prefix)
		out.Float64(float64(in.EndOffset))
	}
	{
		const prefix string = ",\"used\":"
		out.RawString(prefix)
		out.Bool(bool(in.Used))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *RuleUsage) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss39(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss40(in *jlexer.Lexer, out *RuleMatch) {
	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 "rule":
			if in.IsNull() {
				in.Skip()
				out.Rule = nil
			} else {
				if out.Rule == nil {
					out.Rule = new(Rule)
				}
				(*out.Rule).UnmarshalEasyJSON(in)
			}
		case "matchingSelectors":
			if in.IsNull() {
				in.Skip()
				out.MatchingSelectors = nil
			} else {
				in.Delim('[')
				if out.MatchingSelectors == nil {
					if !in.IsDelim(']') {
						out.MatchingSelectors = make([]int64, 0, 8)
					} else {
						out.MatchingSelectors = []int64{}
					}
				} else {
					out.MatchingSelectors = (out.MatchingSelectors)[:0]
				}
				for !in.IsDelim(']') {
					var v28 int64
					v28 = int64(in.Int64())
					out.MatchingSelectors = append(out.MatchingSelectors, v28)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss40(out *jwriter.Writer, in RuleMatch) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"rule\":"
		out.RawString(prefix[1:])
		if in.Rule == nil {
			out.RawString("null")
		} else {
			(*in.Rule).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"matchingSelectors\":"
		out.RawString(prefix)
		if in.MatchingSelectors == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v29, v30 := range in.MatchingSelectors {
				if v29 > 0 {
					out.RawByte(',')
				}
				out.Int64(int64(v30))
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *RuleMatch) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss40(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss41(in *jlexer.Lexer, out *Rule) {
	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 "styleSheetId":
			out.StyleSheetID = StyleSheetID(in.String())
		case "selectorList":
			if in.IsNull() {
				in.Skip()
				out.SelectorList = nil
			} else {
				if out.SelectorList == nil {
					out.SelectorList = new(SelectorList)
				}
				(*out.SelectorList).UnmarshalEasyJSON(in)
			}
		case "nestingSelectors":
			if in.IsNull() {
				in.Skip()
				out.NestingSelectors = nil
			} else {
				in.Delim('[')
				if out.NestingSelectors == nil {
					if !in.IsDelim(']') {
						out.NestingSelectors = make([]string, 0, 4)
					} else {
						out.NestingSelectors = []string{}
					}
				} else {
					out.NestingSelectors = (out.NestingSelectors)[:0]
				}
				for !in.IsDelim(']') {
					var v31 string
					v31 = string(in.String())
					out.NestingSelectors = append(out.NestingSelectors, v31)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "origin":
			(out.Origin).UnmarshalEasyJSON(in)
		case "style":
			if in.IsNull() {
				in.Skip()
				out.Style = nil
			} else {
				if out.Style == nil {
					out.Style = new(Style)
				}
				(*out.Style).UnmarshalEasyJSON(in)
			}
		case "media":
			if in.IsNull() {
				in.Skip()
				out.Media = nil
			} else {
				in.Delim('[')
				if out.Media == nil {
					if !in.IsDelim(']') {
						out.Media = make([]*Media, 0, 8)
					} else {
						out.Media = []*Media{}
					}
				} else {
					out.Media = (out.Media)[:0]
				}
				for !in.IsDelim(']') {
					var v32 *Media
					if in.IsNull() {
						in.Skip()
						v32 = nil
					} else {
						if v32 == nil {
							v32 = new(Media)
						}
						(*v32).UnmarshalEasyJSON(in)
					}
					out.Media = append(out.Media, v32)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "containerQueries":
			if in.IsNull() {
				in.Skip()
				out.ContainerQueries = nil
			} else {
				in.Delim('[')
				if out.ContainerQueries == nil {
					if !in.IsDelim(']') {
						out.ContainerQueries = make([]*ContainerQuery, 0, 8)
					} else {
						out.ContainerQueries = []*ContainerQuery{}
					}
				} else {
					out.ContainerQueries = (out.ContainerQueries)[:0]
				}
				for !in.IsDelim(']') {
					var v33 *ContainerQuery
					if in.IsNull() {
						in.Skip()
						v33 = nil
					} else {
						if v33 == nil {
							v33 = new(ContainerQuery)
						}
						(*v33).UnmarshalEasyJSON(in)
					}
					out.ContainerQueries = append(out.ContainerQueries, v33)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "supports":
			if in.IsNull() {
				in.Skip()
				out.Supports = nil
			} else {
				in.Delim('[')
				if out.Supports == nil {
					if !in.IsDelim(']') {
						out.Supports = make([]*Supports, 0, 8)
					} else {
						out.Supports = []*Supports{}
					}
				} else {
					out.Supports = (out.Supports)[:0]
				}
				for !in.IsDelim(']') {
					var v34 *Supports
					if in.IsNull() {
						in.Skip()
						v34 = nil
					} else {
						if v34 == nil {
							v34 = new(Supports)
						}
						(*v34).UnmarshalEasyJSON(in)
					}
					out.Supports = append(out.Supports, v34)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "layers":
			if in.IsNull() {
				in.Skip()
				out.Layers = nil
			} else {
				in.Delim('[')
				if out.Layers == nil {
					if !in.IsDelim(']') {
						out.Layers = make([]*Layer, 0, 8)
					} else {
						out.Layers = []*Layer{}
					}
				} else {
					out.Layers = (out.Layers)[:0]
				}
				for !in.IsDelim(']') {
					var v35 *Layer
					if in.IsNull() {
						in.Skip()
						v35 = nil
					} else {
						if v35 == nil {
							v35 = new(Layer)
						}
						(*v35).UnmarshalEasyJSON(in)
					}
					out.Layers = append(out.Layers, v35)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "scopes":
			if in.IsNull() {
				in.Skip()
				out.Scopes = nil
			} else {
				in.Delim('[')
				if out.Scopes == nil {
					if !in.IsDelim(']') {
						out.Scopes = make([]*Scope, 0, 8)
					} else {
						out.Scopes = []*Scope{}
					}
				} else {
					out.Scopes = (out.Scopes)[:0]
				}
				for !in.IsDelim(']') {
					var v36 *Scope
					if in.IsNull() {
						in.Skip()
						v36 = nil
					} else {
						if v36 == nil {
							v36 = new(Scope)
						}
						(*v36).UnmarshalEasyJSON(in)
					}
					out.Scopes = append(out.Scopes, v36)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "ruleTypes":
			if in.IsNull() {
				in.Skip()
				out.RuleTypes = nil
			} else {
				in.Delim('[')
				if out.RuleTypes == nil {
					if !in.IsDelim(']') {
						out.RuleTypes = make([]RuleType, 0, 4)
					} else {
						out.RuleTypes = []RuleType{}
					}
				} else {
					out.RuleTypes = (out.RuleTypes)[:0]
				}
				for !in.IsDelim(']') {
					var v37 RuleType
					(v37).UnmarshalEasyJSON(in)
					out.RuleTypes = append(out.RuleTypes, v37)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss41(out *jwriter.Writer, in Rule) {
	out.RawByte('{')
	first := true
	_ = first
	if in.StyleSheetID != "" {
		const prefix string = ",\"styleSheetId\":"
		first = false
		out.RawString(prefix[1:])
		out.String(string(in.StyleSheetID))
	}
	{
		const prefix string = ",\"selectorList\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		if in.SelectorList == nil {
			out.RawString("null")
		} else {
			(*in.SelectorList).MarshalEasyJSON(out)
		}
	}
	if len(in.NestingSelectors) != 0 {
		const prefix string = ",\"nestingSelectors\":"
		out.RawString(prefix)
		{
			out.RawByte('[')
			for v38, v39 := range in.NestingSelectors {
				if v38 > 0 {
					out.RawByte(',')
				}
				out.String(string(v39))
			}
			out.RawByte(']')
		}
	}
	{
		const prefix string = ",\"origin\":"
		out.RawString(prefix)
		(in.Origin).MarshalEasyJSON(out)
	}
	{
		const prefix string = ",\"style\":"
		out.RawString(prefix)
		if in.Style == nil {
			out.RawString("null")
		} else {
			(*in.Style).MarshalEasyJSON(out)
		}
	}
	if len(in.Media) != 0 {
		const prefix string = ",\"media\":"
		out.RawString(prefix)
		{
			out.RawByte('[')
			for v40, v41 := range in.Media {
				if v40 > 0 {
					out.RawByte(',')
				}
				if v41 == nil {
					out.RawString("null")
				} else {
					(*v41).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	if len(in.ContainerQueries) != 0 {
		const prefix string = ",\"containerQueries\":"
		out.RawString(prefix)
		{
			out.RawByte('[')
			for v42, v43 := range in.ContainerQueries {
				if v42 > 0 {
					out.RawByte(',')
				}
				if v43 == nil {
					out.RawString("null")
				} else {
					(*v43).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	if len(in.Supports) != 0 {
		const prefix string = ",\"supports\":"
		out.RawString(prefix)
		{
			out.RawByte('[')
			for v44, v45 := range in.Supports {
				if v44 > 0 {
					out.RawByte(',')
				}
				if v45 == nil {
					out.RawString("null")
				} else {
					(*v45).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	if len(in.Layers) != 0 {
		const prefix string = ",\"layers\":"
		out.RawString(prefix)
		{
			out.RawByte('[')
			for v46, v47 := range in.Layers {
				if v46 > 0 {
					out.RawByte(',')
				}
				if v47 == nil {
					out.RawString("null")
				} else {
					(*v47).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	if len(in.Scopes) != 0 {
		const prefix string = ",\"scopes\":"
		out.RawString(prefix)
		{
			out.RawByte('[')
			for v48, v49 := range in.Scopes {
				if v48 > 0 {
					out.RawByte(',')
				}
				if v49 == nil {
					out.RawString("null")
				} else {
					(*v49).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	if len(in.RuleTypes) != 0 {
		const prefix string = ",\"ruleTypes\":"
		out.RawString(prefix)
		{
			out.RawByte('[')
			for v50, v51 := range in.RuleTypes {
				if v50 > 0 {
					out.RawByte(',')
				}
				(v51).MarshalEasyJSON(out)
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *Rule) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss41(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss42(in *jlexer.Lexer, out *PseudoElementMatches) {
	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 "pseudoType":
			(out.PseudoType).UnmarshalEasyJSON(in)
		case "pseudoIdentifier":
			out.PseudoIdentifier = string(in.String())
		case "matches":
			if in.IsNull() {
				in.Skip()
				out.Matches = nil
			} else {
				in.Delim('[')
				if out.Matches == nil {
					if !in.IsDelim(']') {
						out.Matches = make([]*RuleMatch, 0, 8)
					} else {
						out.Matches = []*RuleMatch{}
					}
				} else {
					out.Matches = (out.Matches)[:0]
				}
				for !in.IsDelim(']') {
					var v52 *RuleMatch
					if in.IsNull() {
						in.Skip()
						v52 = nil
					} else {
						if v52 == nil {
							v52 = new(RuleMatch)
						}
						(*v52).UnmarshalEasyJSON(in)
					}
					out.Matches = append(out.Matches, v52)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss42(out *jwriter.Writer, in PseudoElementMatches) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"pseudoType\":"
		out.RawString(prefix[1:])
		(in.PseudoType).MarshalEasyJSON(out)
	}
	if in.PseudoIdentifier != "" {
		const prefix string = ",\"pseudoIdentifier\":"
		out.RawString(prefix)
		out.String(string(in.PseudoIdentifier))
	}
	{
		const prefix string = ",\"matches\":"
		out.RawString(prefix)
		if in.Matches == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v53, v54 := range in.Matches {
				if v53 > 0 {
					out.RawByte(',')
				}
				if v54 == nil {
					out.RawString("null")
				} else {
					(*v54).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *PseudoElementMatches) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss42(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss43(in *jlexer.Lexer, out *PropertyRule) {
	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 "styleSheetId":
			out.StyleSheetID = StyleSheetID(in.String())
		case "origin":
			(out.Origin).UnmarshalEasyJSON(in)
		case "propertyName":
			if in.IsNull() {
				in.Skip()
				out.PropertyName = nil
			} else {
				if out.PropertyName == nil {
					out.PropertyName = new(Value)
				}
				(*out.PropertyName).UnmarshalEasyJSON(in)
			}
		case "style":
			if in.IsNull() {
				in.Skip()
				out.Style = nil
			} else {
				if out.Style == nil {
					out.Style = new(Style)
				}
				(*out.Style).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss43(out *jwriter.Writer, in PropertyRule) {
	out.RawByte('{')
	first := true
	_ = first
	if in.StyleSheetID != "" {
		const prefix string = ",\"styleSheetId\":"
		first = false
		out.RawString(prefix[1:])
		out.String(string(in.StyleSheetID))
	}
	{
		const prefix string = ",\"origin\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(in.Origin).MarshalEasyJSON(out)
	}
	{
		const prefix string = ",\"propertyName\":"
		out.RawString(prefix)
		if in.PropertyName == nil {
			out.RawString("null")
		} else {
			(*in.PropertyName).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"style\":"
		out.RawString(prefix)
		if in.Style == nil {
			out.RawString("null")
		} else {
			(*in.Style).MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *PropertyRule) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss43(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss44(in *jlexer.Lexer, out *PropertyRegistration) {
	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 "propertyName":
			out.PropertyName = string(in.String())
		case "initialValue":
			if in.IsNull() {
				in.Skip()
				out.InitialValue = nil
			} else {
				if out.InitialValue == nil {
					out.InitialValue = new(Value)
				}
				(*out.InitialValue).UnmarshalEasyJSON(in)
			}
		case "inherits":
			out.Inherits = bool(in.Bool())
		case "syntax":
			out.Syntax = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss44(out *jwriter.Writer, in PropertyRegistration) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"propertyName\":"
		out.RawString(prefix[1:])
		out.String(string(in.PropertyName))
	}
	if in.InitialValue != nil {
		const prefix string = ",\"initialValue\":"
		out.RawString(prefix)
		(*in.InitialValue).MarshalEasyJSON(out)
	}
	{
		const prefix string = ",\"inherits\":"
		out.RawString(prefix)
		out.Bool(bool(in.Inherits))
	}
	{
		const prefix string = ",\"syntax\":"
		out.RawString(prefix)
		out.String(string(in.Syntax))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *PropertyRegistration) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss44(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss45(in *jlexer.Lexer, out *Property) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "name":
			out.Name = string(in.String())
		case "value":
			out.Value = string(in.String())
		case "important":
			out.Important = bool(in.Bool())
		case "implicit":
			out.Implicit = bool(in.Bool())
		case "text":
			out.Text = string(in.String())
		case "parsedOk":
			out.ParsedOk = bool(in.Bool())
		case "disabled":
			out.Disabled = bool(in.Bool())
		case "range":
			if in.IsNull() {
				in.Skip()
				out.Range = nil
			} else {
				if out.Range == nil {
					out.Range = new(SourceRange)
				}
				(*out.Range).UnmarshalEasyJSON(in)
			}
		case "longhandProperties":
			if in.IsNull() {
				in.Skip()
				out.LonghandProperties = nil
			} else {
				in.Delim('[')
				if out.LonghandProperties == nil {
					if !in.IsDelim(']') {
						out.LonghandProperties = make([]*Property, 0, 8)
					} else {
						out.LonghandProperties = []*Property{}
					}
				} else {
					out.LonghandProperties = (out.LonghandProperties)[:0]
				}
				for !in.IsDelim(']') {
					var v55 *Property
					if in.IsNull() {
						in.Skip()
						v55 = nil
					} else {
						if v55 == nil {
							v55 = new(Property)
						}
						(*v55).UnmarshalEasyJSON(in)
					}
					out.LonghandProperties = append(out.LonghandProperties, v55)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss45(out *jwriter.Writer, in Property) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"name\":"
		out.RawString(prefix[1:])
		out.String(string(in.Name))
	}
	{
		const prefix string = ",\"value\":"
		out.RawString(prefix)
		out.String(string(in.Value))
	}
	if in.Important {
		const prefix string = ",\"important\":"
		out.RawString(prefix)
		out.Bool(bool(in.Important))
	}
	if in.Implicit {
		const prefix string = ",\"implicit\":"
		out.RawString(prefix)
		out.Bool(bool(in.Implicit))
	}
	if in.Text != "" {
		const prefix string = ",\"text\":"
		out.RawString(prefix)
		out.String(string(in.Text))
	}
	if in.ParsedOk {
		const prefix string = ",\"parsedOk\":"
		out.RawString(prefix)
		out.Bool(bool(in.ParsedOk))
	}
	if in.Disabled {
		const prefix string = ",\"disabled\":"
		out.RawString(prefix)
		out.Bool(bool(in.Disabled))
	}
	if in.Range != nil {
		const prefix string = ",\"range\":"
		out.RawString(prefix)
		(*in.Range).MarshalEasyJSON(out)
	}
	if len(in.LonghandProperties) != 0 {
		const prefix string = ",\"longhandProperties\":"
		out.RawString(prefix)
		{
			out.RawByte('[')
			for v56, v57 := range in.LonghandProperties {
				if v56 > 0 {
					out.RawByte(',')
				}
				if v57 == nil {
					out.RawString("null")
				} else {
					(*v57).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *Property) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss45(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss46(in *jlexer.Lexer, out *PositionTryRule) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "name":
			if in.IsNull() {
				in.Skip()
				out.Name = nil
			} else {
				if out.Name == nil {
					out.Name = new(Value)
				}
				(*out.Name).UnmarshalEasyJSON(in)
			}
		case "styleSheetId":
			out.StyleSheetID = StyleSheetID(in.String())
		case "origin":
			(out.Origin).UnmarshalEasyJSON(in)
		case "style":
			if in.IsNull() {
				in.Skip()
				out.Style = nil
			} else {
				if out.Style == nil {
					out.Style = new(Style)
				}
				(*out.Style).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss46(out *jwriter.Writer, in PositionTryRule) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"name\":"
		out.RawString(prefix[1:])
		if in.Name == nil {
			out.RawString("null")
		} else {
			(*in.Name).MarshalEasyJSON(out)
		}
	}
	if in.StyleSheetID != "" {
		const prefix string = ",\"styleSheetId\":"
		out.RawString(prefix)
		out.String(string(in.StyleSheetID))
	}
	{
		const prefix string = ",\"origin\":"
		out.RawString(prefix)
		(in.Origin).MarshalEasyJSON(out)
	}
	{
		const prefix string = ",\"style\":"
		out.RawString(prefix)
		if in.Style == nil {
			out.RawString("null")
		} else {
			(*in.Style).MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *PositionTryRule) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss46(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss47(in *jlexer.Lexer, out *PlatformFontUsage) {
	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 "familyName":
			out.FamilyName = string(in.String())
		case "postScriptName":
			out.PostScriptName = string(in.String())
		case "isCustomFont":
			out.IsCustomFont = bool(in.Bool())
		case "glyphCount":
			out.GlyphCount = float64(in.Float64())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss47(out *jwriter.Writer, in PlatformFontUsage) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"familyName\":"
		out.RawString(prefix[1:])
		out.String(string(in.FamilyName))
	}
	{
		const prefix string = ",\"postScriptName\":"
		out.RawString(prefix)
		out.String(string(in.PostScriptName))
	}
	{
		const prefix string = ",\"isCustomFont\":"
		out.RawString(prefix)
		out.Bool(bool(in.IsCustomFont))
	}
	{
		const prefix string = ",\"glyphCount\":"
		out.RawString(prefix)
		out.Float64(float64(in.GlyphCount))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *PlatformFontUsage) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss47(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss48(in *jlexer.Lexer, out *MediaQueryExpression) {
	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 "value":
			out.Value = float64(in.Float64())
		case "unit":
			out.Unit = string(in.String())
		case "feature":
			out.Feature = string(in.String())
		case "valueRange":
			if in.IsNull() {
				in.Skip()
				out.ValueRange = nil
			} else {
				if out.ValueRange == nil {
					out.ValueRange = new(SourceRange)
				}
				(*out.ValueRange).UnmarshalEasyJSON(in)
			}
		case "computedLength":
			out.ComputedLength = float64(in.Float64())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss48(out *jwriter.Writer, in MediaQueryExpression) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"value\":"
		out.RawString(prefix[1:])
		out.Float64(float64(in.Value))
	}
	{
		const prefix string = ",\"unit\":"
		out.RawString(prefix)
		out.String(string(in.Unit))
	}
	{
		const prefix string = ",\"feature\":"
		out.RawString(prefix)
		out.String(string(in.Feature))
	}
	if in.ValueRange != nil {
		const prefix string = ",\"valueRange\":"
		out.RawString(prefix)
		(*in.ValueRange).MarshalEasyJSON(out)
	}
	if in.ComputedLength != 0 {
		const prefix string = ",\"computedLength\":"
		out.RawString(prefix)
		out.Float64(float64(in.ComputedLength))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *MediaQueryExpression) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss48(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss49(in *jlexer.Lexer, out *MediaQuery) {
	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 "expressions":
			if in.IsNull() {
				in.Skip()
				out.Expressions = nil
			} else {
				in.Delim('[')
				if out.Expressions == nil {
					if !in.IsDelim(']') {
						out.Expressions = make([]*MediaQueryExpression, 0, 8)
					} else {
						out.Expressions = []*MediaQueryExpression{}
					}
				} else {
					out.Expressions = (out.Expressions)[:0]
				}
				for !in.IsDelim(']') {
					var v58 *MediaQueryExpression
					if in.IsNull() {
						in.Skip()
						v58 = nil
					} else {
						if v58 == nil {
							v58 = new(MediaQueryExpression)
						}
						(*v58).UnmarshalEasyJSON(in)
					}
					out.Expressions = append(out.Expressions, v58)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "active":
			out.Active = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss49(out *jwriter.Writer, in MediaQuery) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"expressions\":"
		out.RawString(prefix[1:])
		if in.Expressions == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v59, v60 := range in.Expressions {
				if v59 > 0 {
					out.RawByte(',')
				}
				if v60 == nil {
					out.RawString("null")
				} else {
					(*v60).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	{
		const prefix string = ",\"active\":"
		out.RawString(prefix)
		out.Bool(bool(in.Active))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *MediaQuery) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss49(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss50(in *jlexer.Lexer, out *Media) {
	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 "text":
			out.Text = string(in.String())
		case "source":
			(out.Source).UnmarshalEasyJSON(in)
		case "sourceURL":
			out.SourceURL = string(in.String())
		case "range":
			if in.IsNull() {
				in.Skip()
				out.Range = nil
			} else {
				if out.Range == nil {
					out.Range = new(SourceRange)
				}
				(*out.Range).UnmarshalEasyJSON(in)
			}
		case "styleSheetId":
			out.StyleSheetID = StyleSheetID(in.String())
		case "mediaList":
			if in.IsNull() {
				in.Skip()
				out.MediaList = nil
			} else {
				in.Delim('[')
				if out.MediaList == nil {
					if !in.IsDelim(']') {
						out.MediaList = make([]*MediaQuery, 0, 8)
					} else {
						out.MediaList = []*MediaQuery{}
					}
				} else {
					out.MediaList = (out.MediaList)[:0]
				}
				for !in.IsDelim(']') {
					var v61 *MediaQuery
					if in.IsNull() {
						in.Skip()
						v61 = nil
					} else {
						if v61 == nil {
							v61 = new(MediaQuery)
						}
						(*v61).UnmarshalEasyJSON(in)
					}
					out.MediaList = append(out.MediaList, v61)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss50(out *jwriter.Writer, in Media) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"text\":"
		out.RawString(prefix[1:])
		out.String(string(in.Text))
	}
	{
		const prefix string = ",\"source\":"
		out.RawString(prefix)
		(in.Source).MarshalEasyJSON(out)
	}
	if in.SourceURL != "" {
		const prefix string = ",\"sourceURL\":"
		out.RawString(prefix)
		out.String(string(in.SourceURL))
	}
	if in.Range != nil {
		const prefix string = ",\"range\":"
		out.RawString(prefix)
		(*in.Range).MarshalEasyJSON(out)
	}
	if in.StyleSheetID != "" {
		const prefix string = ",\"styleSheetId\":"
		out.RawString(prefix)
		out.String(string(in.StyleSheetID))
	}
	if len(in.MediaList) != 0 {
		const prefix string = ",\"mediaList\":"
		out.RawString(prefix)
		{
			out.RawByte('[')
			for v62, v63 := range in.MediaList {
				if v62 > 0 {
					out.RawByte(',')
				}
				if v63 == nil {
					out.RawString("null")
				} else {
					(*v63).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *Media) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss50(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss51(in *jlexer.Lexer, out *LayerData) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "name":
			out.Name = string(in.String())
		case "subLayers":
			if in.IsNull() {
				in.Skip()
				out.SubLayers = nil
			} else {
				in.Delim('[')
				if out.SubLayers == nil {
					if !in.IsDelim(']') {
						out.SubLayers = make([]*LayerData, 0, 8)
					} else {
						out.SubLayers = []*LayerData{}
					}
				} else {
					out.SubLayers = (out.SubLayers)[:0]
				}
				for !in.IsDelim(']') {
					var v64 *LayerData
					if in.IsNull() {
						in.Skip()
						v64 = nil
					} else {
						if v64 == nil {
							v64 = new(LayerData)
						}
						(*v64).UnmarshalEasyJSON(in)
					}
					out.SubLayers = append(out.SubLayers, v64)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "order":
			out.Order = float64(in.Float64())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss51(out *jwriter.Writer, in LayerData) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"name\":"
		out.RawString(prefix[1:])
		out.String(string(in.Name))
	}
	if len(in.SubLayers) != 0 {
		const prefix string = ",\"subLayers\":"
		out.RawString(prefix)
		{
			out.RawByte('[')
			for v65, v66 := range in.SubLayers {
				if v65 > 0 {
					out.RawByte(',')
				}
				if v66 == nil {
					out.RawString("null")
				} else {
					(*v66).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	{
		const prefix string = ",\"order\":"
		out.RawString(prefix)
		out.Float64(float64(in.Order))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *LayerData) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss51(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss52(in *jlexer.Lexer, out *Layer) {
	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 "text":
			out.Text = string(in.String())
		case "range":
			if in.IsNull() {
				in.Skip()
				out.Range = nil
			} else {
				if out.Range == nil {
					out.Range = new(SourceRange)
				}
				(*out.Range).UnmarshalEasyJSON(in)
			}
		case "styleSheetId":
			out.StyleSheetID = StyleSheetID(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss52(out *jwriter.Writer, in Layer) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"text\":"
		out.RawString(prefix[1:])
		out.String(string(in.Text))
	}
	if in.Range != nil {
		const prefix string = ",\"range\":"
		out.RawString(prefix)
		(*in.Range).MarshalEasyJSON(out)
	}
	if in.StyleSheetID != "" {
		const prefix string = ",\"styleSheetId\":"
		out.RawString(prefix)
		out.String(string(in.StyleSheetID))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *Layer) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss52(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss53(in *jlexer.Lexer, out *KeyframesRule) {
	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 "animationName":
			if in.IsNull() {
				in.Skip()
				out.AnimationName = nil
			} else {
				if out.AnimationName == nil {
					out.AnimationName = new(Value)
				}
				(*out.AnimationName).UnmarshalEasyJSON(in)
			}
		case "keyframes":
			if in.IsNull() {
				in.Skip()
				out.Keyframes = nil
			} else {
				in.Delim('[')
				if out.Keyframes == nil {
					if !in.IsDelim(']') {
						out.Keyframes = make([]*KeyframeRule, 0, 8)
					} else {
						out.Keyframes = []*KeyframeRule{}
					}
				} else {
					out.Keyframes = (out.Keyframes)[:0]
				}
				for !in.IsDelim(']') {
					var v67 *KeyframeRule
					if in.IsNull() {
						in.Skip()
						v67 = nil
					} else {
						if v67 == nil {
							v67 = new(KeyframeRule)
						}
						(*v67).UnmarshalEasyJSON(in)
					}
					out.Keyframes = append(out.Keyframes, v67)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss53(out *jwriter.Writer, in KeyframesRule) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"animationName\":"
		out.RawString(prefix[1:])
		if in.AnimationName == nil {
			out.RawString("null")
		} else {
			(*in.AnimationName).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"keyframes\":"
		out.RawString(prefix)
		if in.Keyframes == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v68, v69 := range in.Keyframes {
				if v68 > 0 {
					out.RawByte(',')
				}
				if v69 == nil {
					out.RawString("null")
				} else {
					(*v69).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *KeyframesRule) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss53(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss54(in *jlexer.Lexer, out *KeyframeRule) {
	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 "styleSheetId":
			out.StyleSheetID = StyleSheetID(in.String())
		case "origin":
			(out.Origin).UnmarshalEasyJSON(in)
		case "keyText":
			if in.IsNull() {
				in.Skip()
				out.KeyText = nil
			} else {
				if out.KeyText == nil {
					out.KeyText = new(Value)
				}
				(*out.KeyText).UnmarshalEasyJSON(in)
			}
		case "style":
			if in.IsNull() {
				in.Skip()
				out.Style = nil
			} else {
				if out.Style == nil {
					out.Style = new(Style)
				}
				(*out.Style).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss54(out *jwriter.Writer, in KeyframeRule) {
	out.RawByte('{')
	first := true
	_ = first
	if in.StyleSheetID != "" {
		const prefix string = ",\"styleSheetId\":"
		first = false
		out.RawString(prefix[1:])
		out.String(string(in.StyleSheetID))
	}
	{
		const prefix string = ",\"origin\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(in.Origin).MarshalEasyJSON(out)
	}
	{
		const prefix string = ",\"keyText\":"
		out.RawString(prefix)
		if in.KeyText == nil {
			out.RawString("null")
		} else {
			(*in.KeyText).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"style\":"
		out.RawString(prefix)
		if in.Style == nil {
			out.RawString("null")
		} else {
			(*in.Style).MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *KeyframeRule) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss54(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss55(in *jlexer.Lexer, out *InheritedStyleEntry) {
	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 "inlineStyle":
			if in.IsNull() {
				in.Skip()
				out.InlineStyle = nil
			} else {
				if out.InlineStyle == nil {
					out.InlineStyle = new(Style)
				}
				(*out.InlineStyle).UnmarshalEasyJSON(in)
			}
		case "matchedCSSRules":
			if in.IsNull() {
				in.Skip()
				out.MatchedCSSRules = nil
			} else {
				in.Delim('[')
				if out.MatchedCSSRules == nil {
					if !in.IsDelim(']') {
						out.MatchedCSSRules = make([]*RuleMatch, 0, 8)
					} else {
						out.MatchedCSSRules = []*RuleMatch{}
					}
				} else {
					out.MatchedCSSRules = (out.MatchedCSSRules)[:0]
				}
				for !in.IsDelim(']') {
					var v70 *RuleMatch
					if in.IsNull() {
						in.Skip()
						v70 = nil
					} else {
						if v70 == nil {
							v70 = new(RuleMatch)
						}
						(*v70).UnmarshalEasyJSON(in)
					}
					out.MatchedCSSRules = append(out.MatchedCSSRules, v70)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss55(out *jwriter.Writer, in InheritedStyleEntry) {
	out.RawByte('{')
	first := true
	_ = first
	if in.InlineStyle != nil {
		const prefix string = ",\"inlineStyle\":"
		first = false
		out.RawString(prefix[1:])
		(*in.InlineStyle).MarshalEasyJSON(out)
	}
	{
		const prefix string = ",\"matchedCSSRules\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		if in.MatchedCSSRules == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v71, v72 := range in.MatchedCSSRules {
				if v71 > 0 {
					out.RawByte(',')
				}
				if v72 == nil {
					out.RawString("null")
				} else {
					(*v72).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *InheritedStyleEntry) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss55(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss56(in *jlexer.Lexer, out *InheritedPseudoElementMatches) {
	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 "pseudoElements":
			if in.IsNull() {
				in.Skip()
				out.PseudoElements = nil
			} else {
				in.Delim('[')
				if out.PseudoElements == nil {
					if !in.IsDelim(']') {
						out.PseudoElements = make([]*PseudoElementMatches, 0, 8)
					} else {
						out.PseudoElements = []*PseudoElementMatches{}
					}
				} else {
					out.PseudoElements = (out.PseudoElements)[:0]
				}
				for !in.IsDelim(']') {
					var v73 *PseudoElementMatches
					if in.IsNull() {
						in.Skip()
						v73 = nil
					} else {
						if v73 == nil {
							v73 = new(PseudoElementMatches)
						}
						(*v73).UnmarshalEasyJSON(in)
					}
					out.PseudoElements = append(out.PseudoElements, v73)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss56(out *jwriter.Writer, in InheritedPseudoElementMatches) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"pseudoElements\":"
		out.RawString(prefix[1:])
		if in.PseudoElements == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v74, v75 := range in.PseudoElements {
				if v74 > 0 {
					out.RawByte(',')
				}
				if v75 == nil {
					out.RawString("null")
				} else {
					(*v75).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

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

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetStyleSheetTextReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss57(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss58(in *jlexer.Lexer, out *GetStyleSheetTextParams) {
	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 "styleSheetId":
			out.StyleSheetID = StyleSheetID(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss58(out *jwriter.Writer, in GetStyleSheetTextParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"styleSheetId\":"
		out.RawString(prefix[1:])
		out.String(string(in.StyleSheetID))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetStyleSheetTextParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss58(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss59(in *jlexer.Lexer, out *GetPlatformFontsForNodeReturns) {
	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 "fonts":
			if in.IsNull() {
				in.Skip()
				out.Fonts = nil
			} else {
				in.Delim('[')
				if out.Fonts == nil {
					if !in.IsDelim(']') {
						out.Fonts = make([]*PlatformFontUsage, 0, 8)
					} else {
						out.Fonts = []*PlatformFontUsage{}
					}
				} else {
					out.Fonts = (out.Fonts)[:0]
				}
				for !in.IsDelim(']') {
					var v76 *PlatformFontUsage
					if in.IsNull() {
						in.Skip()
						v76 = nil
					} else {
						if v76 == nil {
							v76 = new(PlatformFontUsage)
						}
						(*v76).UnmarshalEasyJSON(in)
					}
					out.Fonts = append(out.Fonts, v76)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss59(out *jwriter.Writer, in GetPlatformFontsForNodeReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if len(in.Fonts) != 0 {
		const prefix string = ",\"fonts\":"
		first = false
		out.RawString(prefix[1:])
		{
			out.RawByte('[')
			for v77, v78 := range in.Fonts {
				if v77 > 0 {
					out.RawByte(',')
				}
				if v78 == nil {
					out.RawString("null")
				} else {
					(*v78).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetPlatformFontsForNodeReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss59(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss60(in *jlexer.Lexer, out *GetPlatformFontsForNodeParams) {
	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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss60(out *jwriter.Writer, in GetPlatformFontsForNodeParams) {
	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 GetPlatformFontsForNodeParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss60(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetPlatformFontsForNodeParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss60(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss61(in *jlexer.Lexer, out *GetMediaQueriesReturns) {
	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 "medias":
			if in.IsNull() {
				in.Skip()
				out.Medias = nil
			} else {
				in.Delim('[')
				if out.Medias == nil {
					if !in.IsDelim(']') {
						out.Medias = make([]*Media, 0, 8)
					} else {
						out.Medias = []*Media{}
					}
				} else {
					out.Medias = (out.Medias)[:0]
				}
				for !in.IsDelim(']') {
					var v79 *Media
					if in.IsNull() {
						in.Skip()
						v79 = nil
					} else {
						if v79 == nil {
							v79 = new(Media)
						}
						(*v79).UnmarshalEasyJSON(in)
					}
					out.Medias = append(out.Medias, v79)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss61(out *jwriter.Writer, in GetMediaQueriesReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if len(in.Medias) != 0 {
		const prefix string = ",\"medias\":"
		first = false
		out.RawString(prefix[1:])
		{
			out.RawByte('[')
			for v80, v81 := range in.Medias {
				if v80 > 0 {
					out.RawByte(',')
				}
				if v81 == nil {
					out.RawString("null")
				} else {
					(*v81).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetMediaQueriesReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss61(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss62(in *jlexer.Lexer, out *GetMediaQueriesParams) {
	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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss62(out *jwriter.Writer, in GetMediaQueriesParams) {
	out.RawByte('{')
	first := true
	_ = first
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetMediaQueriesParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss62(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss63(in *jlexer.Lexer, out *GetMatchedStylesForNodeReturns) {
	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 "inlineStyle":
			if in.IsNull() {
				in.Skip()
				out.InlineStyle = nil
			} else {
				if out.InlineStyle == nil {
					out.InlineStyle = new(Style)
				}
				(*out.InlineStyle).UnmarshalEasyJSON(in)
			}
		case "attributesStyle":
			if in.IsNull() {
				in.Skip()
				out.AttributesStyle = nil
			} else {
				if out.AttributesStyle == nil {
					out.AttributesStyle = new(Style)
				}
				(*out.AttributesStyle).UnmarshalEasyJSON(in)
			}
		case "matchedCSSRules":
			if in.IsNull() {
				in.Skip()
				out.MatchedCSSRules = nil
			} else {
				in.Delim('[')
				if out.MatchedCSSRules == nil {
					if !in.IsDelim(']') {
						out.MatchedCSSRules = make([]*RuleMatch, 0, 8)
					} else {
						out.MatchedCSSRules = []*RuleMatch{}
					}
				} else {
					out.MatchedCSSRules = (out.MatchedCSSRules)[:0]
				}
				for !in.IsDelim(']') {
					var v82 *RuleMatch
					if in.IsNull() {
						in.Skip()
						v82 = nil
					} else {
						if v82 == nil {
							v82 = new(RuleMatch)
						}
						(*v82).UnmarshalEasyJSON(in)
					}
					out.MatchedCSSRules = append(out.MatchedCSSRules, v82)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "pseudoElements":
			if in.IsNull() {
				in.Skip()
				out.PseudoElements = nil
			} else {
				in.Delim('[')
				if out.PseudoElements == nil {
					if !in.IsDelim(']') {
						out.PseudoElements = make([]*PseudoElementMatches, 0, 8)
					} else {
						out.PseudoElements = []*PseudoElementMatches{}
					}
				} else {
					out.PseudoElements = (out.PseudoElements)[:0]
				}
				for !in.IsDelim(']') {
					var v83 *PseudoElementMatches
					if in.IsNull() {
						in.Skip()
						v83 = nil
					} else {
						if v83 == nil {
							v83 = new(PseudoElementMatches)
						}
						(*v83).UnmarshalEasyJSON(in)
					}
					out.PseudoElements = append(out.PseudoElements, v83)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "inherited":
			if in.IsNull() {
				in.Skip()
				out.Inherited = nil
			} else {
				in.Delim('[')
				if out.Inherited == nil {
					if !in.IsDelim(']') {
						out.Inherited = make([]*InheritedStyleEntry, 0, 8)
					} else {
						out.Inherited = []*InheritedStyleEntry{}
					}
				} else {
					out.Inherited = (out.Inherited)[:0]
				}
				for !in.IsDelim(']') {
					var v84 *InheritedStyleEntry
					if in.IsNull() {
						in.Skip()
						v84 = nil
					} else {
						if v84 == nil {
							v84 = new(InheritedStyleEntry)
						}
						(*v84).UnmarshalEasyJSON(in)
					}
					out.Inherited = append(out.Inherited, v84)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "inheritedPseudoElements":
			if in.IsNull() {
				in.Skip()
				out.InheritedPseudoElements = nil
			} else {
				in.Delim('[')
				if out.InheritedPseudoElements == nil {
					if !in.IsDelim(']') {
						out.InheritedPseudoElements = make([]*InheritedPseudoElementMatches, 0, 8)
					} else {
						out.InheritedPseudoElements = []*InheritedPseudoElementMatches{}
					}
				} else {
					out.InheritedPseudoElements = (out.InheritedPseudoElements)[:0]
				}
				for !in.IsDelim(']') {
					var v85 *InheritedPseudoElementMatches
					if in.IsNull() {
						in.Skip()
						v85 = nil
					} else {
						if v85 == nil {
							v85 = new(InheritedPseudoElementMatches)
						}
						(*v85).UnmarshalEasyJSON(in)
					}
					out.InheritedPseudoElements = append(out.InheritedPseudoElements, v85)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "cssKeyframesRules":
			if in.IsNull() {
				in.Skip()
				out.CSSKeyframesRules = nil
			} else {
				in.Delim('[')
				if out.CSSKeyframesRules == nil {
					if !in.IsDelim(']') {
						out.CSSKeyframesRules = make([]*KeyframesRule, 0, 8)
					} else {
						out.CSSKeyframesRules = []*KeyframesRule{}
					}
				} else {
					out.CSSKeyframesRules = (out.CSSKeyframesRules)[:0]
				}
				for !in.IsDelim(']') {
					var v86 *KeyframesRule
					if in.IsNull() {
						in.Skip()
						v86 = nil
					} else {
						if v86 == nil {
							v86 = new(KeyframesRule)
						}
						(*v86).UnmarshalEasyJSON(in)
					}
					out.CSSKeyframesRules = append(out.CSSKeyframesRules, v86)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "cssPositionTryRules":
			if in.IsNull() {
				in.Skip()
				out.CSSPositionTryRules = nil
			} else {
				in.Delim('[')
				if out.CSSPositionTryRules == nil {
					if !in.IsDelim(']') {
						out.CSSPositionTryRules = make([]*PositionTryRule, 0, 8)
					} else {
						out.CSSPositionTryRules = []*PositionTryRule{}
					}
				} else {
					out.CSSPositionTryRules = (out.CSSPositionTryRules)[:0]
				}
				for !in.IsDelim(']') {
					var v87 *PositionTryRule
					if in.IsNull() {
						in.Skip()
						v87 = nil
					} else {
						if v87 == nil {
							v87 = new(PositionTryRule)
						}
						(*v87).UnmarshalEasyJSON(in)
					}
					out.CSSPositionTryRules = append(out.CSSPositionTryRules, v87)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "cssPropertyRules":
			if in.IsNull() {
				in.Skip()
				out.CSSPropertyRules = nil
			} else {
				in.Delim('[')
				if out.CSSPropertyRules == nil {
					if !in.IsDelim(']') {
						out.CSSPropertyRules = make([]*PropertyRule, 0, 8)
					} else {
						out.CSSPropertyRules = []*PropertyRule{}
					}
				} else {
					out.CSSPropertyRules = (out.CSSPropertyRules)[:0]
				}
				for !in.IsDelim(']') {
					var v88 *PropertyRule
					if in.IsNull() {
						in.Skip()
						v88 = nil
					} else {
						if v88 == nil {
							v88 = new(PropertyRule)
						}
						(*v88).UnmarshalEasyJSON(in)
					}
					out.CSSPropertyRules = append(out.CSSPropertyRules, v88)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "cssPropertyRegistrations":
			if in.IsNull() {
				in.Skip()
				out.CSSPropertyRegistrations = nil
			} else {
				in.Delim('[')
				if out.CSSPropertyRegistrations == nil {
					if !in.IsDelim(']') {
						out.CSSPropertyRegistrations = make([]*PropertyRegistration, 0, 8)
					} else {
						out.CSSPropertyRegistrations = []*PropertyRegistration{}
					}
				} else {
					out.CSSPropertyRegistrations = (out.CSSPropertyRegistrations)[:0]
				}
				for !in.IsDelim(']') {
					var v89 *PropertyRegistration
					if in.IsNull() {
						in.Skip()
						v89 = nil
					} else {
						if v89 == nil {
							v89 = new(PropertyRegistration)
						}
						(*v89).UnmarshalEasyJSON(in)
					}
					out.CSSPropertyRegistrations = append(out.CSSPropertyRegistrations, v89)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "cssFontPaletteValuesRule":
			if in.IsNull() {
				in.Skip()
				out.CSSFontPaletteValuesRule = nil
			} else {
				if out.CSSFontPaletteValuesRule == nil {
					out.CSSFontPaletteValuesRule = new(FontPaletteValuesRule)
				}
				(*out.CSSFontPaletteValuesRule).UnmarshalEasyJSON(in)
			}
		case "parentLayoutNodeId":
			(out.ParentLayoutNodeID).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss63(out *jwriter.Writer, in GetMatchedStylesForNodeReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if in.InlineStyle != nil {
		const prefix string = ",\"inlineStyle\":"
		first = false
		out.RawString(prefix[1:])
		(*in.InlineStyle).MarshalEasyJSON(out)
	}
	if in.AttributesStyle != nil {
		const prefix string = ",\"attributesStyle\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.AttributesStyle).MarshalEasyJSON(out)
	}
	if len(in.MatchedCSSRules) != 0 {
		const prefix string = ",\"matchedCSSRules\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		{
			out.RawByte('[')
			for v90, v91 := range in.MatchedCSSRules {
				if v90 > 0 {
					out.RawByte(',')
				}
				if v91 == nil {
					out.RawString("null")
				} else {
					(*v91).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	if len(in.PseudoElements) != 0 {
		const prefix string = ",\"pseudoElements\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		{
			out.RawByte('[')
			for v92, v93 := range in.PseudoElements {
				if v92 > 0 {
					out.RawByte(',')
				}
				if v93 == nil {
					out.RawString("null")
				} else {
					(*v93).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	if len(in.Inherited) != 0 {
		const prefix string = ",\"inherited\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		{
			out.RawByte('[')
			for v94, v95 := range in.Inherited {
				if v94 > 0 {
					out.RawByte(',')
				}
				if v95 == nil {
					out.RawString("null")
				} else {
					(*v95).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	if len(in.InheritedPseudoElements) != 0 {
		const prefix string = ",\"inheritedPseudoElements\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		{
			out.RawByte('[')
			for v96, v97 := range in.InheritedPseudoElements {
				if v96 > 0 {
					out.RawByte(',')
				}
				if v97 == nil {
					out.RawString("null")
				} else {
					(*v97).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	if len(in.CSSKeyframesRules) != 0 {
		const prefix string = ",\"cssKeyframesRules\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		{
			out.RawByte('[')
			for v98, v99 := range in.CSSKeyframesRules {
				if v98 > 0 {
					out.RawByte(',')
				}
				if v99 == nil {
					out.RawString("null")
				} else {
					(*v99).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	if len(in.CSSPositionTryRules) != 0 {
		const prefix string = ",\"cssPositionTryRules\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		{
			out.RawByte('[')
			for v100, v101 := range in.CSSPositionTryRules {
				if v100 > 0 {
					out.RawByte(',')
				}
				if v101 == nil {
					out.RawString("null")
				} else {
					(*v101).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	if len(in.CSSPropertyRules) != 0 {
		const prefix string = ",\"cssPropertyRules\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		{
			out.RawByte('[')
			for v102, v103 := range in.CSSPropertyRules {
				if v102 > 0 {
					out.RawByte(',')
				}
				if v103 == nil {
					out.RawString("null")
				} else {
					(*v103).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	if len(in.CSSPropertyRegistrations) != 0 {
		const prefix string = ",\"cssPropertyRegistrations\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		{
			out.RawByte('[')
			for v104, v105 := range in.CSSPropertyRegistrations {
				if v104 > 0 {
					out.RawByte(',')
				}
				if v105 == nil {
					out.RawString("null")
				} else {
					(*v105).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	if in.CSSFontPaletteValuesRule != nil {
		const prefix string = ",\"cssFontPaletteValuesRule\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.CSSFontPaletteValuesRule).MarshalEasyJSON(out)
	}
	if in.ParentLayoutNodeID != 0 {
		const prefix string = ",\"parentLayoutNodeId\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.Int64(int64(in.ParentLayoutNodeID))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetMatchedStylesForNodeReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss63(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss64(in *jlexer.Lexer, out *GetMatchedStylesForNodeParams) {
	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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss64(out *jwriter.Writer, in GetMatchedStylesForNodeParams) {
	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 GetMatchedStylesForNodeParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss64(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetMatchedStylesForNodeParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss64(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss65(in *jlexer.Lexer, out *GetLocationForSelectorReturns) {
	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 "ranges":
			if in.IsNull() {
				in.Skip()
				out.Ranges = nil
			} else {
				in.Delim('[')
				if out.Ranges == nil {
					if !in.IsDelim(']') {
						out.Ranges = make([]*SourceRange, 0, 8)
					} else {
						out.Ranges = []*SourceRange{}
					}
				} else {
					out.Ranges = (out.Ranges)[:0]
				}
				for !in.IsDelim(']') {
					var v106 *SourceRange
					if in.IsNull() {
						in.Skip()
						v106 = nil
					} else {
						if v106 == nil {
							v106 = new(SourceRange)
						}
						(*v106).UnmarshalEasyJSON(in)
					}
					out.Ranges = append(out.Ranges, v106)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss65(out *jwriter.Writer, in GetLocationForSelectorReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if len(in.Ranges) != 0 {
		const prefix string = ",\"ranges\":"
		first = false
		out.RawString(prefix[1:])
		{
			out.RawByte('[')
			for v107, v108 := range in.Ranges {
				if v107 > 0 {
					out.RawByte(',')
				}
				if v108 == nil {
					out.RawString("null")
				} else {
					(*v108).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetLocationForSelectorReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss65(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss66(in *jlexer.Lexer, out *GetLocationForSelectorParams) {
	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 "styleSheetId":
			out.StyleSheetID = StyleSheetID(in.String())
		case "selectorText":
			out.SelectorText = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss66(out *jwriter.Writer, in GetLocationForSelectorParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"styleSheetId\":"
		out.RawString(prefix[1:])
		out.String(string(in.StyleSheetID))
	}
	{
		const prefix string = ",\"selectorText\":"
		out.RawString(prefix)
		out.String(string(in.SelectorText))
	}
	out.RawByte('}')
}

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

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

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

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

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetLayersForNodeReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss67(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss68(in *jlexer.Lexer, out *GetLayersForNodeParams) {
	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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss68(out *jwriter.Writer, in GetLayersForNodeParams) {
	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 GetLayersForNodeParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss68(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetLayersForNodeParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss68(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss69(in *jlexer.Lexer, out *GetInlineStylesForNodeReturns) {
	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 "inlineStyle":
			if in.IsNull() {
				in.Skip()
				out.InlineStyle = nil
			} else {
				if out.InlineStyle == nil {
					out.InlineStyle = new(Style)
				}
				(*out.InlineStyle).UnmarshalEasyJSON(in)
			}
		case "attributesStyle":
			if in.IsNull() {
				in.Skip()
				out.AttributesStyle = nil
			} else {
				if out.AttributesStyle == nil {
					out.AttributesStyle = new(Style)
				}
				(*out.AttributesStyle).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss69(out *jwriter.Writer, in GetInlineStylesForNodeReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if in.InlineStyle != nil {
		const prefix string = ",\"inlineStyle\":"
		first = false
		out.RawString(prefix[1:])
		(*in.InlineStyle).MarshalEasyJSON(out)
	}
	if in.AttributesStyle != nil {
		const prefix string = ",\"attributesStyle\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.AttributesStyle).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetInlineStylesForNodeReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss69(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss70(in *jlexer.Lexer, out *GetInlineStylesForNodeParams) {
	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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss70(out *jwriter.Writer, in GetInlineStylesForNodeParams) {
	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 GetInlineStylesForNodeParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss70(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetInlineStylesForNodeParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss70(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss71(in *jlexer.Lexer, out *GetComputedStyleForNodeReturns) {
	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 "computedStyle":
			if in.IsNull() {
				in.Skip()
				out.ComputedStyle = nil
			} else {
				in.Delim('[')
				if out.ComputedStyle == nil {
					if !in.IsDelim(']') {
						out.ComputedStyle = make([]*ComputedStyleProperty, 0, 8)
					} else {
						out.ComputedStyle = []*ComputedStyleProperty{}
					}
				} else {
					out.ComputedStyle = (out.ComputedStyle)[:0]
				}
				for !in.IsDelim(']') {
					var v109 *ComputedStyleProperty
					if in.IsNull() {
						in.Skip()
						v109 = nil
					} else {
						if v109 == nil {
							v109 = new(ComputedStyleProperty)
						}
						(*v109).UnmarshalEasyJSON(in)
					}
					out.ComputedStyle = append(out.ComputedStyle, v109)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss71(out *jwriter.Writer, in GetComputedStyleForNodeReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if len(in.ComputedStyle) != 0 {
		const prefix string = ",\"computedStyle\":"
		first = false
		out.RawString(prefix[1:])
		{
			out.RawByte('[')
			for v110, v111 := range in.ComputedStyle {
				if v110 > 0 {
					out.RawByte(',')
				}
				if v111 == nil {
					out.RawString("null")
				} else {
					(*v111).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetComputedStyleForNodeReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss71(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss72(in *jlexer.Lexer, out *GetComputedStyleForNodeParams) {
	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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss72(out *jwriter.Writer, in GetComputedStyleForNodeParams) {
	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 GetComputedStyleForNodeParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss72(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetComputedStyleForNodeParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss72(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss73(in *jlexer.Lexer, out *GetBackgroundColorsReturns) {
	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 "backgroundColors":
			if in.IsNull() {
				in.Skip()
				out.BackgroundColors = nil
			} else {
				in.Delim('[')
				if out.BackgroundColors == nil {
					if !in.IsDelim(']') {
						out.BackgroundColors = make([]string, 0, 4)
					} else {
						out.BackgroundColors = []string{}
					}
				} else {
					out.BackgroundColors = (out.BackgroundColors)[:0]
				}
				for !in.IsDelim(']') {
					var v112 string
					v112 = string(in.String())
					out.BackgroundColors = append(out.BackgroundColors, v112)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "computedFontSize":
			out.ComputedFontSize = string(in.String())
		case "computedFontWeight":
			out.ComputedFontWeight = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss73(out *jwriter.Writer, in GetBackgroundColorsReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if len(in.BackgroundColors) != 0 {
		const prefix string = ",\"backgroundColors\":"
		first = false
		out.RawString(prefix[1:])
		{
			out.RawByte('[')
			for v113, v114 := range in.BackgroundColors {
				if v113 > 0 {
					out.RawByte(',')
				}
				out.String(string(v114))
			}
			out.RawByte(']')
		}
	}
	if in.ComputedFontSize != "" {
		const prefix string = ",\"computedFontSize\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.String(string(in.ComputedFontSize))
	}
	if in.ComputedFontWeight != "" {
		const prefix string = ",\"computedFontWeight\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.String(string(in.ComputedFontWeight))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetBackgroundColorsReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss73(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss74(in *jlexer.Lexer, out *GetBackgroundColorsParams) {
	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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss74(out *jwriter.Writer, in GetBackgroundColorsParams) {
	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 GetBackgroundColorsParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss74(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetBackgroundColorsParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss74(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss75(in *jlexer.Lexer, out *ForcePseudoStateParams) {
	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 "forcedPseudoClasses":
			if in.IsNull() {
				in.Skip()
				out.ForcedPseudoClasses = nil
			} else {
				in.Delim('[')
				if out.ForcedPseudoClasses == nil {
					if !in.IsDelim(']') {
						out.ForcedPseudoClasses = make([]string, 0, 4)
					} else {
						out.ForcedPseudoClasses = []string{}
					}
				} else {
					out.ForcedPseudoClasses = (out.ForcedPseudoClasses)[:0]
				}
				for !in.IsDelim(']') {
					var v115 string
					v115 = string(in.String())
					out.ForcedPseudoClasses = append(out.ForcedPseudoClasses, v115)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss75(out *jwriter.Writer, in ForcePseudoStateParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"nodeId\":"
		out.RawString(prefix[1:])
		out.Int64(int64(in.NodeID))
	}
	{
		const prefix string = ",\"forcedPseudoClasses\":"
		out.RawString(prefix)
		if in.ForcedPseudoClasses == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v116, v117 := range in.ForcedPseudoClasses {
				if v116 > 0 {
					out.RawByte(',')
				}
				out.String(string(v117))
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *ForcePseudoStateParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss75(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss76(in *jlexer.Lexer, out *FontVariationAxis) {
	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 "tag":
			out.Tag = string(in.String())
		case "name":
			out.Name = string(in.String())
		case "minValue":
			out.MinValue = float64(in.Float64())
		case "maxValue":
			out.MaxValue = float64(in.Float64())
		case "defaultValue":
			out.DefaultValue = float64(in.Float64())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss76(out *jwriter.Writer, in FontVariationAxis) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"tag\":"
		out.RawString(prefix[1:])
		out.String(string(in.Tag))
	}
	{
		const prefix string = ",\"name\":"
		out.RawString(prefix)
		out.String(string(in.Name))
	}
	{
		const prefix string = ",\"minValue\":"
		out.RawString(prefix)
		out.Float64(float64(in.MinValue))
	}
	{
		const prefix string = ",\"maxValue\":"
		out.RawString(prefix)
		out.Float64(float64(in.MaxValue))
	}
	{
		const prefix string = ",\"defaultValue\":"
		out.RawString(prefix)
		out.Float64(float64(in.DefaultValue))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *FontVariationAxis) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss76(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss77(in *jlexer.Lexer, out *FontPaletteValuesRule) {
	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 "styleSheetId":
			out.StyleSheetID = StyleSheetID(in.String())
		case "origin":
			(out.Origin).UnmarshalEasyJSON(in)
		case "fontPaletteName":
			if in.IsNull() {
				in.Skip()
				out.FontPaletteName = nil
			} else {
				if out.FontPaletteName == nil {
					out.FontPaletteName = new(Value)
				}
				(*out.FontPaletteName).UnmarshalEasyJSON(in)
			}
		case "style":
			if in.IsNull() {
				in.Skip()
				out.Style = nil
			} else {
				if out.Style == nil {
					out.Style = new(Style)
				}
				(*out.Style).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss77(out *jwriter.Writer, in FontPaletteValuesRule) {
	out.RawByte('{')
	first := true
	_ = first
	if in.StyleSheetID != "" {
		const prefix string = ",\"styleSheetId\":"
		first = false
		out.RawString(prefix[1:])
		out.String(string(in.StyleSheetID))
	}
	{
		const prefix string = ",\"origin\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(in.Origin).MarshalEasyJSON(out)
	}
	{
		const prefix string = ",\"fontPaletteName\":"
		out.RawString(prefix)
		if in.FontPaletteName == nil {
			out.RawString("null")
		} else {
			(*in.FontPaletteName).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"style\":"
		out.RawString(prefix)
		if in.Style == nil {
			out.RawString("null")
		} else {
			(*in.Style).MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *FontPaletteValuesRule) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss77(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss78(in *jlexer.Lexer, out *FontFace) {
	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 "fontFamily":
			out.FontFamily = string(in.String())
		case "fontStyle":
			out.FontStyle = string(in.String())
		case "fontVariant":
			out.FontVariant = string(in.String())
		case "fontWeight":
			out.FontWeight = string(in.String())
		case "fontStretch":
			out.FontStretch = string(in.String())
		case "fontDisplay":
			out.FontDisplay = string(in.String())
		case "unicodeRange":
			out.UnicodeRange = string(in.String())
		case "src":
			out.Src = string(in.String())
		case "platformFontFamily":
			out.PlatformFontFamily = string(in.String())
		case "fontVariationAxes":
			if in.IsNull() {
				in.Skip()
				out.FontVariationAxes = nil
			} else {
				in.Delim('[')
				if out.FontVariationAxes == nil {
					if !in.IsDelim(']') {
						out.FontVariationAxes = make([]*FontVariationAxis, 0, 8)
					} else {
						out.FontVariationAxes = []*FontVariationAxis{}
					}
				} else {
					out.FontVariationAxes = (out.FontVariationAxes)[:0]
				}
				for !in.IsDelim(']') {
					var v118 *FontVariationAxis
					if in.IsNull() {
						in.Skip()
						v118 = nil
					} else {
						if v118 == nil {
							v118 = new(FontVariationAxis)
						}
						(*v118).UnmarshalEasyJSON(in)
					}
					out.FontVariationAxes = append(out.FontVariationAxes, v118)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss78(out *jwriter.Writer, in FontFace) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"fontFamily\":"
		out.RawString(prefix[1:])
		out.String(string(in.FontFamily))
	}
	{
		const prefix string = ",\"fontStyle\":"
		out.RawString(prefix)
		out.String(string(in.FontStyle))
	}
	{
		const prefix string = ",\"fontVariant\":"
		out.RawString(prefix)
		out.String(string(in.FontVariant))
	}
	{
		const prefix string = ",\"fontWeight\":"
		out.RawString(prefix)
		out.String(string(in.FontWeight))
	}
	{
		const prefix string = ",\"fontStretch\":"
		out.RawString(prefix)
		out.String(string(in.FontStretch))
	}
	{
		const prefix string = ",\"fontDisplay\":"
		out.RawString(prefix)
		out.String(string(in.FontDisplay))
	}
	{
		const prefix string = ",\"unicodeRange\":"
		out.RawString(prefix)
		out.String(string(in.UnicodeRange))
	}
	{
		const prefix string = ",\"src\":"
		out.RawString(prefix)
		out.String(string(in.Src))
	}
	{
		const prefix string = ",\"platformFontFamily\":"
		out.RawString(prefix)
		out.String(string(in.PlatformFontFamily))
	}
	if len(in.FontVariationAxes) != 0 {
		const prefix string = ",\"fontVariationAxes\":"
		out.RawString(prefix)
		{
			out.RawByte('[')
			for v119, v120 := range in.FontVariationAxes {
				if v119 > 0 {
					out.RawByte(',')
				}
				if v120 == nil {
					out.RawString("null")
				} else {
					(*v120).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *FontFace) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss78(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss79(in *jlexer.Lexer, out *EventStyleSheetRemoved) {
	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 "styleSheetId":
			out.StyleSheetID = StyleSheetID(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss79(out *jwriter.Writer, in EventStyleSheetRemoved) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"styleSheetId\":"
		out.RawString(prefix[1:])
		out.String(string(in.StyleSheetID))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventStyleSheetRemoved) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss79(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss80(in *jlexer.Lexer, out *EventStyleSheetChanged) {
	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 "styleSheetId":
			out.StyleSheetID = StyleSheetID(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss80(out *jwriter.Writer, in EventStyleSheetChanged) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"styleSheetId\":"
		out.RawString(prefix[1:])
		out.String(string(in.StyleSheetID))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventStyleSheetChanged) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss80(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss81(in *jlexer.Lexer, out *EventStyleSheetAdded) {
	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 "header":
			if in.IsNull() {
				in.Skip()
				out.Header = nil
			} else {
				if out.Header == nil {
					out.Header = new(StyleSheetHeader)
				}
				(*out.Header).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss81(out *jwriter.Writer, in EventStyleSheetAdded) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"header\":"
		out.RawString(prefix[1:])
		if in.Header == nil {
			out.RawString("null")
		} else {
			(*in.Header).MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventStyleSheetAdded) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss81(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss82(in *jlexer.Lexer, out *EventMediaQueryResultChanged) {
	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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss82(out *jwriter.Writer, in EventMediaQueryResultChanged) {
	out.RawByte('{')
	first := true
	_ = first
	out.RawByte('}')
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *CreateStyleSheetParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss87(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss88(in *jlexer.Lexer, out *ContainerQuery) {
	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 "text":
			out.Text = string(in.String())
		case "range":
			if in.IsNull() {
				in.Skip()
				out.Range = nil
			} else {
				if out.Range == nil {
					out.Range = new(SourceRange)
				}
				(*out.Range).UnmarshalEasyJSON(in)
			}
		case "styleSheetId":
			out.StyleSheetID = StyleSheetID(in.String())
		case "name":
			out.Name = string(in.String())
		case "physicalAxes":
			(out.PhysicalAxes).UnmarshalEasyJSON(in)
		case "logicalAxes":
			(out.LogicalAxes).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss88(out *jwriter.Writer, in ContainerQuery) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"text\":"
		out.RawString(prefix[1:])
		out.String(string(in.Text))
	}
	if in.Range != nil {
		const prefix string = ",\"range\":"
		out.RawString(prefix)
		(*in.Range).MarshalEasyJSON(out)
	}
	if in.StyleSheetID != "" {
		const prefix string = ",\"styleSheetId\":"
		out.RawString(prefix)
		out.String(string(in.StyleSheetID))
	}
	if in.Name != "" {
		const prefix string = ",\"name\":"
		out.RawString(prefix)
		out.String(string(in.Name))
	}
	if in.PhysicalAxes != "" {
		const prefix string = ",\"physicalAxes\":"
		out.RawString(prefix)
		(in.PhysicalAxes).MarshalEasyJSON(out)
	}
	if in.LogicalAxes != "" {
		const prefix string = ",\"logicalAxes\":"
		out.RawString(prefix)
		(in.LogicalAxes).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

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

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *ComputedStyleProperty) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss89(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss90(in *jlexer.Lexer, out *CollectClassNamesReturns) {
	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 "classNames":
			if in.IsNull() {
				in.Skip()
				out.ClassNames = nil
			} else {
				in.Delim('[')
				if out.ClassNames == nil {
					if !in.IsDelim(']') {
						out.ClassNames = make([]string, 0, 4)
					} else {
						out.ClassNames = []string{}
					}
				} else {
					out.ClassNames = (out.ClassNames)[:0]
				}
				for !in.IsDelim(']') {
					var v121 string
					v121 = string(in.String())
					out.ClassNames = append(out.ClassNames, v121)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss90(out *jwriter.Writer, in CollectClassNamesReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if len(in.ClassNames) != 0 {
		const prefix string = ",\"classNames\":"
		first = false
		out.RawString(prefix[1:])
		{
			out.RawByte('[')
			for v122, v123 := range in.ClassNames {
				if v122 > 0 {
					out.RawByte(',')
				}
				out.String(string(v123))
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *CollectClassNamesReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss90(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss91(in *jlexer.Lexer, out *CollectClassNamesParams) {
	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 "styleSheetId":
			out.StyleSheetID = StyleSheetID(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss91(out *jwriter.Writer, in CollectClassNamesParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"styleSheetId\":"
		out.RawString(prefix[1:])
		out.String(string(in.StyleSheetID))
	}
	out.RawByte('}')
}

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

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

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

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

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *AddRuleReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss92(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss93(in *jlexer.Lexer, out *AddRuleParams) {
	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 "styleSheetId":
			out.StyleSheetID = StyleSheetID(in.String())
		case "ruleText":
			out.RuleText = string(in.String())
		case "location":
			if in.IsNull() {
				in.Skip()
				out.Location = nil
			} else {
				if out.Location == nil {
					out.Location = new(SourceRange)
				}
				(*out.Location).UnmarshalEasyJSON(in)
			}
		case "nodeForPropertySyntaxValidation":
			(out.NodeForPropertySyntaxValidation).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss93(out *jwriter.Writer, in AddRuleParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"styleSheetId\":"
		out.RawString(prefix[1:])
		out.String(string(in.StyleSheetID))
	}
	{
		const prefix string = ",\"ruleText\":"
		out.RawString(prefix)
		out.String(string(in.RuleText))
	}
	{
		const prefix string = ",\"location\":"
		out.RawString(prefix)
		if in.Location == nil {
			out.RawString("null")
		} else {
			(*in.Location).MarshalEasyJSON(out)
		}
	}
	if in.NodeForPropertySyntaxValidation != 0 {
		const prefix string = ",\"nodeForPropertySyntaxValidation\":"
		out.RawString(prefix)
		out.Int64(int64(in.NodeForPropertySyntaxValidation))
	}
	out.RawByte('}')
}

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

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

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

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