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

package css

import (
	json "encoding/json"
	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.UnsafeString()
		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)
			}
		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)
	}
	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 *TakeCoverageDeltaReturns) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		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 v1 *RuleUsage
					if in.IsNull() {
						in.Skip()
						v1 = nil
					} else {
						if v1 == nil {
							v1 = new(RuleUsage)
						}
						(*v1).UnmarshalEasyJSON(in)
					}
					out.Coverage = append(out.Coverage, v1)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "timestamp":
			out.Timestamp = float64(in.Float64())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss1(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 v2, v3 := range in.Coverage {
				if v2 > 0 {
					out.RawByte(',')
				}
				if v3 == nil {
					out.RawString("null")
				} else {
					(*v3).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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss1(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *TakeCoverageDeltaReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss1(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss2(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.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss2(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss2(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *TakeCoverageDeltaParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss2(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss3(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.UnsafeString()
		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 "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())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss3(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 = ",\"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))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *StyleSheetHeader) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss3(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss4(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.UnsafeString()
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss4(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss4(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *StyleDeclarationEdit) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss4(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss5(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.UnsafeString()
		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 v4 *Property
					if in.IsNull() {
						in.Skip()
						v4 = nil
					} else {
						if v4 == nil {
							v4 = new(Property)
						}
						(*v4).UnmarshalEasyJSON(in)
					}
					out.CSSProperties = append(out.CSSProperties, v4)
					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 v5 *ShorthandEntry
					if in.IsNull() {
						in.Skip()
						v5 = nil
					} else {
						if v5 == nil {
							v5 = new(ShorthandEntry)
						}
						(*v5).UnmarshalEasyJSON(in)
					}
					out.ShorthandEntries = append(out.ShorthandEntries, v5)
					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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss5(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 v6, v7 := range in.CSSProperties {
				if v6 > 0 {
					out.RawByte(',')
				}
				if v7 == nil {
					out.RawString("null")
				} else {
					(*v7).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 v8, v9 := range in.ShorthandEntries {
				if v8 > 0 {
					out.RawByte(',')
				}
				if v9 == nil {
					out.RawString("null")
				} else {
					(*v9).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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss5(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *Style) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss5(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss6(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.UnsafeString()
		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 v10 *RuleUsage
					if in.IsNull() {
						in.Skip()
						v10 = nil
					} else {
						if v10 == nil {
							v10 = new(RuleUsage)
						}
						(*v10).UnmarshalEasyJSON(in)
					}
					out.RuleUsage = append(out.RuleUsage, v10)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss6(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 v11, v12 := range in.RuleUsage {
				if v11 > 0 {
					out.RawByte(',')
				}
				if v12 == nil {
					out.RawString("null")
				} else {
					(*v12).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *StopRuleUsageTrackingReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss6(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss7(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.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss7(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss7(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *StopRuleUsageTrackingParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss7(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss8(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.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss8(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss8(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *StartRuleUsageTrackingParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss8(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss9(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.UnsafeString()
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss9(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss9(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SourceRange) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss9(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss10(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.UnsafeString()
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss10(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss10(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *ShorthandEntry) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss10(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss11(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.UnsafeString()
		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 v13 *Style
					if in.IsNull() {
						in.Skip()
						v13 = nil
					} else {
						if v13 == nil {
							v13 = new(Style)
						}
						(*v13).UnmarshalEasyJSON(in)
					}
					out.Styles = append(out.Styles, v13)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss11(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 v14, v15 := range in.Styles {
				if v14 > 0 {
					out.RawByte(',')
				}
				if v15 == nil {
					out.RawString("null")
				} else {
					(*v15).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetStyleTextsReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss11(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss12(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.UnsafeString()
		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 v16 *StyleDeclarationEdit
					if in.IsNull() {
						in.Skip()
						v16 = nil
					} else {
						if v16 == nil {
							v16 = new(StyleDeclarationEdit)
						}
						(*v16).UnmarshalEasyJSON(in)
					}
					out.Edits = append(out.Edits, v16)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss12(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 v17, v18 := range in.Edits {
				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 SetStyleTextsParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss12(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetStyleTextsParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss12(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss13(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.UnsafeString()
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss13(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss13(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetStyleSheetTextReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss13(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss14(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.UnsafeString()
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss14(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss14(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetStyleSheetTextParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss14(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss15(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.UnsafeString()
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss15(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss15(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetRuleSelectorReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss15(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss16(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.UnsafeString()
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss16(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss16(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetRuleSelectorParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss16(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss17(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.UnsafeString()
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss17(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss17(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetMediaTextReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss17(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss18(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.UnsafeString()
		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 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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss18(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetMediaTextParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss18(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss19(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.UnsafeString()
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss19(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss19(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetKeyframeKeyReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss19(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss20(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.UnsafeString()
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss20(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss20(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetKeyframeKeyParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss20(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss21(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.UnsafeString()
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss21(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss21(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetEffectivePropertyValueForNodeParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss21(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss22(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.UnsafeString()
		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 v19 *Value
					if in.IsNull() {
						in.Skip()
						v19 = nil
					} else {
						if v19 == nil {
							v19 = new(Value)
						}
						(*v19).UnmarshalEasyJSON(in)
					}
					out.Selectors = append(out.Selectors, v19)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "text":
			out.Text = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss22(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 v20, v21 := range in.Selectors {
				if v20 > 0 {
					out.RawByte(',')
				}
				if v21 == nil {
					out.RawString("null")
				} else {
					(*v21).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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss22(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SelectorList) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss22(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss23(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.UnsafeString()
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss23(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss23(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *RuleUsage) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss23(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss24(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.UnsafeString()
		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 v22 int64
					v22 = int64(in.Int64())
					out.MatchingSelectors = append(out.MatchingSelectors, v22)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss24(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 v23, v24 := range in.MatchingSelectors {
				if v23 > 0 {
					out.RawByte(',')
				}
				out.Int64(int64(v24))
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *RuleMatch) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss24(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss25(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.UnsafeString()
		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 "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 v25 *Media
					if in.IsNull() {
						in.Skip()
						v25 = nil
					} else {
						if v25 == nil {
							v25 = new(Media)
						}
						(*v25).UnmarshalEasyJSON(in)
					}
					out.Media = append(out.Media, v25)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss25(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)
		}
	}
	{
		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 v26, v27 := range in.Media {
				if v26 > 0 {
					out.RawByte(',')
				}
				if v27 == nil {
					out.RawString("null")
				} else {
					(*v27).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *Rule) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss25(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss26(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.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "pseudoType":
			(out.PseudoType).UnmarshalEasyJSON(in)
		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 v28 *RuleMatch
					if in.IsNull() {
						in.Skip()
						v28 = nil
					} else {
						if v28 == nil {
							v28 = new(RuleMatch)
						}
						(*v28).UnmarshalEasyJSON(in)
					}
					out.Matches = append(out.Matches, v28)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss26(out *jwriter.Writer, in PseudoElementMatches) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"pseudoType\":"
		out.RawString(prefix[1:])
		(in.PseudoType).MarshalEasyJSON(out)
	}
	{
		const prefix string = ",\"matches\":"
		out.RawString(prefix)
		if in.Matches == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v29, v30 := range in.Matches {
				if v29 > 0 {
					out.RawByte(',')
				}
				if v30 == nil {
					out.RawString("null")
				} else {
					(*v30).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *PseudoElementMatches) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss26(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss27(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.UnsafeString()
		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)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss27(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)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *Property) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss27(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss28(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.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "familyName":
			out.FamilyName = 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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss28(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 = ",\"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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss28(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *PlatformFontUsage) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss28(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss29(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.UnsafeString()
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss29(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss29(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *MediaQueryExpression) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss29(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss30(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.UnsafeString()
		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 v31 *MediaQueryExpression
					if in.IsNull() {
						in.Skip()
						v31 = nil
					} else {
						if v31 == nil {
							v31 = new(MediaQueryExpression)
						}
						(*v31).UnmarshalEasyJSON(in)
					}
					out.Expressions = append(out.Expressions, v31)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "active":
			out.Active = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss30(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 v32, v33 := range in.Expressions {
				if v32 > 0 {
					out.RawByte(',')
				}
				if v33 == nil {
					out.RawString("null")
				} else {
					(*v33).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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss30(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *MediaQuery) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss30(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss31(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.UnsafeString()
		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 v34 *MediaQuery
					if in.IsNull() {
						in.Skip()
						v34 = nil
					} else {
						if v34 == nil {
							v34 = new(MediaQuery)
						}
						(*v34).UnmarshalEasyJSON(in)
					}
					out.MediaList = append(out.MediaList, v34)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss31(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 v35, v36 := range in.MediaList {
				if v35 > 0 {
					out.RawByte(',')
				}
				if v36 == nil {
					out.RawString("null")
				} else {
					(*v36).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *Media) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss31(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss32(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.UnsafeString()
		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 v37 *KeyframeRule
					if in.IsNull() {
						in.Skip()
						v37 = nil
					} else {
						if v37 == nil {
							v37 = new(KeyframeRule)
						}
						(*v37).UnmarshalEasyJSON(in)
					}
					out.Keyframes = append(out.Keyframes, v37)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss32(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 v38, v39 := range in.Keyframes {
				if v38 > 0 {
					out.RawByte(',')
				}
				if v39 == nil {
					out.RawString("null")
				} else {
					(*v39).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *KeyframesRule) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss32(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss33(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.UnsafeString()
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss33(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss33(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *KeyframeRule) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss33(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss34(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.UnsafeString()
		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 v40 *RuleMatch
					if in.IsNull() {
						in.Skip()
						v40 = nil
					} else {
						if v40 == nil {
							v40 = new(RuleMatch)
						}
						(*v40).UnmarshalEasyJSON(in)
					}
					out.MatchedCSSRules = append(out.MatchedCSSRules, v40)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss34(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 v41, v42 := range in.MatchedCSSRules {
				if v41 > 0 {
					out.RawByte(',')
				}
				if v42 == nil {
					out.RawString("null")
				} else {
					(*v42).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *InheritedStyleEntry) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss34(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss35(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.UnsafeString()
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss35(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss35(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetStyleSheetTextReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss35(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss36(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.UnsafeString()
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss36(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss36(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetStyleSheetTextParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss36(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss37(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.UnsafeString()
		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 v43 *PlatformFontUsage
					if in.IsNull() {
						in.Skip()
						v43 = nil
					} else {
						if v43 == nil {
							v43 = new(PlatformFontUsage)
						}
						(*v43).UnmarshalEasyJSON(in)
					}
					out.Fonts = append(out.Fonts, v43)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss37(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 v44, v45 := range in.Fonts {
				if v44 > 0 {
					out.RawByte(',')
				}
				if v45 == nil {
					out.RawString("null")
				} else {
					(*v45).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetPlatformFontsForNodeReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss37(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss38(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.UnsafeString()
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss38(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss38(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetPlatformFontsForNodeParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss38(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss39(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.UnsafeString()
		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 v46 *Media
					if in.IsNull() {
						in.Skip()
						v46 = nil
					} else {
						if v46 == nil {
							v46 = new(Media)
						}
						(*v46).UnmarshalEasyJSON(in)
					}
					out.Medias = append(out.Medias, v46)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss39(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 v47, v48 := range in.Medias {
				if v47 > 0 {
					out.RawByte(',')
				}
				if v48 == nil {
					out.RawString("null")
				} else {
					(*v48).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetMediaQueriesReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss39(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss40(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.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss40(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss40(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetMediaQueriesParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss40(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss41(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.UnsafeString()
		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 v49 *RuleMatch
					if in.IsNull() {
						in.Skip()
						v49 = nil
					} else {
						if v49 == nil {
							v49 = new(RuleMatch)
						}
						(*v49).UnmarshalEasyJSON(in)
					}
					out.MatchedCSSRules = append(out.MatchedCSSRules, v49)
					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 v50 *PseudoElementMatches
					if in.IsNull() {
						in.Skip()
						v50 = nil
					} else {
						if v50 == nil {
							v50 = new(PseudoElementMatches)
						}
						(*v50).UnmarshalEasyJSON(in)
					}
					out.PseudoElements = append(out.PseudoElements, v50)
					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 v51 *InheritedStyleEntry
					if in.IsNull() {
						in.Skip()
						v51 = nil
					} else {
						if v51 == nil {
							v51 = new(InheritedStyleEntry)
						}
						(*v51).UnmarshalEasyJSON(in)
					}
					out.Inherited = append(out.Inherited, v51)
					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 v52 *KeyframesRule
					if in.IsNull() {
						in.Skip()
						v52 = nil
					} else {
						if v52 == nil {
							v52 = new(KeyframesRule)
						}
						(*v52).UnmarshalEasyJSON(in)
					}
					out.CSSKeyframesRules = append(out.CSSKeyframesRules, v52)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss41(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 v53, v54 := range in.MatchedCSSRules {
				if v53 > 0 {
					out.RawByte(',')
				}
				if v54 == nil {
					out.RawString("null")
				} else {
					(*v54).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 v55, v56 := range in.PseudoElements {
				if v55 > 0 {
					out.RawByte(',')
				}
				if v56 == nil {
					out.RawString("null")
				} else {
					(*v56).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 v57, v58 := range in.Inherited {
				if v57 > 0 {
					out.RawByte(',')
				}
				if v58 == nil {
					out.RawString("null")
				} else {
					(*v58).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 v59, v60 := range in.CSSKeyframesRules {
				if v59 > 0 {
					out.RawByte(',')
				}
				if v60 == nil {
					out.RawString("null")
				} else {
					(*v60).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetMatchedStylesForNodeReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss41(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss42(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.UnsafeString()
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss42(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss42(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetMatchedStylesForNodeParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss42(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss43(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.UnsafeString()
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss43(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss43(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetInlineStylesForNodeReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss43(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss44(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.UnsafeString()
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss44(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss44(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetInlineStylesForNodeParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss44(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss45(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.UnsafeString()
		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 v61 *ComputedStyleProperty
					if in.IsNull() {
						in.Skip()
						v61 = nil
					} else {
						if v61 == nil {
							v61 = new(ComputedStyleProperty)
						}
						(*v61).UnmarshalEasyJSON(in)
					}
					out.ComputedStyle = append(out.ComputedStyle, v61)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss45(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 v62, v63 := range in.ComputedStyle {
				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 GetComputedStyleForNodeReturns) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss45(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetComputedStyleForNodeReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss45(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss46(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.UnsafeString()
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss46(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss46(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetComputedStyleForNodeParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss46(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss47(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.UnsafeString()
		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 v64 string
					v64 = string(in.String())
					out.BackgroundColors = append(out.BackgroundColors, v64)
					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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss47(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 v65, v66 := range in.BackgroundColors {
				if v65 > 0 {
					out.RawByte(',')
				}
				out.String(string(v66))
			}
			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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss47(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetBackgroundColorsReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss47(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss48(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.UnsafeString()
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss48(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss48(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetBackgroundColorsParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss48(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss49(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.UnsafeString()
		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 v67 string
					v67 = string(in.String())
					out.ForcedPseudoClasses = append(out.ForcedPseudoClasses, v67)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss49(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 v68, v69 := range in.ForcedPseudoClasses {
				if v68 > 0 {
					out.RawByte(',')
				}
				out.String(string(v69))
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *ForcePseudoStateParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss49(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss50(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.UnsafeString()
		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 "unicodeRange":
			out.UnicodeRange = string(in.String())
		case "src":
			out.Src = string(in.String())
		case "platformFontFamily":
			out.PlatformFontFamily = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss50(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 = ",\"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))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *FontFace) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss50(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss51(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.UnsafeString()
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss51(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss51(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventStyleSheetRemoved) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss51(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss52(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.UnsafeString()
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss52(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss52(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventStyleSheetChanged) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss52(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss53(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.UnsafeString()
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss53(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss53(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventStyleSheetAdded) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss53(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss54(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.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss54(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss54(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventMediaQueryResultChanged) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss54(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss55(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.UnsafeString()
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss55(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss55(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventFontsUpdated) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss55(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss56(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.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss56(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss56(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EnableParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss56(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss57(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.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss57(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss57(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *DisableParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss57(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss58(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.UnsafeString()
		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 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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss58(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *CreateStyleSheetReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss58(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss59(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.UnsafeString()
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss59(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss59(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *CreateStyleSheetParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss59(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss60(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.UnsafeString()
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss60(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss60(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *ComputedStyleProperty) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss60(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss61(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.UnsafeString()
		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 v70 string
					v70 = string(in.String())
					out.ClassNames = append(out.ClassNames, v70)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss61(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 v71, v72 := range in.ClassNames {
				if v71 > 0 {
					out.RawByte(',')
				}
				out.String(string(v72))
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *CollectClassNamesReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss61(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss62(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.UnsafeString()
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss62(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss62(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *CollectClassNamesParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss62(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss63(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.UnsafeString()
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss63(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss63(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *AddRuleReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss63(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoCss64(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.UnsafeString()
		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)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoCss64(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)
		}
	}
	out.RawByte('}')
}

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

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

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

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