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

package network

import (
	json "encoding/json"
	cdp "github.com/chromedp/cdproto/cdp"
	debugger "github.com/chromedp/cdproto/debugger"
	io "github.com/chromedp/cdproto/io"
	runtime "github.com/chromedp/cdproto/runtime"
	security "github.com/chromedp/cdproto/security"
	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 easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork(in *jlexer.Lexer, out *WebSocketResponse) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "status":
			out.Status = int64(in.Int64())
		case "statusText":
			out.StatusText = string(in.String())
		case "headers":
			if in.IsNull() {
				in.Skip()
			} else {
				in.Delim('{')
				if !in.IsDelim('}') {
					out.Headers = make(Headers)
				} else {
					out.Headers = nil
				}
				for !in.IsDelim('}') {
					key := string(in.String())
					in.WantColon()
					var v1 interface{}
					if m, ok := v1.(easyjson.Unmarshaler); ok {
						m.UnmarshalEasyJSON(in)
					} else if m, ok := v1.(json.Unmarshaler); ok {
						_ = m.UnmarshalJSON(in.Raw())
					} else {
						v1 = in.Interface()
					}
					(out.Headers)[key] = v1
					in.WantComma()
				}
				in.Delim('}')
			}
		case "headersText":
			out.HeadersText = string(in.String())
		case "requestHeaders":
			if in.IsNull() {
				in.Skip()
			} else {
				in.Delim('{')
				if !in.IsDelim('}') {
					out.RequestHeaders = make(Headers)
				} else {
					out.RequestHeaders = nil
				}
				for !in.IsDelim('}') {
					key := string(in.String())
					in.WantColon()
					var v2 interface{}
					if m, ok := v2.(easyjson.Unmarshaler); ok {
						m.UnmarshalEasyJSON(in)
					} else if m, ok := v2.(json.Unmarshaler); ok {
						_ = m.UnmarshalJSON(in.Raw())
					} else {
						v2 = in.Interface()
					}
					(out.RequestHeaders)[key] = v2
					in.WantComma()
				}
				in.Delim('}')
			}
		case "requestHeadersText":
			out.RequestHeadersText = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork(out *jwriter.Writer, in WebSocketResponse) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"status\":"
		out.RawString(prefix[1:])
		out.Int64(int64(in.Status))
	}
	{
		const prefix string = ",\"statusText\":"
		out.RawString(prefix)
		out.String(string(in.StatusText))
	}
	{
		const prefix string = ",\"headers\":"
		out.RawString(prefix)
		if in.Headers == nil && (out.Flags&jwriter.NilMapAsEmpty) == 0 {
			out.RawString(`null`)
		} else {
			out.RawByte('{')
			v3First := true
			for v3Name, v3Value := range in.Headers {
				if v3First {
					v3First = false
				} else {
					out.RawByte(',')
				}
				out.String(string(v3Name))
				out.RawByte(':')
				if m, ok := v3Value.(easyjson.Marshaler); ok {
					m.MarshalEasyJSON(out)
				} else if m, ok := v3Value.(json.Marshaler); ok {
					out.Raw(m.MarshalJSON())
				} else {
					out.Raw(json.Marshal(v3Value))
				}
			}
			out.RawByte('}')
		}
	}
	if in.HeadersText != "" {
		const prefix string = ",\"headersText\":"
		out.RawString(prefix)
		out.String(string(in.HeadersText))
	}
	if len(in.RequestHeaders) != 0 {
		const prefix string = ",\"requestHeaders\":"
		out.RawString(prefix)
		{
			out.RawByte('{')
			v4First := true
			for v4Name, v4Value := range in.RequestHeaders {
				if v4First {
					v4First = false
				} else {
					out.RawByte(',')
				}
				out.String(string(v4Name))
				out.RawByte(':')
				if m, ok := v4Value.(easyjson.Marshaler); ok {
					m.MarshalEasyJSON(out)
				} else if m, ok := v4Value.(json.Marshaler); ok {
					out.Raw(m.MarshalJSON())
				} else {
					out.Raw(json.Marshal(v4Value))
				}
			}
			out.RawByte('}')
		}
	}
	if in.RequestHeadersText != "" {
		const prefix string = ",\"requestHeadersText\":"
		out.RawString(prefix)
		out.String(string(in.RequestHeadersText))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *WebSocketResponse) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork1(in *jlexer.Lexer, out *WebSocketRequest) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "headers":
			if in.IsNull() {
				in.Skip()
			} else {
				in.Delim('{')
				if !in.IsDelim('}') {
					out.Headers = make(Headers)
				} else {
					out.Headers = nil
				}
				for !in.IsDelim('}') {
					key := string(in.String())
					in.WantColon()
					var v5 interface{}
					if m, ok := v5.(easyjson.Unmarshaler); ok {
						m.UnmarshalEasyJSON(in)
					} else if m, ok := v5.(json.Unmarshaler); ok {
						_ = m.UnmarshalJSON(in.Raw())
					} else {
						v5 = in.Interface()
					}
					(out.Headers)[key] = v5
					in.WantComma()
				}
				in.Delim('}')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork1(out *jwriter.Writer, in WebSocketRequest) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"headers\":"
		out.RawString(prefix[1:])
		if in.Headers == nil && (out.Flags&jwriter.NilMapAsEmpty) == 0 {
			out.RawString(`null`)
		} else {
			out.RawByte('{')
			v6First := true
			for v6Name, v6Value := range in.Headers {
				if v6First {
					v6First = false
				} else {
					out.RawByte(',')
				}
				out.String(string(v6Name))
				out.RawByte(':')
				if m, ok := v6Value.(easyjson.Marshaler); ok {
					m.MarshalEasyJSON(out)
				} else if m, ok := v6Value.(json.Marshaler); ok {
					out.Raw(m.MarshalJSON())
				} else {
					out.Raw(json.Marshal(v6Value))
				}
			}
			out.RawByte('}')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *WebSocketRequest) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork1(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork2(in *jlexer.Lexer, out *WebSocketFrame) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "opcode":
			out.Opcode = float64(in.Float64())
		case "mask":
			out.Mask = bool(in.Bool())
		case "payloadData":
			out.PayloadData = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork2(out *jwriter.Writer, in WebSocketFrame) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"opcode\":"
		out.RawString(prefix[1:])
		out.Float64(float64(in.Opcode))
	}
	{
		const prefix string = ",\"mask\":"
		out.RawString(prefix)
		out.Bool(bool(in.Mask))
	}
	{
		const prefix string = ",\"payloadData\":"
		out.RawString(prefix)
		out.String(string(in.PayloadData))
	}
	out.RawByte('}')
}

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

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

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

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

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *TakeResponseBodyForInterceptionAsStreamReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork3(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork4(in *jlexer.Lexer, out *TakeResponseBodyForInterceptionAsStreamParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "interceptionId":
			out.InterceptionID = InterceptionID(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork4(out *jwriter.Writer, in TakeResponseBodyForInterceptionAsStreamParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"interceptionId\":"
		out.RawString(prefix[1:])
		out.String(string(in.InterceptionID))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *TakeResponseBodyForInterceptionAsStreamParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork4(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork5(in *jlexer.Lexer, out *SignedExchangeSignature) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "label":
			out.Label = string(in.String())
		case "signature":
			out.Signature = string(in.String())
		case "integrity":
			out.Integrity = string(in.String())
		case "certUrl":
			out.CertURL = string(in.String())
		case "certSha256":
			out.CertSha256 = string(in.String())
		case "validityUrl":
			out.ValidityURL = string(in.String())
		case "date":
			out.Date = int64(in.Int64())
		case "expires":
			out.Expires = int64(in.Int64())
		case "certificates":
			if in.IsNull() {
				in.Skip()
				out.Certificates = nil
			} else {
				in.Delim('[')
				if out.Certificates == nil {
					if !in.IsDelim(']') {
						out.Certificates = make([]string, 0, 4)
					} else {
						out.Certificates = []string{}
					}
				} else {
					out.Certificates = (out.Certificates)[:0]
				}
				for !in.IsDelim(']') {
					var v7 string
					v7 = string(in.String())
					out.Certificates = append(out.Certificates, v7)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork5(out *jwriter.Writer, in SignedExchangeSignature) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"label\":"
		out.RawString(prefix[1:])
		out.String(string(in.Label))
	}
	{
		const prefix string = ",\"signature\":"
		out.RawString(prefix)
		out.String(string(in.Signature))
	}
	{
		const prefix string = ",\"integrity\":"
		out.RawString(prefix)
		out.String(string(in.Integrity))
	}
	if in.CertURL != "" {
		const prefix string = ",\"certUrl\":"
		out.RawString(prefix)
		out.String(string(in.CertURL))
	}
	if in.CertSha256 != "" {
		const prefix string = ",\"certSha256\":"
		out.RawString(prefix)
		out.String(string(in.CertSha256))
	}
	{
		const prefix string = ",\"validityUrl\":"
		out.RawString(prefix)
		out.String(string(in.ValidityURL))
	}
	{
		const prefix string = ",\"date\":"
		out.RawString(prefix)
		out.Int64(int64(in.Date))
	}
	{
		const prefix string = ",\"expires\":"
		out.RawString(prefix)
		out.Int64(int64(in.Expires))
	}
	if len(in.Certificates) != 0 {
		const prefix string = ",\"certificates\":"
		out.RawString(prefix)
		{
			out.RawByte('[')
			for v8, v9 := range in.Certificates {
				if v8 > 0 {
					out.RawByte(',')
				}
				out.String(string(v9))
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SignedExchangeSignature) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork5(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork6(in *jlexer.Lexer, out *SignedExchangeInfo) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "outerResponse":
			if in.IsNull() {
				in.Skip()
				out.OuterResponse = nil
			} else {
				if out.OuterResponse == nil {
					out.OuterResponse = new(Response)
				}
				(*out.OuterResponse).UnmarshalEasyJSON(in)
			}
		case "header":
			if in.IsNull() {
				in.Skip()
				out.Header = nil
			} else {
				if out.Header == nil {
					out.Header = new(SignedExchangeHeader)
				}
				(*out.Header).UnmarshalEasyJSON(in)
			}
		case "securityDetails":
			if in.IsNull() {
				in.Skip()
				out.SecurityDetails = nil
			} else {
				if out.SecurityDetails == nil {
					out.SecurityDetails = new(SecurityDetails)
				}
				(*out.SecurityDetails).UnmarshalEasyJSON(in)
			}
		case "errors":
			if in.IsNull() {
				in.Skip()
				out.Errors = nil
			} else {
				in.Delim('[')
				if out.Errors == nil {
					if !in.IsDelim(']') {
						out.Errors = make([]*SignedExchangeError, 0, 8)
					} else {
						out.Errors = []*SignedExchangeError{}
					}
				} else {
					out.Errors = (out.Errors)[:0]
				}
				for !in.IsDelim(']') {
					var v10 *SignedExchangeError
					if in.IsNull() {
						in.Skip()
						v10 = nil
					} else {
						if v10 == nil {
							v10 = new(SignedExchangeError)
						}
						(*v10).UnmarshalEasyJSON(in)
					}
					out.Errors = append(out.Errors, v10)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork6(out *jwriter.Writer, in SignedExchangeInfo) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"outerResponse\":"
		out.RawString(prefix[1:])
		if in.OuterResponse == nil {
			out.RawString("null")
		} else {
			(*in.OuterResponse).MarshalEasyJSON(out)
		}
	}
	if in.Header != nil {
		const prefix string = ",\"header\":"
		out.RawString(prefix)
		(*in.Header).MarshalEasyJSON(out)
	}
	if in.SecurityDetails != nil {
		const prefix string = ",\"securityDetails\":"
		out.RawString(prefix)
		(*in.SecurityDetails).MarshalEasyJSON(out)
	}
	if len(in.Errors) != 0 {
		const prefix string = ",\"errors\":"
		out.RawString(prefix)
		{
			out.RawByte('[')
			for v11, v12 := range in.Errors {
				if v11 > 0 {
					out.RawByte(',')
				}
				if v12 == nil {
					out.RawString("null")
				} else {
					(*v12).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SignedExchangeInfo) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork6(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork7(in *jlexer.Lexer, out *SignedExchangeHeader) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "requestUrl":
			out.RequestURL = string(in.String())
		case "responseCode":
			out.ResponseCode = int64(in.Int64())
		case "responseHeaders":
			if in.IsNull() {
				in.Skip()
			} else {
				in.Delim('{')
				if !in.IsDelim('}') {
					out.ResponseHeaders = make(Headers)
				} else {
					out.ResponseHeaders = nil
				}
				for !in.IsDelim('}') {
					key := string(in.String())
					in.WantColon()
					var v13 interface{}
					if m, ok := v13.(easyjson.Unmarshaler); ok {
						m.UnmarshalEasyJSON(in)
					} else if m, ok := v13.(json.Unmarshaler); ok {
						_ = m.UnmarshalJSON(in.Raw())
					} else {
						v13 = in.Interface()
					}
					(out.ResponseHeaders)[key] = v13
					in.WantComma()
				}
				in.Delim('}')
			}
		case "signatures":
			if in.IsNull() {
				in.Skip()
				out.Signatures = nil
			} else {
				in.Delim('[')
				if out.Signatures == nil {
					if !in.IsDelim(']') {
						out.Signatures = make([]*SignedExchangeSignature, 0, 8)
					} else {
						out.Signatures = []*SignedExchangeSignature{}
					}
				} else {
					out.Signatures = (out.Signatures)[:0]
				}
				for !in.IsDelim(']') {
					var v14 *SignedExchangeSignature
					if in.IsNull() {
						in.Skip()
						v14 = nil
					} else {
						if v14 == nil {
							v14 = new(SignedExchangeSignature)
						}
						(*v14).UnmarshalEasyJSON(in)
					}
					out.Signatures = append(out.Signatures, v14)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "headerIntegrity":
			out.HeaderIntegrity = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork7(out *jwriter.Writer, in SignedExchangeHeader) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"requestUrl\":"
		out.RawString(prefix[1:])
		out.String(string(in.RequestURL))
	}
	{
		const prefix string = ",\"responseCode\":"
		out.RawString(prefix)
		out.Int64(int64(in.ResponseCode))
	}
	{
		const prefix string = ",\"responseHeaders\":"
		out.RawString(prefix)
		if in.ResponseHeaders == nil && (out.Flags&jwriter.NilMapAsEmpty) == 0 {
			out.RawString(`null`)
		} else {
			out.RawByte('{')
			v15First := true
			for v15Name, v15Value := range in.ResponseHeaders {
				if v15First {
					v15First = false
				} else {
					out.RawByte(',')
				}
				out.String(string(v15Name))
				out.RawByte(':')
				if m, ok := v15Value.(easyjson.Marshaler); ok {
					m.MarshalEasyJSON(out)
				} else if m, ok := v15Value.(json.Marshaler); ok {
					out.Raw(m.MarshalJSON())
				} else {
					out.Raw(json.Marshal(v15Value))
				}
			}
			out.RawByte('}')
		}
	}
	{
		const prefix string = ",\"signatures\":"
		out.RawString(prefix)
		if in.Signatures == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v16, v17 := range in.Signatures {
				if v16 > 0 {
					out.RawByte(',')
				}
				if v17 == nil {
					out.RawString("null")
				} else {
					(*v17).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	{
		const prefix string = ",\"headerIntegrity\":"
		out.RawString(prefix)
		out.String(string(in.HeaderIntegrity))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SignedExchangeHeader) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork7(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork8(in *jlexer.Lexer, out *SignedExchangeError) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "message":
			out.Message = string(in.String())
		case "signatureIndex":
			out.SignatureIndex = int64(in.Int64())
		case "errorField":
			(out.ErrorField).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork8(out *jwriter.Writer, in SignedExchangeError) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"message\":"
		out.RawString(prefix[1:])
		out.String(string(in.Message))
	}
	if in.SignatureIndex != 0 {
		const prefix string = ",\"signatureIndex\":"
		out.RawString(prefix)
		out.Int64(int64(in.SignatureIndex))
	}
	if in.ErrorField != "" {
		const prefix string = ",\"errorField\":"
		out.RawString(prefix)
		(in.ErrorField).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SignedExchangeError) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork8(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork9(in *jlexer.Lexer, out *SignedCertificateTimestamp) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "status":
			out.Status = string(in.String())
		case "origin":
			out.Origin = string(in.String())
		case "logDescription":
			out.LogDescription = string(in.String())
		case "logId":
			out.LogID = string(in.String())
		case "timestamp":
			if in.IsNull() {
				in.Skip()
				out.Timestamp = nil
			} else {
				if out.Timestamp == nil {
					out.Timestamp = new(cdp.TimeSinceEpoch)
				}
				(*out.Timestamp).UnmarshalEasyJSON(in)
			}
		case "hashAlgorithm":
			out.HashAlgorithm = string(in.String())
		case "signatureAlgorithm":
			out.SignatureAlgorithm = string(in.String())
		case "signatureData":
			out.SignatureData = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork9(out *jwriter.Writer, in SignedCertificateTimestamp) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"status\":"
		out.RawString(prefix[1:])
		out.String(string(in.Status))
	}
	{
		const prefix string = ",\"origin\":"
		out.RawString(prefix)
		out.String(string(in.Origin))
	}
	{
		const prefix string = ",\"logDescription\":"
		out.RawString(prefix)
		out.String(string(in.LogDescription))
	}
	{
		const prefix string = ",\"logId\":"
		out.RawString(prefix)
		out.String(string(in.LogID))
	}
	{
		const prefix string = ",\"timestamp\":"
		out.RawString(prefix)
		if in.Timestamp == nil {
			out.RawString("null")
		} else {
			(*in.Timestamp).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"hashAlgorithm\":"
		out.RawString(prefix)
		out.String(string(in.HashAlgorithm))
	}
	{
		const prefix string = ",\"signatureAlgorithm\":"
		out.RawString(prefix)
		out.String(string(in.SignatureAlgorithm))
	}
	{
		const prefix string = ",\"signatureData\":"
		out.RawString(prefix)
		out.String(string(in.SignatureData))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SignedCertificateTimestamp) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork9(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork10(in *jlexer.Lexer, out *SetExtraHTTPHeadersParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "headers":
			if in.IsNull() {
				in.Skip()
			} else {
				in.Delim('{')
				if !in.IsDelim('}') {
					out.Headers = make(Headers)
				} else {
					out.Headers = nil
				}
				for !in.IsDelim('}') {
					key := string(in.String())
					in.WantColon()
					var v18 interface{}
					if m, ok := v18.(easyjson.Unmarshaler); ok {
						m.UnmarshalEasyJSON(in)
					} else if m, ok := v18.(json.Unmarshaler); ok {
						_ = m.UnmarshalJSON(in.Raw())
					} else {
						v18 = in.Interface()
					}
					(out.Headers)[key] = v18
					in.WantComma()
				}
				in.Delim('}')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork10(out *jwriter.Writer, in SetExtraHTTPHeadersParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"headers\":"
		out.RawString(prefix[1:])
		if in.Headers == nil && (out.Flags&jwriter.NilMapAsEmpty) == 0 {
			out.RawString(`null`)
		} else {
			out.RawByte('{')
			v19First := true
			for v19Name, v19Value := range in.Headers {
				if v19First {
					v19First = false
				} else {
					out.RawByte(',')
				}
				out.String(string(v19Name))
				out.RawByte(':')
				if m, ok := v19Value.(easyjson.Marshaler); ok {
					m.MarshalEasyJSON(out)
				} else if m, ok := v19Value.(json.Marshaler); ok {
					out.Raw(m.MarshalJSON())
				} else {
					out.Raw(json.Marshal(v19Value))
				}
			}
			out.RawByte('}')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetExtraHTTPHeadersParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork10(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork11(in *jlexer.Lexer, out *SetDataSizeLimitsForTestParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "maxTotalSize":
			out.MaxTotalSize = int64(in.Int64())
		case "maxResourceSize":
			out.MaxResourceSize = int64(in.Int64())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork11(out *jwriter.Writer, in SetDataSizeLimitsForTestParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"maxTotalSize\":"
		out.RawString(prefix[1:])
		out.Int64(int64(in.MaxTotalSize))
	}
	{
		const prefix string = ",\"maxResourceSize\":"
		out.RawString(prefix)
		out.Int64(int64(in.MaxResourceSize))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetDataSizeLimitsForTestParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork11(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork12(in *jlexer.Lexer, out *SetCookiesParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "cookies":
			if in.IsNull() {
				in.Skip()
				out.Cookies = nil
			} else {
				in.Delim('[')
				if out.Cookies == nil {
					if !in.IsDelim(']') {
						out.Cookies = make([]*CookieParam, 0, 8)
					} else {
						out.Cookies = []*CookieParam{}
					}
				} else {
					out.Cookies = (out.Cookies)[:0]
				}
				for !in.IsDelim(']') {
					var v20 *CookieParam
					if in.IsNull() {
						in.Skip()
						v20 = nil
					} else {
						if v20 == nil {
							v20 = new(CookieParam)
						}
						(*v20).UnmarshalEasyJSON(in)
					}
					out.Cookies = append(out.Cookies, v20)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork12(out *jwriter.Writer, in SetCookiesParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"cookies\":"
		out.RawString(prefix[1:])
		if in.Cookies == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v21, v22 := range in.Cookies {
				if v21 > 0 {
					out.RawByte(',')
				}
				if v22 == nil {
					out.RawString("null")
				} else {
					(*v22).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetCookiesParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork12(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork13(in *jlexer.Lexer, out *SetCookieReturns) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "success":
			out.Success = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork13(out *jwriter.Writer, in SetCookieReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if in.Success {
		const prefix string = ",\"success\":"
		first = false
		out.RawString(prefix[1:])
		out.Bool(bool(in.Success))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetCookieReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork13(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork14(in *jlexer.Lexer, out *SetCookieParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "name":
			out.Name = string(in.String())
		case "value":
			out.Value = string(in.String())
		case "url":
			out.URL = string(in.String())
		case "domain":
			out.Domain = string(in.String())
		case "path":
			out.Path = string(in.String())
		case "secure":
			out.Secure = bool(in.Bool())
		case "httpOnly":
			out.HTTPOnly = bool(in.Bool())
		case "sameSite":
			(out.SameSite).UnmarshalEasyJSON(in)
		case "expires":
			if in.IsNull() {
				in.Skip()
				out.Expires = nil
			} else {
				if out.Expires == nil {
					out.Expires = new(cdp.TimeSinceEpoch)
				}
				(*out.Expires).UnmarshalEasyJSON(in)
			}
		case "priority":
			(out.Priority).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork14(out *jwriter.Writer, in SetCookieParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"name\":"
		out.RawString(prefix[1:])
		out.String(string(in.Name))
	}
	{
		const prefix string = ",\"value\":"
		out.RawString(prefix)
		out.String(string(in.Value))
	}
	if in.URL != "" {
		const prefix string = ",\"url\":"
		out.RawString(prefix)
		out.String(string(in.URL))
	}
	if in.Domain != "" {
		const prefix string = ",\"domain\":"
		out.RawString(prefix)
		out.String(string(in.Domain))
	}
	if in.Path != "" {
		const prefix string = ",\"path\":"
		out.RawString(prefix)
		out.String(string(in.Path))
	}
	if in.Secure {
		const prefix string = ",\"secure\":"
		out.RawString(prefix)
		out.Bool(bool(in.Secure))
	}
	if in.HTTPOnly {
		const prefix string = ",\"httpOnly\":"
		out.RawString(prefix)
		out.Bool(bool(in.HTTPOnly))
	}
	if in.SameSite != "" {
		const prefix string = ",\"sameSite\":"
		out.RawString(prefix)
		(in.SameSite).MarshalEasyJSON(out)
	}
	if in.Expires != nil {
		const prefix string = ",\"expires\":"
		out.RawString(prefix)
		(*in.Expires).MarshalEasyJSON(out)
	}
	if in.Priority != "" {
		const prefix string = ",\"priority\":"
		out.RawString(prefix)
		(in.Priority).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetCookieParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork14(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork15(in *jlexer.Lexer, out *SetCacheDisabledParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "cacheDisabled":
			out.CacheDisabled = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork15(out *jwriter.Writer, in SetCacheDisabledParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"cacheDisabled\":"
		out.RawString(prefix[1:])
		out.Bool(bool(in.CacheDisabled))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetCacheDisabledParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork15(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork16(in *jlexer.Lexer, out *SetBypassServiceWorkerParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "bypass":
			out.Bypass = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork16(out *jwriter.Writer, in SetBypassServiceWorkerParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"bypass\":"
		out.RawString(prefix[1:])
		out.Bool(bool(in.Bypass))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetBypassServiceWorkerParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork16(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork17(in *jlexer.Lexer, out *SetBlockedURLSParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "urls":
			if in.IsNull() {
				in.Skip()
				out.Urls = nil
			} else {
				in.Delim('[')
				if out.Urls == nil {
					if !in.IsDelim(']') {
						out.Urls = make([]string, 0, 4)
					} else {
						out.Urls = []string{}
					}
				} else {
					out.Urls = (out.Urls)[:0]
				}
				for !in.IsDelim(']') {
					var v23 string
					v23 = string(in.String())
					out.Urls = append(out.Urls, v23)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork17(out *jwriter.Writer, in SetBlockedURLSParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"urls\":"
		out.RawString(prefix[1:])
		if in.Urls == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v24, v25 := range in.Urls {
				if v24 > 0 {
					out.RawByte(',')
				}
				out.String(string(v25))
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetBlockedURLSParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork17(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork18(in *jlexer.Lexer, out *SecurityDetails) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "protocol":
			out.Protocol = string(in.String())
		case "keyExchange":
			out.KeyExchange = string(in.String())
		case "keyExchangeGroup":
			out.KeyExchangeGroup = string(in.String())
		case "cipher":
			out.Cipher = string(in.String())
		case "mac":
			out.Mac = string(in.String())
		case "certificateId":
			out.CertificateID = security.CertificateID(in.Int64())
		case "subjectName":
			out.SubjectName = string(in.String())
		case "sanList":
			if in.IsNull() {
				in.Skip()
				out.SanList = nil
			} else {
				in.Delim('[')
				if out.SanList == nil {
					if !in.IsDelim(']') {
						out.SanList = make([]string, 0, 4)
					} else {
						out.SanList = []string{}
					}
				} else {
					out.SanList = (out.SanList)[:0]
				}
				for !in.IsDelim(']') {
					var v26 string
					v26 = string(in.String())
					out.SanList = append(out.SanList, v26)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "issuer":
			out.Issuer = string(in.String())
		case "validFrom":
			if in.IsNull() {
				in.Skip()
				out.ValidFrom = nil
			} else {
				if out.ValidFrom == nil {
					out.ValidFrom = new(cdp.TimeSinceEpoch)
				}
				(*out.ValidFrom).UnmarshalEasyJSON(in)
			}
		case "validTo":
			if in.IsNull() {
				in.Skip()
				out.ValidTo = nil
			} else {
				if out.ValidTo == nil {
					out.ValidTo = new(cdp.TimeSinceEpoch)
				}
				(*out.ValidTo).UnmarshalEasyJSON(in)
			}
		case "signedCertificateTimestampList":
			if in.IsNull() {
				in.Skip()
				out.SignedCertificateTimestampList = nil
			} else {
				in.Delim('[')
				if out.SignedCertificateTimestampList == nil {
					if !in.IsDelim(']') {
						out.SignedCertificateTimestampList = make([]*SignedCertificateTimestamp, 0, 8)
					} else {
						out.SignedCertificateTimestampList = []*SignedCertificateTimestamp{}
					}
				} else {
					out.SignedCertificateTimestampList = (out.SignedCertificateTimestampList)[:0]
				}
				for !in.IsDelim(']') {
					var v27 *SignedCertificateTimestamp
					if in.IsNull() {
						in.Skip()
						v27 = nil
					} else {
						if v27 == nil {
							v27 = new(SignedCertificateTimestamp)
						}
						(*v27).UnmarshalEasyJSON(in)
					}
					out.SignedCertificateTimestampList = append(out.SignedCertificateTimestampList, v27)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "certificateTransparencyCompliance":
			(out.CertificateTransparencyCompliance).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork18(out *jwriter.Writer, in SecurityDetails) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"protocol\":"
		out.RawString(prefix[1:])
		out.String(string(in.Protocol))
	}
	{
		const prefix string = ",\"keyExchange\":"
		out.RawString(prefix)
		out.String(string(in.KeyExchange))
	}
	if in.KeyExchangeGroup != "" {
		const prefix string = ",\"keyExchangeGroup\":"
		out.RawString(prefix)
		out.String(string(in.KeyExchangeGroup))
	}
	{
		const prefix string = ",\"cipher\":"
		out.RawString(prefix)
		out.String(string(in.Cipher))
	}
	if in.Mac != "" {
		const prefix string = ",\"mac\":"
		out.RawString(prefix)
		out.String(string(in.Mac))
	}
	{
		const prefix string = ",\"certificateId\":"
		out.RawString(prefix)
		out.Int64(int64(in.CertificateID))
	}
	{
		const prefix string = ",\"subjectName\":"
		out.RawString(prefix)
		out.String(string(in.SubjectName))
	}
	{
		const prefix string = ",\"sanList\":"
		out.RawString(prefix)
		if in.SanList == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v28, v29 := range in.SanList {
				if v28 > 0 {
					out.RawByte(',')
				}
				out.String(string(v29))
			}
			out.RawByte(']')
		}
	}
	{
		const prefix string = ",\"issuer\":"
		out.RawString(prefix)
		out.String(string(in.Issuer))
	}
	{
		const prefix string = ",\"validFrom\":"
		out.RawString(prefix)
		if in.ValidFrom == nil {
			out.RawString("null")
		} else {
			(*in.ValidFrom).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"validTo\":"
		out.RawString(prefix)
		if in.ValidTo == nil {
			out.RawString("null")
		} else {
			(*in.ValidTo).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"signedCertificateTimestampList\":"
		out.RawString(prefix)
		if in.SignedCertificateTimestampList == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v30, v31 := range in.SignedCertificateTimestampList {
				if v30 > 0 {
					out.RawByte(',')
				}
				if v31 == nil {
					out.RawString("null")
				} else {
					(*v31).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	{
		const prefix string = ",\"certificateTransparencyCompliance\":"
		out.RawString(prefix)
		(in.CertificateTransparencyCompliance).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

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

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SearchInResponseBodyReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork19(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork20(in *jlexer.Lexer, out *SearchInResponseBodyParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "requestId":
			out.RequestID = RequestID(in.String())
		case "query":
			out.Query = string(in.String())
		case "caseSensitive":
			out.CaseSensitive = bool(in.Bool())
		case "isRegex":
			out.IsRegex = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork20(out *jwriter.Writer, in SearchInResponseBodyParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"requestId\":"
		out.RawString(prefix[1:])
		out.String(string(in.RequestID))
	}
	{
		const prefix string = ",\"query\":"
		out.RawString(prefix)
		out.String(string(in.Query))
	}
	if in.CaseSensitive {
		const prefix string = ",\"caseSensitive\":"
		out.RawString(prefix)
		out.Bool(bool(in.CaseSensitive))
	}
	if in.IsRegex {
		const prefix string = ",\"isRegex\":"
		out.RawString(prefix)
		out.Bool(bool(in.IsRegex))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SearchInResponseBodyParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork20(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork21(in *jlexer.Lexer, out *Response) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "url":
			out.URL = string(in.String())
		case "status":
			out.Status = int64(in.Int64())
		case "statusText":
			out.StatusText = string(in.String())
		case "headers":
			if in.IsNull() {
				in.Skip()
			} else {
				in.Delim('{')
				if !in.IsDelim('}') {
					out.Headers = make(Headers)
				} else {
					out.Headers = nil
				}
				for !in.IsDelim('}') {
					key := string(in.String())
					in.WantColon()
					var v35 interface{}
					if m, ok := v35.(easyjson.Unmarshaler); ok {
						m.UnmarshalEasyJSON(in)
					} else if m, ok := v35.(json.Unmarshaler); ok {
						_ = m.UnmarshalJSON(in.Raw())
					} else {
						v35 = in.Interface()
					}
					(out.Headers)[key] = v35
					in.WantComma()
				}
				in.Delim('}')
			}
		case "headersText":
			out.HeadersText = string(in.String())
		case "mimeType":
			out.MimeType = string(in.String())
		case "requestHeaders":
			if in.IsNull() {
				in.Skip()
			} else {
				in.Delim('{')
				if !in.IsDelim('}') {
					out.RequestHeaders = make(Headers)
				} else {
					out.RequestHeaders = nil
				}
				for !in.IsDelim('}') {
					key := string(in.String())
					in.WantColon()
					var v36 interface{}
					if m, ok := v36.(easyjson.Unmarshaler); ok {
						m.UnmarshalEasyJSON(in)
					} else if m, ok := v36.(json.Unmarshaler); ok {
						_ = m.UnmarshalJSON(in.Raw())
					} else {
						v36 = in.Interface()
					}
					(out.RequestHeaders)[key] = v36
					in.WantComma()
				}
				in.Delim('}')
			}
		case "requestHeadersText":
			out.RequestHeadersText = string(in.String())
		case "connectionReused":
			out.ConnectionReused = bool(in.Bool())
		case "connectionId":
			out.ConnectionID = float64(in.Float64())
		case "remoteIPAddress":
			out.RemoteIPAddress = string(in.String())
		case "remotePort":
			out.RemotePort = int64(in.Int64())
		case "fromDiskCache":
			out.FromDiskCache = bool(in.Bool())
		case "fromServiceWorker":
			out.FromServiceWorker = bool(in.Bool())
		case "fromPrefetchCache":
			out.FromPrefetchCache = bool(in.Bool())
		case "encodedDataLength":
			out.EncodedDataLength = float64(in.Float64())
		case "timing":
			if in.IsNull() {
				in.Skip()
				out.Timing = nil
			} else {
				if out.Timing == nil {
					out.Timing = new(ResourceTiming)
				}
				(*out.Timing).UnmarshalEasyJSON(in)
			}
		case "serviceWorkerResponseSource":
			(out.ServiceWorkerResponseSource).UnmarshalEasyJSON(in)
		case "responseTime":
			if in.IsNull() {
				in.Skip()
				out.ResponseTime = nil
			} else {
				if out.ResponseTime == nil {
					out.ResponseTime = new(cdp.TimeSinceEpoch)
				}
				(*out.ResponseTime).UnmarshalEasyJSON(in)
			}
		case "cacheStorageCacheName":
			out.CacheStorageCacheName = string(in.String())
		case "protocol":
			out.Protocol = string(in.String())
		case "securityState":
			(out.SecurityState).UnmarshalEasyJSON(in)
		case "securityDetails":
			if in.IsNull() {
				in.Skip()
				out.SecurityDetails = nil
			} else {
				if out.SecurityDetails == nil {
					out.SecurityDetails = new(SecurityDetails)
				}
				(*out.SecurityDetails).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork21(out *jwriter.Writer, in Response) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"url\":"
		out.RawString(prefix[1:])
		out.String(string(in.URL))
	}
	{
		const prefix string = ",\"status\":"
		out.RawString(prefix)
		out.Int64(int64(in.Status))
	}
	{
		const prefix string = ",\"statusText\":"
		out.RawString(prefix)
		out.String(string(in.StatusText))
	}
	{
		const prefix string = ",\"headers\":"
		out.RawString(prefix)
		if in.Headers == nil && (out.Flags&jwriter.NilMapAsEmpty) == 0 {
			out.RawString(`null`)
		} else {
			out.RawByte('{')
			v37First := true
			for v37Name, v37Value := range in.Headers {
				if v37First {
					v37First = false
				} else {
					out.RawByte(',')
				}
				out.String(string(v37Name))
				out.RawByte(':')
				if m, ok := v37Value.(easyjson.Marshaler); ok {
					m.MarshalEasyJSON(out)
				} else if m, ok := v37Value.(json.Marshaler); ok {
					out.Raw(m.MarshalJSON())
				} else {
					out.Raw(json.Marshal(v37Value))
				}
			}
			out.RawByte('}')
		}
	}
	if in.HeadersText != "" {
		const prefix string = ",\"headersText\":"
		out.RawString(prefix)
		out.String(string(in.HeadersText))
	}
	{
		const prefix string = ",\"mimeType\":"
		out.RawString(prefix)
		out.String(string(in.MimeType))
	}
	if len(in.RequestHeaders) != 0 {
		const prefix string = ",\"requestHeaders\":"
		out.RawString(prefix)
		{
			out.RawByte('{')
			v38First := true
			for v38Name, v38Value := range in.RequestHeaders {
				if v38First {
					v38First = false
				} else {
					out.RawByte(',')
				}
				out.String(string(v38Name))
				out.RawByte(':')
				if m, ok := v38Value.(easyjson.Marshaler); ok {
					m.MarshalEasyJSON(out)
				} else if m, ok := v38Value.(json.Marshaler); ok {
					out.Raw(m.MarshalJSON())
				} else {
					out.Raw(json.Marshal(v38Value))
				}
			}
			out.RawByte('}')
		}
	}
	if in.RequestHeadersText != "" {
		const prefix string = ",\"requestHeadersText\":"
		out.RawString(prefix)
		out.String(string(in.RequestHeadersText))
	}
	{
		const prefix string = ",\"connectionReused\":"
		out.RawString(prefix)
		out.Bool(bool(in.ConnectionReused))
	}
	{
		const prefix string = ",\"connectionId\":"
		out.RawString(prefix)
		out.Float64(float64(in.ConnectionID))
	}
	if in.RemoteIPAddress != "" {
		const prefix string = ",\"remoteIPAddress\":"
		out.RawString(prefix)
		out.String(string(in.RemoteIPAddress))
	}
	if in.RemotePort != 0 {
		const prefix string = ",\"remotePort\":"
		out.RawString(prefix)
		out.Int64(int64(in.RemotePort))
	}
	if in.FromDiskCache {
		const prefix string = ",\"fromDiskCache\":"
		out.RawString(prefix)
		out.Bool(bool(in.FromDiskCache))
	}
	if in.FromServiceWorker {
		const prefix string = ",\"fromServiceWorker\":"
		out.RawString(prefix)
		out.Bool(bool(in.FromServiceWorker))
	}
	if in.FromPrefetchCache {
		const prefix string = ",\"fromPrefetchCache\":"
		out.RawString(prefix)
		out.Bool(bool(in.FromPrefetchCache))
	}
	{
		const prefix string = ",\"encodedDataLength\":"
		out.RawString(prefix)
		out.Float64(float64(in.EncodedDataLength))
	}
	if in.Timing != nil {
		const prefix string = ",\"timing\":"
		out.RawString(prefix)
		(*in.Timing).MarshalEasyJSON(out)
	}
	if in.ServiceWorkerResponseSource != "" {
		const prefix string = ",\"serviceWorkerResponseSource\":"
		out.RawString(prefix)
		(in.ServiceWorkerResponseSource).MarshalEasyJSON(out)
	}
	if in.ResponseTime != nil {
		const prefix string = ",\"responseTime\":"
		out.RawString(prefix)
		(*in.ResponseTime).MarshalEasyJSON(out)
	}
	if in.CacheStorageCacheName != "" {
		const prefix string = ",\"cacheStorageCacheName\":"
		out.RawString(prefix)
		out.String(string(in.CacheStorageCacheName))
	}
	if in.Protocol != "" {
		const prefix string = ",\"protocol\":"
		out.RawString(prefix)
		out.String(string(in.Protocol))
	}
	{
		const prefix string = ",\"securityState\":"
		out.RawString(prefix)
		(in.SecurityState).MarshalEasyJSON(out)
	}
	if in.SecurityDetails != nil {
		const prefix string = ",\"securityDetails\":"
		out.RawString(prefix)
		(*in.SecurityDetails).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *Response) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork21(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork22(in *jlexer.Lexer, out *ResourceTiming) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "requestTime":
			out.RequestTime = float64(in.Float64())
		case "proxyStart":
			out.ProxyStart = float64(in.Float64())
		case "proxyEnd":
			out.ProxyEnd = float64(in.Float64())
		case "dnsStart":
			out.DNSStart = float64(in.Float64())
		case "dnsEnd":
			out.DNSEnd = float64(in.Float64())
		case "connectStart":
			out.ConnectStart = float64(in.Float64())
		case "connectEnd":
			out.ConnectEnd = float64(in.Float64())
		case "sslStart":
			out.SslStart = float64(in.Float64())
		case "sslEnd":
			out.SslEnd = float64(in.Float64())
		case "workerStart":
			out.WorkerStart = float64(in.Float64())
		case "workerReady":
			out.WorkerReady = float64(in.Float64())
		case "workerFetchStart":
			out.WorkerFetchStart = float64(in.Float64())
		case "workerRespondWithSettled":
			out.WorkerRespondWithSettled = float64(in.Float64())
		case "sendStart":
			out.SendStart = float64(in.Float64())
		case "sendEnd":
			out.SendEnd = float64(in.Float64())
		case "pushStart":
			out.PushStart = float64(in.Float64())
		case "pushEnd":
			out.PushEnd = float64(in.Float64())
		case "receiveHeadersEnd":
			out.ReceiveHeadersEnd = float64(in.Float64())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork22(out *jwriter.Writer, in ResourceTiming) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"requestTime\":"
		out.RawString(prefix[1:])
		out.Float64(float64(in.RequestTime))
	}
	{
		const prefix string = ",\"proxyStart\":"
		out.RawString(prefix)
		out.Float64(float64(in.ProxyStart))
	}
	{
		const prefix string = ",\"proxyEnd\":"
		out.RawString(prefix)
		out.Float64(float64(in.ProxyEnd))
	}
	{
		const prefix string = ",\"dnsStart\":"
		out.RawString(prefix)
		out.Float64(float64(in.DNSStart))
	}
	{
		const prefix string = ",\"dnsEnd\":"
		out.RawString(prefix)
		out.Float64(float64(in.DNSEnd))
	}
	{
		const prefix string = ",\"connectStart\":"
		out.RawString(prefix)
		out.Float64(float64(in.ConnectStart))
	}
	{
		const prefix string = ",\"connectEnd\":"
		out.RawString(prefix)
		out.Float64(float64(in.ConnectEnd))
	}
	{
		const prefix string = ",\"sslStart\":"
		out.RawString(prefix)
		out.Float64(float64(in.SslStart))
	}
	{
		const prefix string = ",\"sslEnd\":"
		out.RawString(prefix)
		out.Float64(float64(in.SslEnd))
	}
	{
		const prefix string = ",\"workerStart\":"
		out.RawString(prefix)
		out.Float64(float64(in.WorkerStart))
	}
	{
		const prefix string = ",\"workerReady\":"
		out.RawString(prefix)
		out.Float64(float64(in.WorkerReady))
	}
	{
		const prefix string = ",\"workerFetchStart\":"
		out.RawString(prefix)
		out.Float64(float64(in.WorkerFetchStart))
	}
	{
		const prefix string = ",\"workerRespondWithSettled\":"
		out.RawString(prefix)
		out.Float64(float64(in.WorkerRespondWithSettled))
	}
	{
		const prefix string = ",\"sendStart\":"
		out.RawString(prefix)
		out.Float64(float64(in.SendStart))
	}
	{
		const prefix string = ",\"sendEnd\":"
		out.RawString(prefix)
		out.Float64(float64(in.SendEnd))
	}
	{
		const prefix string = ",\"pushStart\":"
		out.RawString(prefix)
		out.Float64(float64(in.PushStart))
	}
	{
		const prefix string = ",\"pushEnd\":"
		out.RawString(prefix)
		out.Float64(float64(in.PushEnd))
	}
	{
		const prefix string = ",\"receiveHeadersEnd\":"
		out.RawString(prefix)
		out.Float64(float64(in.ReceiveHeadersEnd))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *ResourceTiming) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork22(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork23(in *jlexer.Lexer, out *RequestPattern) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "urlPattern":
			out.URLPattern = string(in.String())
		case "resourceType":
			(out.ResourceType).UnmarshalEasyJSON(in)
		case "interceptionStage":
			(out.InterceptionStage).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork23(out *jwriter.Writer, in RequestPattern) {
	out.RawByte('{')
	first := true
	_ = first
	if in.URLPattern != "" {
		const prefix string = ",\"urlPattern\":"
		first = false
		out.RawString(prefix[1:])
		out.String(string(in.URLPattern))
	}
	if in.ResourceType != "" {
		const prefix string = ",\"resourceType\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(in.ResourceType).MarshalEasyJSON(out)
	}
	if in.InterceptionStage != "" {
		const prefix string = ",\"interceptionStage\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(in.InterceptionStage).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *RequestPattern) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork23(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork24(in *jlexer.Lexer, out *Request) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "url":
			out.URL = string(in.String())
		case "urlFragment":
			out.URLFragment = string(in.String())
		case "method":
			out.Method = string(in.String())
		case "headers":
			if in.IsNull() {
				in.Skip()
			} else {
				in.Delim('{')
				if !in.IsDelim('}') {
					out.Headers = make(Headers)
				} else {
					out.Headers = nil
				}
				for !in.IsDelim('}') {
					key := string(in.String())
					in.WantColon()
					var v39 interface{}
					if m, ok := v39.(easyjson.Unmarshaler); ok {
						m.UnmarshalEasyJSON(in)
					} else if m, ok := v39.(json.Unmarshaler); ok {
						_ = m.UnmarshalJSON(in.Raw())
					} else {
						v39 = in.Interface()
					}
					(out.Headers)[key] = v39
					in.WantComma()
				}
				in.Delim('}')
			}
		case "postData":
			out.PostData = string(in.String())
		case "hasPostData":
			out.HasPostData = bool(in.Bool())
		case "mixedContentType":
			(out.MixedContentType).UnmarshalEasyJSON(in)
		case "initialPriority":
			(out.InitialPriority).UnmarshalEasyJSON(in)
		case "referrerPolicy":
			(out.ReferrerPolicy).UnmarshalEasyJSON(in)
		case "isLinkPreload":
			out.IsLinkPreload = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork24(out *jwriter.Writer, in Request) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"url\":"
		out.RawString(prefix[1:])
		out.String(string(in.URL))
	}
	if in.URLFragment != "" {
		const prefix string = ",\"urlFragment\":"
		out.RawString(prefix)
		out.String(string(in.URLFragment))
	}
	{
		const prefix string = ",\"method\":"
		out.RawString(prefix)
		out.String(string(in.Method))
	}
	{
		const prefix string = ",\"headers\":"
		out.RawString(prefix)
		if in.Headers == nil && (out.Flags&jwriter.NilMapAsEmpty) == 0 {
			out.RawString(`null`)
		} else {
			out.RawByte('{')
			v40First := true
			for v40Name, v40Value := range in.Headers {
				if v40First {
					v40First = false
				} else {
					out.RawByte(',')
				}
				out.String(string(v40Name))
				out.RawByte(':')
				if m, ok := v40Value.(easyjson.Marshaler); ok {
					m.MarshalEasyJSON(out)
				} else if m, ok := v40Value.(json.Marshaler); ok {
					out.Raw(m.MarshalJSON())
				} else {
					out.Raw(json.Marshal(v40Value))
				}
			}
			out.RawByte('}')
		}
	}
	if in.PostData != "" {
		const prefix string = ",\"postData\":"
		out.RawString(prefix)
		out.String(string(in.PostData))
	}
	if in.HasPostData {
		const prefix string = ",\"hasPostData\":"
		out.RawString(prefix)
		out.Bool(bool(in.HasPostData))
	}
	if in.MixedContentType != "" {
		const prefix string = ",\"mixedContentType\":"
		out.RawString(prefix)
		(in.MixedContentType).MarshalEasyJSON(out)
	}
	{
		const prefix string = ",\"initialPriority\":"
		out.RawString(prefix)
		(in.InitialPriority).MarshalEasyJSON(out)
	}
	{
		const prefix string = ",\"referrerPolicy\":"
		out.RawString(prefix)
		(in.ReferrerPolicy).MarshalEasyJSON(out)
	}
	if in.IsLinkPreload {
		const prefix string = ",\"isLinkPreload\":"
		out.RawString(prefix)
		out.Bool(bool(in.IsLinkPreload))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *Request) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork24(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork25(in *jlexer.Lexer, out *ReplayXHRParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "requestId":
			out.RequestID = RequestID(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork25(out *jwriter.Writer, in ReplayXHRParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"requestId\":"
		out.RawString(prefix[1:])
		out.String(string(in.RequestID))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *ReplayXHRParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork25(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork26(in *jlexer.Lexer, out *Initiator) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "type":
			(out.Type).UnmarshalEasyJSON(in)
		case "stack":
			if in.IsNull() {
				in.Skip()
				out.Stack = nil
			} else {
				if out.Stack == nil {
					out.Stack = new(runtime.StackTrace)
				}
				(*out.Stack).UnmarshalEasyJSON(in)
			}
		case "url":
			out.URL = string(in.String())
		case "lineNumber":
			out.LineNumber = float64(in.Float64())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork26(out *jwriter.Writer, in Initiator) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"type\":"
		out.RawString(prefix[1:])
		(in.Type).MarshalEasyJSON(out)
	}
	if in.Stack != nil {
		const prefix string = ",\"stack\":"
		out.RawString(prefix)
		(*in.Stack).MarshalEasyJSON(out)
	}
	if in.URL != "" {
		const prefix string = ",\"url\":"
		out.RawString(prefix)
		out.String(string(in.URL))
	}
	if in.LineNumber != 0 {
		const prefix string = ",\"lineNumber\":"
		out.RawString(prefix)
		out.Float64(float64(in.LineNumber))
	}
	out.RawByte('}')
}

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

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

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

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

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetResponseBodyReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork27(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork28(in *jlexer.Lexer, out *GetResponseBodyParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "requestId":
			out.RequestID = RequestID(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork28(out *jwriter.Writer, in GetResponseBodyParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"requestId\":"
		out.RawString(prefix[1:])
		out.String(string(in.RequestID))
	}
	out.RawByte('}')
}

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

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

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

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

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetResponseBodyForInterceptionReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork29(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork30(in *jlexer.Lexer, out *GetResponseBodyForInterceptionParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "interceptionId":
			out.InterceptionID = InterceptionID(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork30(out *jwriter.Writer, in GetResponseBodyForInterceptionParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"interceptionId\":"
		out.RawString(prefix[1:])
		out.String(string(in.InterceptionID))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetResponseBodyForInterceptionParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork30(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork31(in *jlexer.Lexer, out *GetRequestPostDataReturns) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "postData":
			out.PostData = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork31(out *jwriter.Writer, in GetRequestPostDataReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if in.PostData != "" {
		const prefix string = ",\"postData\":"
		first = false
		out.RawString(prefix[1:])
		out.String(string(in.PostData))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetRequestPostDataReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork31(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork32(in *jlexer.Lexer, out *GetRequestPostDataParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "requestId":
			out.RequestID = RequestID(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork32(out *jwriter.Writer, in GetRequestPostDataParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"requestId\":"
		out.RawString(prefix[1:])
		out.String(string(in.RequestID))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetRequestPostDataParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork32(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork33(in *jlexer.Lexer, out *GetCookiesReturns) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "cookies":
			if in.IsNull() {
				in.Skip()
				out.Cookies = nil
			} else {
				in.Delim('[')
				if out.Cookies == nil {
					if !in.IsDelim(']') {
						out.Cookies = make([]*Cookie, 0, 8)
					} else {
						out.Cookies = []*Cookie{}
					}
				} else {
					out.Cookies = (out.Cookies)[:0]
				}
				for !in.IsDelim(']') {
					var v41 *Cookie
					if in.IsNull() {
						in.Skip()
						v41 = nil
					} else {
						if v41 == nil {
							v41 = new(Cookie)
						}
						(*v41).UnmarshalEasyJSON(in)
					}
					out.Cookies = append(out.Cookies, v41)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork33(out *jwriter.Writer, in GetCookiesReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if len(in.Cookies) != 0 {
		const prefix string = ",\"cookies\":"
		first = false
		out.RawString(prefix[1:])
		{
			out.RawByte('[')
			for v42, v43 := range in.Cookies {
				if v42 > 0 {
					out.RawByte(',')
				}
				if v43 == nil {
					out.RawString("null")
				} else {
					(*v43).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetCookiesReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork33(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork34(in *jlexer.Lexer, out *GetCookiesParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "urls":
			if in.IsNull() {
				in.Skip()
				out.Urls = nil
			} else {
				in.Delim('[')
				if out.Urls == nil {
					if !in.IsDelim(']') {
						out.Urls = make([]string, 0, 4)
					} else {
						out.Urls = []string{}
					}
				} else {
					out.Urls = (out.Urls)[:0]
				}
				for !in.IsDelim(']') {
					var v44 string
					v44 = string(in.String())
					out.Urls = append(out.Urls, v44)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork34(out *jwriter.Writer, in GetCookiesParams) {
	out.RawByte('{')
	first := true
	_ = first
	if len(in.Urls) != 0 {
		const prefix string = ",\"urls\":"
		first = false
		out.RawString(prefix[1:])
		{
			out.RawByte('[')
			for v45, v46 := range in.Urls {
				if v45 > 0 {
					out.RawByte(',')
				}
				out.String(string(v46))
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetCookiesParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork34(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork35(in *jlexer.Lexer, out *GetCertificateReturns) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "tableNames":
			if in.IsNull() {
				in.Skip()
				out.TableNames = nil
			} else {
				in.Delim('[')
				if out.TableNames == nil {
					if !in.IsDelim(']') {
						out.TableNames = make([]string, 0, 4)
					} else {
						out.TableNames = []string{}
					}
				} else {
					out.TableNames = (out.TableNames)[:0]
				}
				for !in.IsDelim(']') {
					var v47 string
					v47 = string(in.String())
					out.TableNames = append(out.TableNames, v47)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork35(out *jwriter.Writer, in GetCertificateReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if len(in.TableNames) != 0 {
		const prefix string = ",\"tableNames\":"
		first = false
		out.RawString(prefix[1:])
		{
			out.RawByte('[')
			for v48, v49 := range in.TableNames {
				if v48 > 0 {
					out.RawByte(',')
				}
				out.String(string(v49))
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetCertificateReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork35(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork36(in *jlexer.Lexer, out *GetCertificateParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "origin":
			out.Origin = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork36(out *jwriter.Writer, in GetCertificateParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"origin\":"
		out.RawString(prefix[1:])
		out.String(string(in.Origin))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetCertificateParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork36(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork37(in *jlexer.Lexer, out *GetAllCookiesReturns) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "cookies":
			if in.IsNull() {
				in.Skip()
				out.Cookies = nil
			} else {
				in.Delim('[')
				if out.Cookies == nil {
					if !in.IsDelim(']') {
						out.Cookies = make([]*Cookie, 0, 8)
					} else {
						out.Cookies = []*Cookie{}
					}
				} else {
					out.Cookies = (out.Cookies)[:0]
				}
				for !in.IsDelim(']') {
					var v50 *Cookie
					if in.IsNull() {
						in.Skip()
						v50 = nil
					} else {
						if v50 == nil {
							v50 = new(Cookie)
						}
						(*v50).UnmarshalEasyJSON(in)
					}
					out.Cookies = append(out.Cookies, v50)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork37(out *jwriter.Writer, in GetAllCookiesReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if len(in.Cookies) != 0 {
		const prefix string = ",\"cookies\":"
		first = false
		out.RawString(prefix[1:])
		{
			out.RawByte('[')
			for v51, v52 := range in.Cookies {
				if v51 > 0 {
					out.RawByte(',')
				}
				if v52 == nil {
					out.RawString("null")
				} else {
					(*v52).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetAllCookiesReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork37(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork38(in *jlexer.Lexer, out *GetAllCookiesParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork38(out *jwriter.Writer, in GetAllCookiesParams) {
	out.RawByte('{')
	first := true
	_ = first
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetAllCookiesParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork38(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork39(in *jlexer.Lexer, out *EventWebSocketWillSendHandshakeRequest) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "requestId":
			out.RequestID = RequestID(in.String())
		case "timestamp":
			if in.IsNull() {
				in.Skip()
				out.Timestamp = nil
			} else {
				if out.Timestamp == nil {
					out.Timestamp = new(cdp.MonotonicTime)
				}
				(*out.Timestamp).UnmarshalEasyJSON(in)
			}
		case "wallTime":
			if in.IsNull() {
				in.Skip()
				out.WallTime = nil
			} else {
				if out.WallTime == nil {
					out.WallTime = new(cdp.TimeSinceEpoch)
				}
				(*out.WallTime).UnmarshalEasyJSON(in)
			}
		case "request":
			if in.IsNull() {
				in.Skip()
				out.Request = nil
			} else {
				if out.Request == nil {
					out.Request = new(WebSocketRequest)
				}
				(*out.Request).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork39(out *jwriter.Writer, in EventWebSocketWillSendHandshakeRequest) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"requestId\":"
		out.RawString(prefix[1:])
		out.String(string(in.RequestID))
	}
	{
		const prefix string = ",\"timestamp\":"
		out.RawString(prefix)
		if in.Timestamp == nil {
			out.RawString("null")
		} else {
			(*in.Timestamp).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"wallTime\":"
		out.RawString(prefix)
		if in.WallTime == nil {
			out.RawString("null")
		} else {
			(*in.WallTime).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"request\":"
		out.RawString(prefix)
		if in.Request == nil {
			out.RawString("null")
		} else {
			(*in.Request).MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventWebSocketWillSendHandshakeRequest) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork39(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork40(in *jlexer.Lexer, out *EventWebSocketHandshakeResponseReceived) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "requestId":
			out.RequestID = RequestID(in.String())
		case "timestamp":
			if in.IsNull() {
				in.Skip()
				out.Timestamp = nil
			} else {
				if out.Timestamp == nil {
					out.Timestamp = new(cdp.MonotonicTime)
				}
				(*out.Timestamp).UnmarshalEasyJSON(in)
			}
		case "response":
			if in.IsNull() {
				in.Skip()
				out.Response = nil
			} else {
				if out.Response == nil {
					out.Response = new(WebSocketResponse)
				}
				(*out.Response).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork40(out *jwriter.Writer, in EventWebSocketHandshakeResponseReceived) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"requestId\":"
		out.RawString(prefix[1:])
		out.String(string(in.RequestID))
	}
	{
		const prefix string = ",\"timestamp\":"
		out.RawString(prefix)
		if in.Timestamp == nil {
			out.RawString("null")
		} else {
			(*in.Timestamp).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"response\":"
		out.RawString(prefix)
		if in.Response == nil {
			out.RawString("null")
		} else {
			(*in.Response).MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventWebSocketHandshakeResponseReceived) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork40(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork41(in *jlexer.Lexer, out *EventWebSocketFrameSent) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "requestId":
			out.RequestID = RequestID(in.String())
		case "timestamp":
			if in.IsNull() {
				in.Skip()
				out.Timestamp = nil
			} else {
				if out.Timestamp == nil {
					out.Timestamp = new(cdp.MonotonicTime)
				}
				(*out.Timestamp).UnmarshalEasyJSON(in)
			}
		case "response":
			if in.IsNull() {
				in.Skip()
				out.Response = nil
			} else {
				if out.Response == nil {
					out.Response = new(WebSocketFrame)
				}
				(*out.Response).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork41(out *jwriter.Writer, in EventWebSocketFrameSent) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"requestId\":"
		out.RawString(prefix[1:])
		out.String(string(in.RequestID))
	}
	{
		const prefix string = ",\"timestamp\":"
		out.RawString(prefix)
		if in.Timestamp == nil {
			out.RawString("null")
		} else {
			(*in.Timestamp).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"response\":"
		out.RawString(prefix)
		if in.Response == nil {
			out.RawString("null")
		} else {
			(*in.Response).MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventWebSocketFrameSent) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork41(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork42(in *jlexer.Lexer, out *EventWebSocketFrameReceived) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "requestId":
			out.RequestID = RequestID(in.String())
		case "timestamp":
			if in.IsNull() {
				in.Skip()
				out.Timestamp = nil
			} else {
				if out.Timestamp == nil {
					out.Timestamp = new(cdp.MonotonicTime)
				}
				(*out.Timestamp).UnmarshalEasyJSON(in)
			}
		case "response":
			if in.IsNull() {
				in.Skip()
				out.Response = nil
			} else {
				if out.Response == nil {
					out.Response = new(WebSocketFrame)
				}
				(*out.Response).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork42(out *jwriter.Writer, in EventWebSocketFrameReceived) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"requestId\":"
		out.RawString(prefix[1:])
		out.String(string(in.RequestID))
	}
	{
		const prefix string = ",\"timestamp\":"
		out.RawString(prefix)
		if in.Timestamp == nil {
			out.RawString("null")
		} else {
			(*in.Timestamp).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"response\":"
		out.RawString(prefix)
		if in.Response == nil {
			out.RawString("null")
		} else {
			(*in.Response).MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventWebSocketFrameReceived) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork42(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork43(in *jlexer.Lexer, out *EventWebSocketFrameError) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "requestId":
			out.RequestID = RequestID(in.String())
		case "timestamp":
			if in.IsNull() {
				in.Skip()
				out.Timestamp = nil
			} else {
				if out.Timestamp == nil {
					out.Timestamp = new(cdp.MonotonicTime)
				}
				(*out.Timestamp).UnmarshalEasyJSON(in)
			}
		case "errorMessage":
			out.ErrorMessage = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork43(out *jwriter.Writer, in EventWebSocketFrameError) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"requestId\":"
		out.RawString(prefix[1:])
		out.String(string(in.RequestID))
	}
	{
		const prefix string = ",\"timestamp\":"
		out.RawString(prefix)
		if in.Timestamp == nil {
			out.RawString("null")
		} else {
			(*in.Timestamp).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"errorMessage\":"
		out.RawString(prefix)
		out.String(string(in.ErrorMessage))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventWebSocketFrameError) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork43(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork44(in *jlexer.Lexer, out *EventWebSocketCreated) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "requestId":
			out.RequestID = RequestID(in.String())
		case "url":
			out.URL = string(in.String())
		case "initiator":
			if in.IsNull() {
				in.Skip()
				out.Initiator = nil
			} else {
				if out.Initiator == nil {
					out.Initiator = new(Initiator)
				}
				(*out.Initiator).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork44(out *jwriter.Writer, in EventWebSocketCreated) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"requestId\":"
		out.RawString(prefix[1:])
		out.String(string(in.RequestID))
	}
	{
		const prefix string = ",\"url\":"
		out.RawString(prefix)
		out.String(string(in.URL))
	}
	if in.Initiator != nil {
		const prefix string = ",\"initiator\":"
		out.RawString(prefix)
		(*in.Initiator).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

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

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventWebSocketClosed) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork45(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork46(in *jlexer.Lexer, out *EventSignedExchangeReceived) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "requestId":
			out.RequestID = RequestID(in.String())
		case "info":
			if in.IsNull() {
				in.Skip()
				out.Info = nil
			} else {
				if out.Info == nil {
					out.Info = new(SignedExchangeInfo)
				}
				(*out.Info).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork46(out *jwriter.Writer, in EventSignedExchangeReceived) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"requestId\":"
		out.RawString(prefix[1:])
		out.String(string(in.RequestID))
	}
	{
		const prefix string = ",\"info\":"
		out.RawString(prefix)
		if in.Info == nil {
			out.RawString("null")
		} else {
			(*in.Info).MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventSignedExchangeReceived) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork46(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork47(in *jlexer.Lexer, out *EventResponseReceivedExtraInfo) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "requestId":
			out.RequestID = RequestID(in.String())
		case "blockedCookies":
			if in.IsNull() {
				in.Skip()
				out.BlockedCookies = nil
			} else {
				in.Delim('[')
				if out.BlockedCookies == nil {
					if !in.IsDelim(']') {
						out.BlockedCookies = make([]*BlockedSetCookieWithReason, 0, 8)
					} else {
						out.BlockedCookies = []*BlockedSetCookieWithReason{}
					}
				} else {
					out.BlockedCookies = (out.BlockedCookies)[:0]
				}
				for !in.IsDelim(']') {
					var v53 *BlockedSetCookieWithReason
					if in.IsNull() {
						in.Skip()
						v53 = nil
					} else {
						if v53 == nil {
							v53 = new(BlockedSetCookieWithReason)
						}
						(*v53).UnmarshalEasyJSON(in)
					}
					out.BlockedCookies = append(out.BlockedCookies, v53)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "headers":
			if in.IsNull() {
				in.Skip()
			} else {
				in.Delim('{')
				if !in.IsDelim('}') {
					out.Headers = make(Headers)
				} else {
					out.Headers = nil
				}
				for !in.IsDelim('}') {
					key := string(in.String())
					in.WantColon()
					var v54 interface{}
					if m, ok := v54.(easyjson.Unmarshaler); ok {
						m.UnmarshalEasyJSON(in)
					} else if m, ok := v54.(json.Unmarshaler); ok {
						_ = m.UnmarshalJSON(in.Raw())
					} else {
						v54 = in.Interface()
					}
					(out.Headers)[key] = v54
					in.WantComma()
				}
				in.Delim('}')
			}
		case "headersText":
			out.HeadersText = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork47(out *jwriter.Writer, in EventResponseReceivedExtraInfo) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"requestId\":"
		out.RawString(prefix[1:])
		out.String(string(in.RequestID))
	}
	{
		const prefix string = ",\"blockedCookies\":"
		out.RawString(prefix)
		if in.BlockedCookies == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v55, v56 := range in.BlockedCookies {
				if v55 > 0 {
					out.RawByte(',')
				}
				if v56 == nil {
					out.RawString("null")
				} else {
					(*v56).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	{
		const prefix string = ",\"headers\":"
		out.RawString(prefix)
		if in.Headers == nil && (out.Flags&jwriter.NilMapAsEmpty) == 0 {
			out.RawString(`null`)
		} else {
			out.RawByte('{')
			v57First := true
			for v57Name, v57Value := range in.Headers {
				if v57First {
					v57First = false
				} else {
					out.RawByte(',')
				}
				out.String(string(v57Name))
				out.RawByte(':')
				if m, ok := v57Value.(easyjson.Marshaler); ok {
					m.MarshalEasyJSON(out)
				} else if m, ok := v57Value.(json.Marshaler); ok {
					out.Raw(m.MarshalJSON())
				} else {
					out.Raw(json.Marshal(v57Value))
				}
			}
			out.RawByte('}')
		}
	}
	if in.HeadersText != "" {
		const prefix string = ",\"headersText\":"
		out.RawString(prefix)
		out.String(string(in.HeadersText))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventResponseReceivedExtraInfo) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork47(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork48(in *jlexer.Lexer, out *EventResponseReceived) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "requestId":
			out.RequestID = RequestID(in.String())
		case "loaderId":
			out.LoaderID = cdp.LoaderID(in.String())
		case "timestamp":
			if in.IsNull() {
				in.Skip()
				out.Timestamp = nil
			} else {
				if out.Timestamp == nil {
					out.Timestamp = new(cdp.MonotonicTime)
				}
				(*out.Timestamp).UnmarshalEasyJSON(in)
			}
		case "type":
			(out.Type).UnmarshalEasyJSON(in)
		case "response":
			if in.IsNull() {
				in.Skip()
				out.Response = nil
			} else {
				if out.Response == nil {
					out.Response = new(Response)
				}
				(*out.Response).UnmarshalEasyJSON(in)
			}
		case "frameId":
			(out.FrameID).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork48(out *jwriter.Writer, in EventResponseReceived) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"requestId\":"
		out.RawString(prefix[1:])
		out.String(string(in.RequestID))
	}
	{
		const prefix string = ",\"loaderId\":"
		out.RawString(prefix)
		out.String(string(in.LoaderID))
	}
	{
		const prefix string = ",\"timestamp\":"
		out.RawString(prefix)
		if in.Timestamp == nil {
			out.RawString("null")
		} else {
			(*in.Timestamp).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"type\":"
		out.RawString(prefix)
		(in.Type).MarshalEasyJSON(out)
	}
	{
		const prefix string = ",\"response\":"
		out.RawString(prefix)
		if in.Response == nil {
			out.RawString("null")
		} else {
			(*in.Response).MarshalEasyJSON(out)
		}
	}
	if in.FrameID != "" {
		const prefix string = ",\"frameId\":"
		out.RawString(prefix)
		out.String(string(in.FrameID))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventResponseReceived) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork48(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork49(in *jlexer.Lexer, out *EventResourceChangedPriority) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "requestId":
			out.RequestID = RequestID(in.String())
		case "newPriority":
			(out.NewPriority).UnmarshalEasyJSON(in)
		case "timestamp":
			if in.IsNull() {
				in.Skip()
				out.Timestamp = nil
			} else {
				if out.Timestamp == nil {
					out.Timestamp = new(cdp.MonotonicTime)
				}
				(*out.Timestamp).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork49(out *jwriter.Writer, in EventResourceChangedPriority) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"requestId\":"
		out.RawString(prefix[1:])
		out.String(string(in.RequestID))
	}
	{
		const prefix string = ",\"newPriority\":"
		out.RawString(prefix)
		(in.NewPriority).MarshalEasyJSON(out)
	}
	{
		const prefix string = ",\"timestamp\":"
		out.RawString(prefix)
		if in.Timestamp == nil {
			out.RawString("null")
		} else {
			(*in.Timestamp).MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventResourceChangedPriority) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork49(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork50(in *jlexer.Lexer, out *EventRequestWillBeSentExtraInfo) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "requestId":
			out.RequestID = RequestID(in.String())
		case "associatedCookies":
			if in.IsNull() {
				in.Skip()
				out.AssociatedCookies = nil
			} else {
				in.Delim('[')
				if out.AssociatedCookies == nil {
					if !in.IsDelim(']') {
						out.AssociatedCookies = make([]*BlockedCookieWithReason, 0, 8)
					} else {
						out.AssociatedCookies = []*BlockedCookieWithReason{}
					}
				} else {
					out.AssociatedCookies = (out.AssociatedCookies)[:0]
				}
				for !in.IsDelim(']') {
					var v58 *BlockedCookieWithReason
					if in.IsNull() {
						in.Skip()
						v58 = nil
					} else {
						if v58 == nil {
							v58 = new(BlockedCookieWithReason)
						}
						(*v58).UnmarshalEasyJSON(in)
					}
					out.AssociatedCookies = append(out.AssociatedCookies, v58)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "headers":
			if in.IsNull() {
				in.Skip()
			} else {
				in.Delim('{')
				if !in.IsDelim('}') {
					out.Headers = make(Headers)
				} else {
					out.Headers = nil
				}
				for !in.IsDelim('}') {
					key := string(in.String())
					in.WantColon()
					var v59 interface{}
					if m, ok := v59.(easyjson.Unmarshaler); ok {
						m.UnmarshalEasyJSON(in)
					} else if m, ok := v59.(json.Unmarshaler); ok {
						_ = m.UnmarshalJSON(in.Raw())
					} else {
						v59 = in.Interface()
					}
					(out.Headers)[key] = v59
					in.WantComma()
				}
				in.Delim('}')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork50(out *jwriter.Writer, in EventRequestWillBeSentExtraInfo) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"requestId\":"
		out.RawString(prefix[1:])
		out.String(string(in.RequestID))
	}
	{
		const prefix string = ",\"associatedCookies\":"
		out.RawString(prefix)
		if in.AssociatedCookies == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v60, v61 := range in.AssociatedCookies {
				if v60 > 0 {
					out.RawByte(',')
				}
				if v61 == nil {
					out.RawString("null")
				} else {
					(*v61).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	{
		const prefix string = ",\"headers\":"
		out.RawString(prefix)
		if in.Headers == nil && (out.Flags&jwriter.NilMapAsEmpty) == 0 {
			out.RawString(`null`)
		} else {
			out.RawByte('{')
			v62First := true
			for v62Name, v62Value := range in.Headers {
				if v62First {
					v62First = false
				} else {
					out.RawByte(',')
				}
				out.String(string(v62Name))
				out.RawByte(':')
				if m, ok := v62Value.(easyjson.Marshaler); ok {
					m.MarshalEasyJSON(out)
				} else if m, ok := v62Value.(json.Marshaler); ok {
					out.Raw(m.MarshalJSON())
				} else {
					out.Raw(json.Marshal(v62Value))
				}
			}
			out.RawByte('}')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventRequestWillBeSentExtraInfo) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork50(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork51(in *jlexer.Lexer, out *EventRequestWillBeSent) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "requestId":
			out.RequestID = RequestID(in.String())
		case "loaderId":
			out.LoaderID = cdp.LoaderID(in.String())
		case "documentURL":
			out.DocumentURL = string(in.String())
		case "request":
			if in.IsNull() {
				in.Skip()
				out.Request = nil
			} else {
				if out.Request == nil {
					out.Request = new(Request)
				}
				(*out.Request).UnmarshalEasyJSON(in)
			}
		case "timestamp":
			if in.IsNull() {
				in.Skip()
				out.Timestamp = nil
			} else {
				if out.Timestamp == nil {
					out.Timestamp = new(cdp.MonotonicTime)
				}
				(*out.Timestamp).UnmarshalEasyJSON(in)
			}
		case "wallTime":
			if in.IsNull() {
				in.Skip()
				out.WallTime = nil
			} else {
				if out.WallTime == nil {
					out.WallTime = new(cdp.TimeSinceEpoch)
				}
				(*out.WallTime).UnmarshalEasyJSON(in)
			}
		case "initiator":
			if in.IsNull() {
				in.Skip()
				out.Initiator = nil
			} else {
				if out.Initiator == nil {
					out.Initiator = new(Initiator)
				}
				(*out.Initiator).UnmarshalEasyJSON(in)
			}
		case "redirectResponse":
			if in.IsNull() {
				in.Skip()
				out.RedirectResponse = nil
			} else {
				if out.RedirectResponse == nil {
					out.RedirectResponse = new(Response)
				}
				(*out.RedirectResponse).UnmarshalEasyJSON(in)
			}
		case "type":
			(out.Type).UnmarshalEasyJSON(in)
		case "frameId":
			(out.FrameID).UnmarshalEasyJSON(in)
		case "hasUserGesture":
			out.HasUserGesture = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork51(out *jwriter.Writer, in EventRequestWillBeSent) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"requestId\":"
		out.RawString(prefix[1:])
		out.String(string(in.RequestID))
	}
	{
		const prefix string = ",\"loaderId\":"
		out.RawString(prefix)
		out.String(string(in.LoaderID))
	}
	{
		const prefix string = ",\"documentURL\":"
		out.RawString(prefix)
		out.String(string(in.DocumentURL))
	}
	{
		const prefix string = ",\"request\":"
		out.RawString(prefix)
		if in.Request == nil {
			out.RawString("null")
		} else {
			(*in.Request).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"timestamp\":"
		out.RawString(prefix)
		if in.Timestamp == nil {
			out.RawString("null")
		} else {
			(*in.Timestamp).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"wallTime\":"
		out.RawString(prefix)
		if in.WallTime == nil {
			out.RawString("null")
		} else {
			(*in.WallTime).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"initiator\":"
		out.RawString(prefix)
		if in.Initiator == nil {
			out.RawString("null")
		} else {
			(*in.Initiator).MarshalEasyJSON(out)
		}
	}
	if in.RedirectResponse != nil {
		const prefix string = ",\"redirectResponse\":"
		out.RawString(prefix)
		(*in.RedirectResponse).MarshalEasyJSON(out)
	}
	if in.Type != "" {
		const prefix string = ",\"type\":"
		out.RawString(prefix)
		(in.Type).MarshalEasyJSON(out)
	}
	if in.FrameID != "" {
		const prefix string = ",\"frameId\":"
		out.RawString(prefix)
		out.String(string(in.FrameID))
	}
	if in.HasUserGesture {
		const prefix string = ",\"hasUserGesture\":"
		out.RawString(prefix)
		out.Bool(bool(in.HasUserGesture))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventRequestWillBeSent) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork51(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork52(in *jlexer.Lexer, out *EventRequestServedFromCache) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "requestId":
			out.RequestID = RequestID(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork52(out *jwriter.Writer, in EventRequestServedFromCache) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"requestId\":"
		out.RawString(prefix[1:])
		out.String(string(in.RequestID))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventRequestServedFromCache) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork52(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork53(in *jlexer.Lexer, out *EventLoadingFinished) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "requestId":
			out.RequestID = RequestID(in.String())
		case "timestamp":
			if in.IsNull() {
				in.Skip()
				out.Timestamp = nil
			} else {
				if out.Timestamp == nil {
					out.Timestamp = new(cdp.MonotonicTime)
				}
				(*out.Timestamp).UnmarshalEasyJSON(in)
			}
		case "encodedDataLength":
			out.EncodedDataLength = float64(in.Float64())
		case "shouldReportCorbBlocking":
			out.ShouldReportCorbBlocking = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork53(out *jwriter.Writer, in EventLoadingFinished) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"requestId\":"
		out.RawString(prefix[1:])
		out.String(string(in.RequestID))
	}
	{
		const prefix string = ",\"timestamp\":"
		out.RawString(prefix)
		if in.Timestamp == nil {
			out.RawString("null")
		} else {
			(*in.Timestamp).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"encodedDataLength\":"
		out.RawString(prefix)
		out.Float64(float64(in.EncodedDataLength))
	}
	if in.ShouldReportCorbBlocking {
		const prefix string = ",\"shouldReportCorbBlocking\":"
		out.RawString(prefix)
		out.Bool(bool(in.ShouldReportCorbBlocking))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventLoadingFinished) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork53(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork54(in *jlexer.Lexer, out *EventLoadingFailed) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "requestId":
			out.RequestID = RequestID(in.String())
		case "timestamp":
			if in.IsNull() {
				in.Skip()
				out.Timestamp = nil
			} else {
				if out.Timestamp == nil {
					out.Timestamp = new(cdp.MonotonicTime)
				}
				(*out.Timestamp).UnmarshalEasyJSON(in)
			}
		case "type":
			(out.Type).UnmarshalEasyJSON(in)
		case "errorText":
			out.ErrorText = string(in.String())
		case "canceled":
			out.Canceled = bool(in.Bool())
		case "blockedReason":
			(out.BlockedReason).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork54(out *jwriter.Writer, in EventLoadingFailed) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"requestId\":"
		out.RawString(prefix[1:])
		out.String(string(in.RequestID))
	}
	{
		const prefix string = ",\"timestamp\":"
		out.RawString(prefix)
		if in.Timestamp == nil {
			out.RawString("null")
		} else {
			(*in.Timestamp).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"type\":"
		out.RawString(prefix)
		(in.Type).MarshalEasyJSON(out)
	}
	{
		const prefix string = ",\"errorText\":"
		out.RawString(prefix)
		out.String(string(in.ErrorText))
	}
	if in.Canceled {
		const prefix string = ",\"canceled\":"
		out.RawString(prefix)
		out.Bool(bool(in.Canceled))
	}
	if in.BlockedReason != "" {
		const prefix string = ",\"blockedReason\":"
		out.RawString(prefix)
		(in.BlockedReason).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventLoadingFailed) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork54(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork55(in *jlexer.Lexer, out *EventEventSourceMessageReceived) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "requestId":
			out.RequestID = RequestID(in.String())
		case "timestamp":
			if in.IsNull() {
				in.Skip()
				out.Timestamp = nil
			} else {
				if out.Timestamp == nil {
					out.Timestamp = new(cdp.MonotonicTime)
				}
				(*out.Timestamp).UnmarshalEasyJSON(in)
			}
		case "eventName":
			out.EventName = string(in.String())
		case "eventId":
			out.EventID = string(in.String())
		case "data":
			out.Data = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork55(out *jwriter.Writer, in EventEventSourceMessageReceived) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"requestId\":"
		out.RawString(prefix[1:])
		out.String(string(in.RequestID))
	}
	{
		const prefix string = ",\"timestamp\":"
		out.RawString(prefix)
		if in.Timestamp == nil {
			out.RawString("null")
		} else {
			(*in.Timestamp).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"eventName\":"
		out.RawString(prefix)
		out.String(string(in.EventName))
	}
	{
		const prefix string = ",\"eventId\":"
		out.RawString(prefix)
		out.String(string(in.EventID))
	}
	{
		const prefix string = ",\"data\":"
		out.RawString(prefix)
		out.String(string(in.Data))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventEventSourceMessageReceived) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork55(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork56(in *jlexer.Lexer, out *EventDataReceived) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "requestId":
			out.RequestID = RequestID(in.String())
		case "timestamp":
			if in.IsNull() {
				in.Skip()
				out.Timestamp = nil
			} else {
				if out.Timestamp == nil {
					out.Timestamp = new(cdp.MonotonicTime)
				}
				(*out.Timestamp).UnmarshalEasyJSON(in)
			}
		case "dataLength":
			out.DataLength = int64(in.Int64())
		case "encodedDataLength":
			out.EncodedDataLength = int64(in.Int64())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork56(out *jwriter.Writer, in EventDataReceived) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"requestId\":"
		out.RawString(prefix[1:])
		out.String(string(in.RequestID))
	}
	{
		const prefix string = ",\"timestamp\":"
		out.RawString(prefix)
		if in.Timestamp == nil {
			out.RawString("null")
		} else {
			(*in.Timestamp).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"dataLength\":"
		out.RawString(prefix)
		out.Int64(int64(in.DataLength))
	}
	{
		const prefix string = ",\"encodedDataLength\":"
		out.RawString(prefix)
		out.Int64(int64(in.EncodedDataLength))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventDataReceived) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork56(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork57(in *jlexer.Lexer, out *EnableParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "maxTotalBufferSize":
			out.MaxTotalBufferSize = int64(in.Int64())
		case "maxResourceBufferSize":
			out.MaxResourceBufferSize = int64(in.Int64())
		case "maxPostDataSize":
			out.MaxPostDataSize = int64(in.Int64())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork57(out *jwriter.Writer, in EnableParams) {
	out.RawByte('{')
	first := true
	_ = first
	if in.MaxTotalBufferSize != 0 {
		const prefix string = ",\"maxTotalBufferSize\":"
		first = false
		out.RawString(prefix[1:])
		out.Int64(int64(in.MaxTotalBufferSize))
	}
	if in.MaxResourceBufferSize != 0 {
		const prefix string = ",\"maxResourceBufferSize\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.Int64(int64(in.MaxResourceBufferSize))
	}
	if in.MaxPostDataSize != 0 {
		const prefix string = ",\"maxPostDataSize\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.Int64(int64(in.MaxPostDataSize))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EnableParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork57(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork58(in *jlexer.Lexer, out *EmulateNetworkConditionsParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "offline":
			out.Offline = bool(in.Bool())
		case "latency":
			out.Latency = float64(in.Float64())
		case "downloadThroughput":
			out.DownloadThroughput = float64(in.Float64())
		case "uploadThroughput":
			out.UploadThroughput = float64(in.Float64())
		case "connectionType":
			(out.ConnectionType).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork58(out *jwriter.Writer, in EmulateNetworkConditionsParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"offline\":"
		out.RawString(prefix[1:])
		out.Bool(bool(in.Offline))
	}
	{
		const prefix string = ",\"latency\":"
		out.RawString(prefix)
		out.Float64(float64(in.Latency))
	}
	{
		const prefix string = ",\"downloadThroughput\":"
		out.RawString(prefix)
		out.Float64(float64(in.DownloadThroughput))
	}
	{
		const prefix string = ",\"uploadThroughput\":"
		out.RawString(prefix)
		out.Float64(float64(in.UploadThroughput))
	}
	if in.ConnectionType != "" {
		const prefix string = ",\"connectionType\":"
		out.RawString(prefix)
		(in.ConnectionType).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

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

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *DisableParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork59(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork60(in *jlexer.Lexer, out *DeleteCookiesParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "name":
			out.Name = string(in.String())
		case "url":
			out.URL = string(in.String())
		case "domain":
			out.Domain = string(in.String())
		case "path":
			out.Path = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork60(out *jwriter.Writer, in DeleteCookiesParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"name\":"
		out.RawString(prefix[1:])
		out.String(string(in.Name))
	}
	if in.URL != "" {
		const prefix string = ",\"url\":"
		out.RawString(prefix)
		out.String(string(in.URL))
	}
	if in.Domain != "" {
		const prefix string = ",\"domain\":"
		out.RawString(prefix)
		out.String(string(in.Domain))
	}
	if in.Path != "" {
		const prefix string = ",\"path\":"
		out.RawString(prefix)
		out.String(string(in.Path))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *DeleteCookiesParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork60(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork61(in *jlexer.Lexer, out *CookieParam) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "name":
			out.Name = string(in.String())
		case "value":
			out.Value = string(in.String())
		case "url":
			out.URL = string(in.String())
		case "domain":
			out.Domain = string(in.String())
		case "path":
			out.Path = string(in.String())
		case "secure":
			out.Secure = bool(in.Bool())
		case "httpOnly":
			out.HTTPOnly = bool(in.Bool())
		case "sameSite":
			(out.SameSite).UnmarshalEasyJSON(in)
		case "expires":
			if in.IsNull() {
				in.Skip()
				out.Expires = nil
			} else {
				if out.Expires == nil {
					out.Expires = new(cdp.TimeSinceEpoch)
				}
				(*out.Expires).UnmarshalEasyJSON(in)
			}
		case "priority":
			(out.Priority).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork61(out *jwriter.Writer, in CookieParam) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"name\":"
		out.RawString(prefix[1:])
		out.String(string(in.Name))
	}
	{
		const prefix string = ",\"value\":"
		out.RawString(prefix)
		out.String(string(in.Value))
	}
	if in.URL != "" {
		const prefix string = ",\"url\":"
		out.RawString(prefix)
		out.String(string(in.URL))
	}
	if in.Domain != "" {
		const prefix string = ",\"domain\":"
		out.RawString(prefix)
		out.String(string(in.Domain))
	}
	if in.Path != "" {
		const prefix string = ",\"path\":"
		out.RawString(prefix)
		out.String(string(in.Path))
	}
	if in.Secure {
		const prefix string = ",\"secure\":"
		out.RawString(prefix)
		out.Bool(bool(in.Secure))
	}
	if in.HTTPOnly {
		const prefix string = ",\"httpOnly\":"
		out.RawString(prefix)
		out.Bool(bool(in.HTTPOnly))
	}
	if in.SameSite != "" {
		const prefix string = ",\"sameSite\":"
		out.RawString(prefix)
		(in.SameSite).MarshalEasyJSON(out)
	}
	if in.Expires != nil {
		const prefix string = ",\"expires\":"
		out.RawString(prefix)
		(*in.Expires).MarshalEasyJSON(out)
	}
	if in.Priority != "" {
		const prefix string = ",\"priority\":"
		out.RawString(prefix)
		(in.Priority).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *CookieParam) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork61(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork62(in *jlexer.Lexer, out *Cookie) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "name":
			out.Name = string(in.String())
		case "value":
			out.Value = string(in.String())
		case "domain":
			out.Domain = string(in.String())
		case "path":
			out.Path = string(in.String())
		case "expires":
			out.Expires = float64(in.Float64())
		case "size":
			out.Size = int64(in.Int64())
		case "httpOnly":
			out.HTTPOnly = bool(in.Bool())
		case "secure":
			out.Secure = bool(in.Bool())
		case "session":
			out.Session = bool(in.Bool())
		case "sameSite":
			(out.SameSite).UnmarshalEasyJSON(in)
		case "priority":
			(out.Priority).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork62(out *jwriter.Writer, in Cookie) {
	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))
	}
	{
		const prefix string = ",\"domain\":"
		out.RawString(prefix)
		out.String(string(in.Domain))
	}
	{
		const prefix string = ",\"path\":"
		out.RawString(prefix)
		out.String(string(in.Path))
	}
	{
		const prefix string = ",\"expires\":"
		out.RawString(prefix)
		out.Float64(float64(in.Expires))
	}
	{
		const prefix string = ",\"size\":"
		out.RawString(prefix)
		out.Int64(int64(in.Size))
	}
	{
		const prefix string = ",\"httpOnly\":"
		out.RawString(prefix)
		out.Bool(bool(in.HTTPOnly))
	}
	{
		const prefix string = ",\"secure\":"
		out.RawString(prefix)
		out.Bool(bool(in.Secure))
	}
	{
		const prefix string = ",\"session\":"
		out.RawString(prefix)
		out.Bool(bool(in.Session))
	}
	if in.SameSite != "" {
		const prefix string = ",\"sameSite\":"
		out.RawString(prefix)
		(in.SameSite).MarshalEasyJSON(out)
	}
	{
		const prefix string = ",\"priority\":"
		out.RawString(prefix)
		(in.Priority).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *Cookie) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork62(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork63(in *jlexer.Lexer, out *ClearBrowserCookiesParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork63(out *jwriter.Writer, in ClearBrowserCookiesParams) {
	out.RawByte('{')
	first := true
	_ = first
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *ClearBrowserCookiesParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork63(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork64(in *jlexer.Lexer, out *ClearBrowserCacheParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork64(out *jwriter.Writer, in ClearBrowserCacheParams) {
	out.RawByte('{')
	first := true
	_ = first
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *ClearBrowserCacheParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork64(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork65(in *jlexer.Lexer, out *CachedResource) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "url":
			out.URL = string(in.String())
		case "type":
			(out.Type).UnmarshalEasyJSON(in)
		case "response":
			if in.IsNull() {
				in.Skip()
				out.Response = nil
			} else {
				if out.Response == nil {
					out.Response = new(Response)
				}
				(*out.Response).UnmarshalEasyJSON(in)
			}
		case "bodySize":
			out.BodySize = float64(in.Float64())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork65(out *jwriter.Writer, in CachedResource) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"url\":"
		out.RawString(prefix[1:])
		out.String(string(in.URL))
	}
	{
		const prefix string = ",\"type\":"
		out.RawString(prefix)
		(in.Type).MarshalEasyJSON(out)
	}
	if in.Response != nil {
		const prefix string = ",\"response\":"
		out.RawString(prefix)
		(*in.Response).MarshalEasyJSON(out)
	}
	{
		const prefix string = ",\"bodySize\":"
		out.RawString(prefix)
		out.Float64(float64(in.BodySize))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *CachedResource) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork65(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork66(in *jlexer.Lexer, out *BlockedSetCookieWithReason) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "blockedReasons":
			if in.IsNull() {
				in.Skip()
				out.BlockedReasons = nil
			} else {
				in.Delim('[')
				if out.BlockedReasons == nil {
					if !in.IsDelim(']') {
						out.BlockedReasons = make([]SetCookieBlockedReason, 0, 4)
					} else {
						out.BlockedReasons = []SetCookieBlockedReason{}
					}
				} else {
					out.BlockedReasons = (out.BlockedReasons)[:0]
				}
				for !in.IsDelim(']') {
					var v63 SetCookieBlockedReason
					(v63).UnmarshalEasyJSON(in)
					out.BlockedReasons = append(out.BlockedReasons, v63)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "cookieLine":
			out.CookieLine = string(in.String())
		case "cookie":
			if in.IsNull() {
				in.Skip()
				out.Cookie = nil
			} else {
				if out.Cookie == nil {
					out.Cookie = new(Cookie)
				}
				(*out.Cookie).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork66(out *jwriter.Writer, in BlockedSetCookieWithReason) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"blockedReasons\":"
		out.RawString(prefix[1:])
		if in.BlockedReasons == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v64, v65 := range in.BlockedReasons {
				if v64 > 0 {
					out.RawByte(',')
				}
				(v65).MarshalEasyJSON(out)
			}
			out.RawByte(']')
		}
	}
	{
		const prefix string = ",\"cookieLine\":"
		out.RawString(prefix)
		out.String(string(in.CookieLine))
	}
	if in.Cookie != nil {
		const prefix string = ",\"cookie\":"
		out.RawString(prefix)
		(*in.Cookie).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *BlockedSetCookieWithReason) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork66(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork67(in *jlexer.Lexer, out *BlockedCookieWithReason) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "blockedReasons":
			if in.IsNull() {
				in.Skip()
				out.BlockedReasons = nil
			} else {
				in.Delim('[')
				if out.BlockedReasons == nil {
					if !in.IsDelim(']') {
						out.BlockedReasons = make([]CookieBlockedReason, 0, 4)
					} else {
						out.BlockedReasons = []CookieBlockedReason{}
					}
				} else {
					out.BlockedReasons = (out.BlockedReasons)[:0]
				}
				for !in.IsDelim(']') {
					var v66 CookieBlockedReason
					(v66).UnmarshalEasyJSON(in)
					out.BlockedReasons = append(out.BlockedReasons, v66)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "cookie":
			if in.IsNull() {
				in.Skip()
				out.Cookie = nil
			} else {
				if out.Cookie == nil {
					out.Cookie = new(Cookie)
				}
				(*out.Cookie).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork67(out *jwriter.Writer, in BlockedCookieWithReason) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"blockedReasons\":"
		out.RawString(prefix[1:])
		if in.BlockedReasons == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v67, v68 := range in.BlockedReasons {
				if v67 > 0 {
					out.RawByte(',')
				}
				(v68).MarshalEasyJSON(out)
			}
			out.RawByte(']')
		}
	}
	{
		const prefix string = ",\"cookie\":"
		out.RawString(prefix)
		if in.Cookie == nil {
			out.RawString("null")
		} else {
			(*in.Cookie).MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *BlockedCookieWithReason) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork67(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork68(in *jlexer.Lexer, out *AuthChallengeResponse) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "response":
			(out.Response).UnmarshalEasyJSON(in)
		case "username":
			out.Username = string(in.String())
		case "password":
			out.Password = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork68(out *jwriter.Writer, in AuthChallengeResponse) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"response\":"
		out.RawString(prefix[1:])
		(in.Response).MarshalEasyJSON(out)
	}
	if in.Username != "" {
		const prefix string = ",\"username\":"
		out.RawString(prefix)
		out.String(string(in.Username))
	}
	if in.Password != "" {
		const prefix string = ",\"password\":"
		out.RawString(prefix)
		out.String(string(in.Password))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *AuthChallengeResponse) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork68(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork69(in *jlexer.Lexer, out *AuthChallenge) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "source":
			(out.Source).UnmarshalEasyJSON(in)
		case "origin":
			out.Origin = string(in.String())
		case "scheme":
			out.Scheme = string(in.String())
		case "realm":
			out.Realm = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork69(out *jwriter.Writer, in AuthChallenge) {
	out.RawByte('{')
	first := true
	_ = first
	if in.Source != "" {
		const prefix string = ",\"source\":"
		first = false
		out.RawString(prefix[1:])
		(in.Source).MarshalEasyJSON(out)
	}
	{
		const prefix string = ",\"origin\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.String(string(in.Origin))
	}
	{
		const prefix string = ",\"scheme\":"
		out.RawString(prefix)
		out.String(string(in.Scheme))
	}
	{
		const prefix string = ",\"realm\":"
		out.RawString(prefix)
		out.String(string(in.Realm))
	}
	out.RawByte('}')
}

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

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

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

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