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

package emulation

import (
	json "encoding/json"
	cdp "github.com/chromedp/cdproto/cdp"
	page "github.com/chromedp/cdproto/page"
	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 easyjsonC5a4559bDecodeGithubComChromedpCdprotoEmulation(in *jlexer.Lexer, out *UserAgentMetadata) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "brands":
			if in.IsNull() {
				in.Skip()
				out.Brands = nil
			} else {
				in.Delim('[')
				if out.Brands == nil {
					if !in.IsDelim(']') {
						out.Brands = make([]*UserAgentBrandVersion, 0, 8)
					} else {
						out.Brands = []*UserAgentBrandVersion{}
					}
				} else {
					out.Brands = (out.Brands)[:0]
				}
				for !in.IsDelim(']') {
					var v1 *UserAgentBrandVersion
					if in.IsNull() {
						in.Skip()
						v1 = nil
					} else {
						if v1 == nil {
							v1 = new(UserAgentBrandVersion)
						}
						(*v1).UnmarshalEasyJSON(in)
					}
					out.Brands = append(out.Brands, v1)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "fullVersionList":
			if in.IsNull() {
				in.Skip()
				out.FullVersionList = nil
			} else {
				in.Delim('[')
				if out.FullVersionList == nil {
					if !in.IsDelim(']') {
						out.FullVersionList = make([]*UserAgentBrandVersion, 0, 8)
					} else {
						out.FullVersionList = []*UserAgentBrandVersion{}
					}
				} else {
					out.FullVersionList = (out.FullVersionList)[:0]
				}
				for !in.IsDelim(']') {
					var v2 *UserAgentBrandVersion
					if in.IsNull() {
						in.Skip()
						v2 = nil
					} else {
						if v2 == nil {
							v2 = new(UserAgentBrandVersion)
						}
						(*v2).UnmarshalEasyJSON(in)
					}
					out.FullVersionList = append(out.FullVersionList, v2)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "platform":
			out.Platform = string(in.String())
		case "platformVersion":
			out.PlatformVersion = string(in.String())
		case "architecture":
			out.Architecture = string(in.String())
		case "model":
			out.Model = string(in.String())
		case "mobile":
			out.Mobile = bool(in.Bool())
		case "bitness":
			out.Bitness = string(in.String())
		case "wow64":
			out.Wow64 = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoEmulation(out *jwriter.Writer, in UserAgentMetadata) {
	out.RawByte('{')
	first := true
	_ = first
	if len(in.Brands) != 0 {
		const prefix string = ",\"brands\":"
		first = false
		out.RawString(prefix[1:])
		{
			out.RawByte('[')
			for v3, v4 := range in.Brands {
				if v3 > 0 {
					out.RawByte(',')
				}
				if v4 == nil {
					out.RawString("null")
				} else {
					(*v4).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	if len(in.FullVersionList) != 0 {
		const prefix string = ",\"fullVersionList\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		{
			out.RawByte('[')
			for v5, v6 := range in.FullVersionList {
				if v5 > 0 {
					out.RawByte(',')
				}
				if v6 == nil {
					out.RawString("null")
				} else {
					(*v6).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	{
		const prefix string = ",\"platform\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.String(string(in.Platform))
	}
	{
		const prefix string = ",\"platformVersion\":"
		out.RawString(prefix)
		out.String(string(in.PlatformVersion))
	}
	{
		const prefix string = ",\"architecture\":"
		out.RawString(prefix)
		out.String(string(in.Architecture))
	}
	{
		const prefix string = ",\"model\":"
		out.RawString(prefix)
		out.String(string(in.Model))
	}
	{
		const prefix string = ",\"mobile\":"
		out.RawString(prefix)
		out.Bool(bool(in.Mobile))
	}
	if in.Bitness != "" {
		const prefix string = ",\"bitness\":"
		out.RawString(prefix)
		out.String(string(in.Bitness))
	}
	if in.Wow64 {
		const prefix string = ",\"wow64\":"
		out.RawString(prefix)
		out.Bool(bool(in.Wow64))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *UserAgentMetadata) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoEmulation(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoEmulation1(in *jlexer.Lexer, out *UserAgentBrandVersion) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "brand":
			out.Brand = string(in.String())
		case "version":
			out.Version = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoEmulation1(out *jwriter.Writer, in UserAgentBrandVersion) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"brand\":"
		out.RawString(prefix[1:])
		out.String(string(in.Brand))
	}
	{
		const prefix string = ",\"version\":"
		out.RawString(prefix)
		out.String(string(in.Version))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *UserAgentBrandVersion) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoEmulation1(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoEmulation2(in *jlexer.Lexer, out *SetVirtualTimePolicyReturns) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "virtualTimeTicksBase":
			out.VirtualTimeTicksBase = float64(in.Float64())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoEmulation2(out *jwriter.Writer, in SetVirtualTimePolicyReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if in.VirtualTimeTicksBase != 0 {
		const prefix string = ",\"virtualTimeTicksBase\":"
		first = false
		out.RawString(prefix[1:])
		out.Float64(float64(in.VirtualTimeTicksBase))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetVirtualTimePolicyReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoEmulation2(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoEmulation3(in *jlexer.Lexer, out *SetVirtualTimePolicyParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "policy":
			(out.Policy).UnmarshalEasyJSON(in)
		case "budget":
			out.Budget = float64(in.Float64())
		case "maxVirtualTimeTaskStarvationCount":
			out.MaxVirtualTimeTaskStarvationCount = int64(in.Int64())
		case "initialVirtualTime":
			if in.IsNull() {
				in.Skip()
				out.InitialVirtualTime = nil
			} else {
				if out.InitialVirtualTime == nil {
					out.InitialVirtualTime = new(cdp.TimeSinceEpoch)
				}
				(*out.InitialVirtualTime).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoEmulation3(out *jwriter.Writer, in SetVirtualTimePolicyParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"policy\":"
		out.RawString(prefix[1:])
		(in.Policy).MarshalEasyJSON(out)
	}
	if in.Budget != 0 {
		const prefix string = ",\"budget\":"
		out.RawString(prefix)
		out.Float64(float64(in.Budget))
	}
	if in.MaxVirtualTimeTaskStarvationCount != 0 {
		const prefix string = ",\"maxVirtualTimeTaskStarvationCount\":"
		out.RawString(prefix)
		out.Int64(int64(in.MaxVirtualTimeTaskStarvationCount))
	}
	if in.InitialVirtualTime != nil {
		const prefix string = ",\"initialVirtualTime\":"
		out.RawString(prefix)
		(*in.InitialVirtualTime).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetVirtualTimePolicyParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoEmulation3(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoEmulation4(in *jlexer.Lexer, out *SetUserAgentOverrideParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "userAgent":
			out.UserAgent = string(in.String())
		case "acceptLanguage":
			out.AcceptLanguage = string(in.String())
		case "platform":
			out.Platform = string(in.String())
		case "userAgentMetadata":
			if in.IsNull() {
				in.Skip()
				out.UserAgentMetadata = nil
			} else {
				if out.UserAgentMetadata == nil {
					out.UserAgentMetadata = new(UserAgentMetadata)
				}
				(*out.UserAgentMetadata).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoEmulation4(out *jwriter.Writer, in SetUserAgentOverrideParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"userAgent\":"
		out.RawString(prefix[1:])
		out.String(string(in.UserAgent))
	}
	if in.AcceptLanguage != "" {
		const prefix string = ",\"acceptLanguage\":"
		out.RawString(prefix)
		out.String(string(in.AcceptLanguage))
	}
	if in.Platform != "" {
		const prefix string = ",\"platform\":"
		out.RawString(prefix)
		out.String(string(in.Platform))
	}
	if in.UserAgentMetadata != nil {
		const prefix string = ",\"userAgentMetadata\":"
		out.RawString(prefix)
		(*in.UserAgentMetadata).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetSensorOverrideReadingsParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoEmulation7(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoEmulation8(in *jlexer.Lexer, out *SetSensorOverrideEnabledParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "enabled":
			out.Enabled = bool(in.Bool())
		case "type":
			(out.Type).UnmarshalEasyJSON(in)
		case "metadata":
			if in.IsNull() {
				in.Skip()
				out.Metadata = nil
			} else {
				if out.Metadata == nil {
					out.Metadata = new(SensorMetadata)
				}
				(*out.Metadata).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoEmulation8(out *jwriter.Writer, in SetSensorOverrideEnabledParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"enabled\":"
		out.RawString(prefix[1:])
		out.Bool(bool(in.Enabled))
	}
	{
		const prefix string = ",\"type\":"
		out.RawString(prefix)
		(in.Type).MarshalEasyJSON(out)
	}
	if in.Metadata != nil {
		const prefix string = ",\"metadata\":"
		out.RawString(prefix)
		(*in.Metadata).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetPressureStateOverrideParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoEmulation11(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoEmulation12(in *jlexer.Lexer, out *SetPressureSourceOverrideEnabledParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "enabled":
			out.Enabled = bool(in.Bool())
		case "source":
			(out.Source).UnmarshalEasyJSON(in)
		case "metadata":
			if in.IsNull() {
				in.Skip()
				out.Metadata = nil
			} else {
				if out.Metadata == nil {
					out.Metadata = new(PressureMetadata)
				}
				(*out.Metadata).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoEmulation12(out *jwriter.Writer, in SetPressureSourceOverrideEnabledParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"enabled\":"
		out.RawString(prefix[1:])
		out.Bool(bool(in.Enabled))
	}
	{
		const prefix string = ",\"source\":"
		out.RawString(prefix)
		(in.Source).MarshalEasyJSON(out)
	}
	if in.Metadata != nil {
		const prefix string = ",\"metadata\":"
		out.RawString(prefix)
		(*in.Metadata).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetPressureSourceOverrideEnabledParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoEmulation12(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoEmulation13(in *jlexer.Lexer, out *SetPageScaleFactorParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "pageScaleFactor":
			out.PageScaleFactor = float64(in.Float64())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoEmulation13(out *jwriter.Writer, in SetPageScaleFactorParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"pageScaleFactor\":"
		out.RawString(prefix[1:])
		out.Float64(float64(in.PageScaleFactor))
	}
	out.RawByte('}')
}

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

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

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

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

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetLocaleOverrideParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoEmulation14(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoEmulation15(in *jlexer.Lexer, out *SetIdleOverrideParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "isUserActive":
			out.IsUserActive = bool(in.Bool())
		case "isScreenUnlocked":
			out.IsScreenUnlocked = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoEmulation15(out *jwriter.Writer, in SetIdleOverrideParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"isUserActive\":"
		out.RawString(prefix[1:])
		out.Bool(bool(in.IsUserActive))
	}
	{
		const prefix string = ",\"isScreenUnlocked\":"
		out.RawString(prefix)
		out.Bool(bool(in.IsScreenUnlocked))
	}
	out.RawByte('}')
}

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

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

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

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

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetHardwareConcurrencyOverrideParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoEmulation16(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoEmulation17(in *jlexer.Lexer, out *SetGeolocationOverrideParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "latitude":
			out.Latitude = float64(in.Float64())
		case "longitude":
			out.Longitude = float64(in.Float64())
		case "accuracy":
			out.Accuracy = float64(in.Float64())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoEmulation17(out *jwriter.Writer, in SetGeolocationOverrideParams) {
	out.RawByte('{')
	first := true
	_ = first
	if in.Latitude != 0 {
		const prefix string = ",\"latitude\":"
		first = false
		out.RawString(prefix[1:])
		out.Float64(float64(in.Latitude))
	}
	if in.Longitude != 0 {
		const prefix string = ",\"longitude\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.Float64(float64(in.Longitude))
	}
	if in.Accuracy != 0 {
		const prefix string = ",\"accuracy\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.Float64(float64(in.Accuracy))
	}
	out.RawByte('}')
}

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

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

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

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

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

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

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

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

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetEmulatedVisionDeficiencyParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoEmulation19(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoEmulation20(in *jlexer.Lexer, out *SetEmulatedMediaParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "media":
			out.Media = string(in.String())
		case "features":
			if in.IsNull() {
				in.Skip()
				out.Features = nil
			} else {
				in.Delim('[')
				if out.Features == nil {
					if !in.IsDelim(']') {
						out.Features = make([]*MediaFeature, 0, 8)
					} else {
						out.Features = []*MediaFeature{}
					}
				} else {
					out.Features = (out.Features)[:0]
				}
				for !in.IsDelim(']') {
					var v7 *MediaFeature
					if in.IsNull() {
						in.Skip()
						v7 = nil
					} else {
						if v7 == nil {
							v7 = new(MediaFeature)
						}
						(*v7).UnmarshalEasyJSON(in)
					}
					out.Features = append(out.Features, v7)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoEmulation20(out *jwriter.Writer, in SetEmulatedMediaParams) {
	out.RawByte('{')
	first := true
	_ = first
	if in.Media != "" {
		const prefix string = ",\"media\":"
		first = false
		out.RawString(prefix[1:])
		out.String(string(in.Media))
	}
	if len(in.Features) != 0 {
		const prefix string = ",\"features\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		{
			out.RawByte('[')
			for v8, v9 := range in.Features {
				if v8 > 0 {
					out.RawByte(',')
				}
				if v9 == nil {
					out.RawString("null")
				} else {
					(*v9).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

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

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

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

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

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

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetDocumentCookieDisabledParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoEmulation22(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoEmulation23(in *jlexer.Lexer, out *SetDisabledImageTypesParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "imageTypes":
			if in.IsNull() {
				in.Skip()
				out.ImageTypes = nil
			} else {
				in.Delim('[')
				if out.ImageTypes == nil {
					if !in.IsDelim(']') {
						out.ImageTypes = make([]DisabledImageType, 0, 4)
					} else {
						out.ImageTypes = []DisabledImageType{}
					}
				} else {
					out.ImageTypes = (out.ImageTypes)[:0]
				}
				for !in.IsDelim(']') {
					var v10 DisabledImageType
					(v10).UnmarshalEasyJSON(in)
					out.ImageTypes = append(out.ImageTypes, v10)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoEmulation23(out *jwriter.Writer, in SetDisabledImageTypesParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"imageTypes\":"
		out.RawString(prefix[1:])
		if in.ImageTypes == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v11, v12 := range in.ImageTypes {
				if v11 > 0 {
					out.RawByte(',')
				}
				(v12).MarshalEasyJSON(out)
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

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

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetDevicePostureOverrideParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoEmulation24(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoEmulation25(in *jlexer.Lexer, out *SetDeviceMetricsOverrideParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "width":
			out.Width = int64(in.Int64())
		case "height":
			out.Height = int64(in.Int64())
		case "deviceScaleFactor":
			out.DeviceScaleFactor = float64(in.Float64())
		case "mobile":
			out.Mobile = bool(in.Bool())
		case "scale":
			out.Scale = float64(in.Float64())
		case "screenWidth":
			out.ScreenWidth = int64(in.Int64())
		case "screenHeight":
			out.ScreenHeight = int64(in.Int64())
		case "positionX":
			out.PositionX = int64(in.Int64())
		case "positionY":
			out.PositionY = int64(in.Int64())
		case "dontSetVisibleSize":
			out.DontSetVisibleSize = bool(in.Bool())
		case "screenOrientation":
			if in.IsNull() {
				in.Skip()
				out.ScreenOrientation = nil
			} else {
				if out.ScreenOrientation == nil {
					out.ScreenOrientation = new(ScreenOrientation)
				}
				(*out.ScreenOrientation).UnmarshalEasyJSON(in)
			}
		case "viewport":
			if in.IsNull() {
				in.Skip()
				out.Viewport = nil
			} else {
				if out.Viewport == nil {
					out.Viewport = new(page.Viewport)
				}
				(*out.Viewport).UnmarshalEasyJSON(in)
			}
		case "displayFeature":
			if in.IsNull() {
				in.Skip()
				out.DisplayFeature = nil
			} else {
				if out.DisplayFeature == nil {
					out.DisplayFeature = new(DisplayFeature)
				}
				(*out.DisplayFeature).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoEmulation25(out *jwriter.Writer, in SetDeviceMetricsOverrideParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"width\":"
		out.RawString(prefix[1:])
		out.Int64(int64(in.Width))
	}
	{
		const prefix string = ",\"height\":"
		out.RawString(prefix)
		out.Int64(int64(in.Height))
	}
	{
		const prefix string = ",\"deviceScaleFactor\":"
		out.RawString(prefix)
		out.Float64(float64(in.DeviceScaleFactor))
	}
	{
		const prefix string = ",\"mobile\":"
		out.RawString(prefix)
		out.Bool(bool(in.Mobile))
	}
	if in.Scale != 0 {
		const prefix string = ",\"scale\":"
		out.RawString(prefix)
		out.Float64(float64(in.Scale))
	}
	if in.ScreenWidth != 0 {
		const prefix string = ",\"screenWidth\":"
		out.RawString(prefix)
		out.Int64(int64(in.ScreenWidth))
	}
	if in.ScreenHeight != 0 {
		const prefix string = ",\"screenHeight\":"
		out.RawString(prefix)
		out.Int64(int64(in.ScreenHeight))
	}
	if in.PositionX != 0 {
		const prefix string = ",\"positionX\":"
		out.RawString(prefix)
		out.Int64(int64(in.PositionX))
	}
	if in.PositionY != 0 {
		const prefix string = ",\"positionY\":"
		out.RawString(prefix)
		out.Int64(int64(in.PositionY))
	}
	if in.DontSetVisibleSize {
		const prefix string = ",\"dontSetVisibleSize\":"
		out.RawString(prefix)
		out.Bool(bool(in.DontSetVisibleSize))
	}
	if in.ScreenOrientation != nil {
		const prefix string = ",\"screenOrientation\":"
		out.RawString(prefix)
		(*in.ScreenOrientation).MarshalEasyJSON(out)
	}
	if in.Viewport != nil {
		const prefix string = ",\"viewport\":"
		out.RawString(prefix)
		(*in.Viewport).MarshalEasyJSON(out)
	}
	if in.DisplayFeature != nil {
		const prefix string = ",\"displayFeature\":"
		out.RawString(prefix)
		(*in.DisplayFeature).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

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

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetDefaultBackgroundColorOverrideParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoEmulation26(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoEmulation27(in *jlexer.Lexer, out *SetCPUThrottlingRateParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "rate":
			out.Rate = float64(in.Float64())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoEmulation27(out *jwriter.Writer, in SetCPUThrottlingRateParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"rate\":"
		out.RawString(prefix[1:])
		out.Float64(float64(in.Rate))
	}
	out.RawByte('}')
}

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

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

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

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

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

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

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

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

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetAutoDarkModeOverrideParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoEmulation29(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoEmulation30(in *jlexer.Lexer, out *SensorReadingXYZ) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "x":
			out.X = float64(in.Float64())
		case "y":
			out.Y = float64(in.Float64())
		case "z":
			out.Z = float64(in.Float64())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoEmulation30(out *jwriter.Writer, in SensorReadingXYZ) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"x\":"
		out.RawString(prefix[1:])
		out.Float64(float64(in.X))
	}
	{
		const prefix string = ",\"y\":"
		out.RawString(prefix)
		out.Float64(float64(in.Y))
	}
	{
		const prefix string = ",\"z\":"
		out.RawString(prefix)
		out.Float64(float64(in.Z))
	}
	out.RawByte('}')
}

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

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

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

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

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SensorReadingSingle) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoEmulation31(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoEmulation32(in *jlexer.Lexer, out *SensorReadingQuaternion) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "x":
			out.X = float64(in.Float64())
		case "y":
			out.Y = float64(in.Float64())
		case "z":
			out.Z = float64(in.Float64())
		case "w":
			out.W = float64(in.Float64())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoEmulation32(out *jwriter.Writer, in SensorReadingQuaternion) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"x\":"
		out.RawString(prefix[1:])
		out.Float64(float64(in.X))
	}
	{
		const prefix string = ",\"y\":"
		out.RawString(prefix)
		out.Float64(float64(in.Y))
	}
	{
		const prefix string = ",\"z\":"
		out.RawString(prefix)
		out.Float64(float64(in.Z))
	}
	{
		const prefix string = ",\"w\":"
		out.RawString(prefix)
		out.Float64(float64(in.W))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SensorReadingQuaternion) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoEmulation32(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoEmulation33(in *jlexer.Lexer, out *SensorReading) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "single":
			if in.IsNull() {
				in.Skip()
				out.Single = nil
			} else {
				if out.Single == nil {
					out.Single = new(SensorReadingSingle)
				}
				(*out.Single).UnmarshalEasyJSON(in)
			}
		case "xyz":
			if in.IsNull() {
				in.Skip()
				out.Xyz = nil
			} else {
				if out.Xyz == nil {
					out.Xyz = new(SensorReadingXYZ)
				}
				(*out.Xyz).UnmarshalEasyJSON(in)
			}
		case "quaternion":
			if in.IsNull() {
				in.Skip()
				out.Quaternion = nil
			} else {
				if out.Quaternion == nil {
					out.Quaternion = new(SensorReadingQuaternion)
				}
				(*out.Quaternion).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoEmulation33(out *jwriter.Writer, in SensorReading) {
	out.RawByte('{')
	first := true
	_ = first
	if in.Single != nil {
		const prefix string = ",\"single\":"
		first = false
		out.RawString(prefix[1:])
		(*in.Single).MarshalEasyJSON(out)
	}
	if in.Xyz != nil {
		const prefix string = ",\"xyz\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.Xyz).MarshalEasyJSON(out)
	}
	if in.Quaternion != nil {
		const prefix string = ",\"quaternion\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.Quaternion).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SensorReading) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoEmulation33(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoEmulation34(in *jlexer.Lexer, out *SensorMetadata) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "available":
			out.Available = bool(in.Bool())
		case "minimumFrequency":
			out.MinimumFrequency = float64(in.Float64())
		case "maximumFrequency":
			out.MaximumFrequency = float64(in.Float64())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoEmulation34(out *jwriter.Writer, in SensorMetadata) {
	out.RawByte('{')
	first := true
	_ = first
	if in.Available {
		const prefix string = ",\"available\":"
		first = false
		out.RawString(prefix[1:])
		out.Bool(bool(in.Available))
	}
	if in.MinimumFrequency != 0 {
		const prefix string = ",\"minimumFrequency\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.Float64(float64(in.MinimumFrequency))
	}
	if in.MaximumFrequency != 0 {
		const prefix string = ",\"maximumFrequency\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.Float64(float64(in.MaximumFrequency))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SensorMetadata) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoEmulation34(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoEmulation35(in *jlexer.Lexer, out *ScreenOrientation) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "type":
			(out.Type).UnmarshalEasyJSON(in)
		case "angle":
			out.Angle = int64(in.Int64())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoEmulation35(out *jwriter.Writer, in ScreenOrientation) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"type\":"
		out.RawString(prefix[1:])
		(in.Type).MarshalEasyJSON(out)
	}
	{
		const prefix string = ",\"angle\":"
		out.RawString(prefix)
		out.Int64(int64(in.Angle))
	}
	out.RawByte('}')
}

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

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

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

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

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

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

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

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

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *PressureMetadata) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoEmulation37(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoEmulation38(in *jlexer.Lexer, out *MediaFeature) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "name":
			out.Name = string(in.String())
		case "value":
			out.Value = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoEmulation38(out *jwriter.Writer, in MediaFeature) {
	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 MediaFeature) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoEmulation38(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *MediaFeature) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoEmulation38(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoEmulation39(in *jlexer.Lexer, out *GetOverriddenSensorInformationReturns) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "requestedSamplingFrequency":
			out.RequestedSamplingFrequency = float64(in.Float64())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoEmulation39(out *jwriter.Writer, in GetOverriddenSensorInformationReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if in.RequestedSamplingFrequency != 0 {
		const prefix string = ",\"requestedSamplingFrequency\":"
		first = false
		out.RawString(prefix[1:])
		out.Float64(float64(in.RequestedSamplingFrequency))
	}
	out.RawByte('}')
}

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

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

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

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

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

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

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

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

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventVirtualTimeBudgetExpired) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoEmulation41(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoEmulation42(in *jlexer.Lexer, out *DisplayFeature) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "orientation":
			(out.Orientation).UnmarshalEasyJSON(in)
		case "offset":
			out.Offset = int64(in.Int64())
		case "maskLength":
			out.MaskLength = int64(in.Int64())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoEmulation42(out *jwriter.Writer, in DisplayFeature) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"orientation\":"
		out.RawString(prefix[1:])
		(in.Orientation).MarshalEasyJSON(out)
	}
	{
		const prefix string = ",\"offset\":"
		out.RawString(prefix)
		out.Int64(int64(in.Offset))
	}
	{
		const prefix string = ",\"maskLength\":"
		out.RawString(prefix)
		out.Int64(int64(in.MaskLength))
	}
	out.RawByte('}')
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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