youngee_mc_api/vendor/github.com/chromedp/cdproto/network/easyjson.go

// 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.UnsafeFieldName(false)
		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('{')
				out.Headers = make(Headers)
				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.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "headers":
			if in.IsNull() {
				in.Skip()
			} else {
				in.Delim('{')
				out.Headers = make(Headers)
				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.UnsafeFieldName(false)
		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 *TrustTokenParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "operation":
			(out.Operation).UnmarshalEasyJSON(in)
		case "refreshPolicy":
			(out.RefreshPolicy).UnmarshalEasyJSON(in)
		case "issuers":
			if in.IsNull() {
				in.Skip()
				out.Issuers = nil
			} else {
				in.Delim('[')
				if out.Issuers == nil {
					if !in.IsDelim(']') {
						out.Issuers = make([]string, 0, 4)
					} else {
						out.Issuers = []string{}
					}
				} else {
					out.Issuers = (out.Issuers)[:0]
				}
				for !in.IsDelim(']') {
					var v7 string
					v7 = string(in.String())
					out.Issuers = append(out.Issuers, v7)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork3(out *jwriter.Writer, in TrustTokenParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"operation\":"
		out.RawString(prefix[1:])
		(in.Operation).MarshalEasyJSON(out)
	}
	{
		const prefix string = ",\"refreshPolicy\":"
		out.RawString(prefix)
		(in.RefreshPolicy).MarshalEasyJSON(out)
	}
	if len(in.Issuers) != 0 {
		const prefix string = ",\"issuers\":"
		out.RawString(prefix)
		{
			out.RawByte('[')
			for v8, v9 := range in.Issuers {
				if v8 > 0 {
					out.RawByte(',')
				}
				out.String(string(v9))
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *TrustTokenParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork3(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork4(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.UnsafeFieldName(false)
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork4(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork4(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *TakeResponseBodyForInterceptionAsStreamReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork4(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork5(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.UnsafeFieldName(false)
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork5(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork5(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

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

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *StreamResourceContentReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork6(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork7(in *jlexer.Lexer, out *StreamResourceContentParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "requestId":
			out.RequestID = RequestID(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork7(out *jwriter.Writer, in StreamResourceContentParams) {
	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 StreamResourceContentParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork7(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *StreamResourceContentParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork7(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork8(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.UnsafeFieldName(false)
		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 v10 string
					v10 = string(in.String())
					out.Certificates = append(out.Certificates, v10)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork8(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 v11, v12 := range in.Certificates {
				if v11 > 0 {
					out.RawByte(',')
				}
				out.String(string(v12))
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SignedExchangeSignature) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork8(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork9(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.UnsafeFieldName(false)
		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 v13 *SignedExchangeError
					if in.IsNull() {
						in.Skip()
						v13 = nil
					} else {
						if v13 == nil {
							v13 = new(SignedExchangeError)
						}
						(*v13).UnmarshalEasyJSON(in)
					}
					out.Errors = append(out.Errors, v13)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork9(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 v14, v15 := range in.Errors {
				if v14 > 0 {
					out.RawByte(',')
				}
				if v15 == nil {
					out.RawString("null")
				} else {
					(*v15).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SignedExchangeInfo) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork9(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork10(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.UnsafeFieldName(false)
		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('{')
				out.ResponseHeaders = make(Headers)
				for !in.IsDelim('}') {
					key := string(in.String())
					in.WantColon()
					var v16 interface{}
					if m, ok := v16.(easyjson.Unmarshaler); ok {
						m.UnmarshalEasyJSON(in)
					} else if m, ok := v16.(json.Unmarshaler); ok {
						_ = m.UnmarshalJSON(in.Raw())
					} else {
						v16 = in.Interface()
					}
					(out.ResponseHeaders)[key] = v16
					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 v17 *SignedExchangeSignature
					if in.IsNull() {
						in.Skip()
						v17 = nil
					} else {
						if v17 == nil {
							v17 = new(SignedExchangeSignature)
						}
						(*v17).UnmarshalEasyJSON(in)
					}
					out.Signatures = append(out.Signatures, v17)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "headerIntegrity":
			out.HeaderIntegrity = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork10(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('{')
			v18First := true
			for v18Name, v18Value := range in.ResponseHeaders {
				if v18First {
					v18First = false
				} else {
					out.RawByte(',')
				}
				out.String(string(v18Name))
				out.RawByte(':')
				if m, ok := v18Value.(easyjson.Marshaler); ok {
					m.MarshalEasyJSON(out)
				} else if m, ok := v18Value.(json.Marshaler); ok {
					out.Raw(m.MarshalJSON())
				} else {
					out.Raw(json.Marshal(v18Value))
				}
			}
			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 v19, v20 := range in.Signatures {
				if v19 > 0 {
					out.RawByte(',')
				}
				if v20 == nil {
					out.RawString("null")
				} else {
					(*v20).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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork10(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SignedExchangeHeader) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork10(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork11(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.UnsafeFieldName(false)
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork11(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork11(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SignedExchangeError) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork11(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork12(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.UnsafeFieldName(false)
		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":
			out.Timestamp = float64(in.Float64())
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork12(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)
		out.Float64(float64(in.Timestamp))
	}
	{
		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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork12(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SignedCertificateTimestamp) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork12(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork13(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.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "headers":
			if in.IsNull() {
				in.Skip()
			} else {
				in.Delim('{')
				out.Headers = make(Headers)
				for !in.IsDelim('}') {
					key := string(in.String())
					in.WantColon()
					var v21 interface{}
					if m, ok := v21.(easyjson.Unmarshaler); ok {
						m.UnmarshalEasyJSON(in)
					} else if m, ok := v21.(json.Unmarshaler); ok {
						_ = m.UnmarshalJSON(in.Raw())
					} else {
						v21 = in.Interface()
					}
					(out.Headers)[key] = v21
					in.WantComma()
				}
				in.Delim('}')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork13(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('{')
			v22First := true
			for v22Name, v22Value := range in.Headers {
				if v22First {
					v22First = false
				} else {
					out.RawByte(',')
				}
				out.String(string(v22Name))
				out.RawByte(':')
				if m, ok := v22Value.(easyjson.Marshaler); ok {
					m.MarshalEasyJSON(out)
				} else if m, ok := v22Value.(json.Marshaler); ok {
					out.Raw(m.MarshalJSON())
				} else {
					out.Raw(json.Marshal(v22Value))
				}
			}
			out.RawByte('}')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetExtraHTTPHeadersParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork13(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork14(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.UnsafeFieldName(false)
		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 v23 *CookieParam
					if in.IsNull() {
						in.Skip()
						v23 = nil
					} else {
						if v23 == nil {
							v23 = new(CookieParam)
						}
						(*v23).UnmarshalEasyJSON(in)
					}
					out.Cookies = append(out.Cookies, v23)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork14(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 v24, v25 := range in.Cookies {
				if v24 > 0 {
					out.RawByte(',')
				}
				if v25 == nil {
					out.RawString("null")
				} else {
					(*v25).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetCookiesParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork14(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork15(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.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "name":
			out.Name = string(in.String())
		case "value":
			out.Value = string(in.String())
		case "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)
		case "sameParty":
			out.SameParty = bool(in.Bool())
		case "sourceScheme":
			(out.SourceScheme).UnmarshalEasyJSON(in)
		case "sourcePort":
			out.SourcePort = int64(in.Int64())
		case "partitionKey":
			out.PartitionKey = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork15(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)
	}
	if in.SameParty {
		const prefix string = ",\"sameParty\":"
		out.RawString(prefix)
		out.Bool(bool(in.SameParty))
	}
	if in.SourceScheme != "" {
		const prefix string = ",\"sourceScheme\":"
		out.RawString(prefix)
		(in.SourceScheme).MarshalEasyJSON(out)
	}
	if in.SourcePort != 0 {
		const prefix string = ",\"sourcePort\":"
		out.RawString(prefix)
		out.Int64(int64(in.SourcePort))
	}
	if in.PartitionKey != "" {
		const prefix string = ",\"partitionKey\":"
		out.RawString(prefix)
		out.String(string(in.PartitionKey))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetCookieParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork15(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork16(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.UnsafeFieldName(false)
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork16(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork16(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetCacheDisabledParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork16(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork17(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.UnsafeFieldName(false)
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork17(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork17(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetBypassServiceWorkerParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork17(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork18(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.UnsafeFieldName(false)
		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 v26 string
					v26 = string(in.String())
					out.Urls = append(out.Urls, v26)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork18(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 v27, v28 := range in.Urls {
				if v27 > 0 {
					out.RawByte(',')
				}
				out.String(string(v28))
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

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

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetAttachDebugStackParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork19(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork20(in *jlexer.Lexer, out *SetAcceptedEncodingsParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "encodings":
			if in.IsNull() {
				in.Skip()
				out.Encodings = nil
			} else {
				in.Delim('[')
				if out.Encodings == nil {
					if !in.IsDelim(']') {
						out.Encodings = make([]ContentEncoding, 0, 4)
					} else {
						out.Encodings = []ContentEncoding{}
					}
				} else {
					out.Encodings = (out.Encodings)[:0]
				}
				for !in.IsDelim(']') {
					var v29 ContentEncoding
					(v29).UnmarshalEasyJSON(in)
					out.Encodings = append(out.Encodings, v29)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork20(out *jwriter.Writer, in SetAcceptedEncodingsParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"encodings\":"
		out.RawString(prefix[1:])
		if in.Encodings == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v30, v31 := range in.Encodings {
				if v30 > 0 {
					out.RawByte(',')
				}
				(v31).MarshalEasyJSON(out)
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetAcceptedEncodingsParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork20(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork21(in *jlexer.Lexer, out *ServiceWorkerRouterInfo) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "ruleIdMatched":
			out.RuleIDMatched = int64(in.Int64())
		case "matchedSourceType":
			(out.MatchedSourceType).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork21(out *jwriter.Writer, in ServiceWorkerRouterInfo) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"ruleIdMatched\":"
		out.RawString(prefix[1:])
		out.Int64(int64(in.RuleIDMatched))
	}
	{
		const prefix string = ",\"matchedSourceType\":"
		out.RawString(prefix)
		(in.MatchedSourceType).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *ServiceWorkerRouterInfo) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork21(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork22(in *jlexer.Lexer, out *SecurityIsolationStatus) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "coop":
			if in.IsNull() {
				in.Skip()
				out.Coop = nil
			} else {
				if out.Coop == nil {
					out.Coop = new(CrossOriginOpenerPolicyStatus)
				}
				(*out.Coop).UnmarshalEasyJSON(in)
			}
		case "coep":
			if in.IsNull() {
				in.Skip()
				out.Coep = nil
			} else {
				if out.Coep == nil {
					out.Coep = new(CrossOriginEmbedderPolicyStatus)
				}
				(*out.Coep).UnmarshalEasyJSON(in)
			}
		case "csp":
			if in.IsNull() {
				in.Skip()
				out.Csp = nil
			} else {
				in.Delim('[')
				if out.Csp == nil {
					if !in.IsDelim(']') {
						out.Csp = make([]*ContentSecurityPolicyStatus, 0, 8)
					} else {
						out.Csp = []*ContentSecurityPolicyStatus{}
					}
				} else {
					out.Csp = (out.Csp)[:0]
				}
				for !in.IsDelim(']') {
					var v32 *ContentSecurityPolicyStatus
					if in.IsNull() {
						in.Skip()
						v32 = nil
					} else {
						if v32 == nil {
							v32 = new(ContentSecurityPolicyStatus)
						}
						(*v32).UnmarshalEasyJSON(in)
					}
					out.Csp = append(out.Csp, v32)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork22(out *jwriter.Writer, in SecurityIsolationStatus) {
	out.RawByte('{')
	first := true
	_ = first
	if in.Coop != nil {
		const prefix string = ",\"coop\":"
		first = false
		out.RawString(prefix[1:])
		(*in.Coop).MarshalEasyJSON(out)
	}
	if in.Coep != nil {
		const prefix string = ",\"coep\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.Coep).MarshalEasyJSON(out)
	}
	if len(in.Csp) != 0 {
		const prefix string = ",\"csp\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		{
			out.RawByte('[')
			for v33, v34 := range in.Csp {
				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 SecurityIsolationStatus) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork22(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SecurityIsolationStatus) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork22(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork23(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.UnsafeFieldName(false)
		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 v35 string
					v35 = string(in.String())
					out.SanList = append(out.SanList, v35)
					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 v36 *SignedCertificateTimestamp
					if in.IsNull() {
						in.Skip()
						v36 = nil
					} else {
						if v36 == nil {
							v36 = new(SignedCertificateTimestamp)
						}
						(*v36).UnmarshalEasyJSON(in)
					}
					out.SignedCertificateTimestampList = append(out.SignedCertificateTimestampList, v36)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "certificateTransparencyCompliance":
			(out.CertificateTransparencyCompliance).UnmarshalEasyJSON(in)
		case "serverSignatureAlgorithm":
			out.ServerSignatureAlgorithm = int64(in.Int64())
		case "encryptedClientHello":
			out.EncryptedClientHello = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork23(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 v37, v38 := range in.SanList {
				if v37 > 0 {
					out.RawByte(',')
				}
				out.String(string(v38))
			}
			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 v39, v40 := range in.SignedCertificateTimestampList {
				if v39 > 0 {
					out.RawByte(',')
				}
				if v40 == nil {
					out.RawString("null")
				} else {
					(*v40).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	{
		const prefix string = ",\"certificateTransparencyCompliance\":"
		out.RawString(prefix)
		(in.CertificateTransparencyCompliance).MarshalEasyJSON(out)
	}
	if in.ServerSignatureAlgorithm != 0 {
		const prefix string = ",\"serverSignatureAlgorithm\":"
		out.RawString(prefix)
		out.Int64(int64(in.ServerSignatureAlgorithm))
	}
	{
		const prefix string = ",\"encryptedClientHello\":"
		out.RawString(prefix)
		out.Bool(bool(in.EncryptedClientHello))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SecurityDetails) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork23(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork24(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.UnsafeFieldName(false)
		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 v41 *debugger.SearchMatch
					if in.IsNull() {
						in.Skip()
						v41 = nil
					} else {
						if v41 == nil {
							v41 = new(debugger.SearchMatch)
						}
						(*v41).UnmarshalEasyJSON(in)
					}
					out.Result = append(out.Result, v41)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork24(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 v42, v43 := range in.Result {
				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 SearchInResponseBodyReturns) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork24(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SearchInResponseBodyReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork24(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork25(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.UnsafeFieldName(false)
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork25(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork25(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SearchInResponseBodyParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork25(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork26(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.UnsafeFieldName(false)
		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('{')
				out.Headers = make(Headers)
				for !in.IsDelim('}') {
					key := string(in.String())
					in.WantColon()
					var v44 interface{}
					if m, ok := v44.(easyjson.Unmarshaler); ok {
						m.UnmarshalEasyJSON(in)
					} else if m, ok := v44.(json.Unmarshaler); ok {
						_ = m.UnmarshalJSON(in.Raw())
					} else {
						v44 = in.Interface()
					}
					(out.Headers)[key] = v44
					in.WantComma()
				}
				in.Delim('}')
			}
		case "mimeType":
			out.MimeType = string(in.String())
		case "charset":
			out.Charset = 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 v45 interface{}
					if m, ok := v45.(easyjson.Unmarshaler); ok {
						m.UnmarshalEasyJSON(in)
					} else if m, ok := v45.(json.Unmarshaler); ok {
						_ = m.UnmarshalJSON(in.Raw())
					} else {
						v45 = in.Interface()
					}
					(out.RequestHeaders)[key] = v45
					in.WantComma()
				}
				in.Delim('}')
			}
		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 "fromEarlyHints":
			out.FromEarlyHints = bool(in.Bool())
		case "serviceWorkerRouterInfo":
			if in.IsNull() {
				in.Skip()
				out.ServiceWorkerRouterInfo = nil
			} else {
				if out.ServiceWorkerRouterInfo == nil {
					out.ServiceWorkerRouterInfo = new(ServiceWorkerRouterInfo)
				}
				(*out.ServiceWorkerRouterInfo).UnmarshalEasyJSON(in)
			}
		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.TimeSinceEpochMilli)
				}
				(*out.ResponseTime).UnmarshalEasyJSON(in)
			}
		case "cacheStorageCacheName":
			out.CacheStorageCacheName = string(in.String())
		case "protocol":
			out.Protocol = string(in.String())
		case "alternateProtocolUsage":
			(out.AlternateProtocolUsage).UnmarshalEasyJSON(in)
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork26(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('{')
			v46First := true
			for v46Name, v46Value := range in.Headers {
				if v46First {
					v46First = false
				} else {
					out.RawByte(',')
				}
				out.String(string(v46Name))
				out.RawByte(':')
				if m, ok := v46Value.(easyjson.Marshaler); ok {
					m.MarshalEasyJSON(out)
				} else if m, ok := v46Value.(json.Marshaler); ok {
					out.Raw(m.MarshalJSON())
				} else {
					out.Raw(json.Marshal(v46Value))
				}
			}
			out.RawByte('}')
		}
	}
	{
		const prefix string = ",\"mimeType\":"
		out.RawString(prefix)
		out.String(string(in.MimeType))
	}
	{
		const prefix string = ",\"charset\":"
		out.RawString(prefix)
		out.String(string(in.Charset))
	}
	if len(in.RequestHeaders) != 0 {
		const prefix string = ",\"requestHeaders\":"
		out.RawString(prefix)
		{
			out.RawByte('{')
			v47First := true
			for v47Name, v47Value := range in.RequestHeaders {
				if v47First {
					v47First = false
				} else {
					out.RawByte(',')
				}
				out.String(string(v47Name))
				out.RawByte(':')
				if m, ok := v47Value.(easyjson.Marshaler); ok {
					m.MarshalEasyJSON(out)
				} else if m, ok := v47Value.(json.Marshaler); ok {
					out.Raw(m.MarshalJSON())
				} else {
					out.Raw(json.Marshal(v47Value))
				}
			}
			out.RawByte('}')
		}
	}
	{
		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))
	}
	if in.FromEarlyHints {
		const prefix string = ",\"fromEarlyHints\":"
		out.RawString(prefix)
		out.Bool(bool(in.FromEarlyHints))
	}
	if in.ServiceWorkerRouterInfo != nil {
		const prefix string = ",\"serviceWorkerRouterInfo\":"
		out.RawString(prefix)
		(*in.ServiceWorkerRouterInfo).MarshalEasyJSON(out)
	}
	{
		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))
	}
	if in.AlternateProtocolUsage != "" {
		const prefix string = ",\"alternateProtocolUsage\":"
		out.RawString(prefix)
		(in.AlternateProtocolUsage).MarshalEasyJSON(out)
	}
	{
		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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork26(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *Response) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork26(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork27(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.UnsafeFieldName(false)
		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 "receiveHeadersStart":
			out.ReceiveHeadersStart = float64(in.Float64())
		case "receiveHeadersEnd":
			out.ReceiveHeadersEnd = float64(in.Float64())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork27(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 = ",\"receiveHeadersStart\":"
		out.RawString(prefix)
		out.Float64(float64(in.ReceiveHeadersStart))
	}
	{
		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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork27(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *ResourceTiming) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork27(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork28(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.UnsafeFieldName(false)
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork28(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork28(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *RequestPattern) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork28(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork29(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.UnsafeFieldName(false)
		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('{')
				out.Headers = make(Headers)
				for !in.IsDelim('}') {
					key := string(in.String())
					in.WantColon()
					var v48 interface{}
					if m, ok := v48.(easyjson.Unmarshaler); ok {
						m.UnmarshalEasyJSON(in)
					} else if m, ok := v48.(json.Unmarshaler); ok {
						_ = m.UnmarshalJSON(in.Raw())
					} else {
						v48 = in.Interface()
					}
					(out.Headers)[key] = v48
					in.WantComma()
				}
				in.Delim('}')
			}
		case "hasPostData":
			out.HasPostData = bool(in.Bool())
		case "postDataEntries":
			if in.IsNull() {
				in.Skip()
				out.PostDataEntries = nil
			} else {
				in.Delim('[')
				if out.PostDataEntries == nil {
					if !in.IsDelim(']') {
						out.PostDataEntries = make([]*PostDataEntry, 0, 8)
					} else {
						out.PostDataEntries = []*PostDataEntry{}
					}
				} else {
					out.PostDataEntries = (out.PostDataEntries)[:0]
				}
				for !in.IsDelim(']') {
					var v49 *PostDataEntry
					if in.IsNull() {
						in.Skip()
						v49 = nil
					} else {
						if v49 == nil {
							v49 = new(PostDataEntry)
						}
						(*v49).UnmarshalEasyJSON(in)
					}
					out.PostDataEntries = append(out.PostDataEntries, v49)
					in.WantComma()
				}
				in.Delim(']')
			}
		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())
		case "trustTokenParams":
			if in.IsNull() {
				in.Skip()
				out.TrustTokenParams = nil
			} else {
				if out.TrustTokenParams == nil {
					out.TrustTokenParams = new(TrustTokenParams)
				}
				(*out.TrustTokenParams).UnmarshalEasyJSON(in)
			}
		case "isSameSite":
			out.IsSameSite = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork29(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('{')
			v50First := true
			for v50Name, v50Value := range in.Headers {
				if v50First {
					v50First = false
				} else {
					out.RawByte(',')
				}
				out.String(string(v50Name))
				out.RawByte(':')
				if m, ok := v50Value.(easyjson.Marshaler); ok {
					m.MarshalEasyJSON(out)
				} else if m, ok := v50Value.(json.Marshaler); ok {
					out.Raw(m.MarshalJSON())
				} else {
					out.Raw(json.Marshal(v50Value))
				}
			}
			out.RawByte('}')
		}
	}
	if in.HasPostData {
		const prefix string = ",\"hasPostData\":"
		out.RawString(prefix)
		out.Bool(bool(in.HasPostData))
	}
	if len(in.PostDataEntries) != 0 {
		const prefix string = ",\"postDataEntries\":"
		out.RawString(prefix)
		{
			out.RawByte('[')
			for v51, v52 := range in.PostDataEntries {
				if v51 > 0 {
					out.RawByte(',')
				}
				if v52 == nil {
					out.RawString("null")
				} else {
					(*v52).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	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))
	}
	if in.TrustTokenParams != nil {
		const prefix string = ",\"trustTokenParams\":"
		out.RawString(prefix)
		(*in.TrustTokenParams).MarshalEasyJSON(out)
	}
	if in.IsSameSite {
		const prefix string = ",\"isSameSite\":"
		out.RawString(prefix)
		out.Bool(bool(in.IsSameSite))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *Request) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork29(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork30(in *jlexer.Lexer, out *ReportingAPIReport) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "id":
			out.ID = ReportID(in.String())
		case "initiatorUrl":
			out.InitiatorURL = string(in.String())
		case "destination":
			out.Destination = string(in.String())
		case "type":
			out.Type = 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 "depth":
			out.Depth = int64(in.Int64())
		case "completedAttempts":
			out.CompletedAttempts = int64(in.Int64())
		case "body":
			(out.Body).UnmarshalEasyJSON(in)
		case "status":
			(out.Status).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork30(out *jwriter.Writer, in ReportingAPIReport) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"id\":"
		out.RawString(prefix[1:])
		out.String(string(in.ID))
	}
	{
		const prefix string = ",\"initiatorUrl\":"
		out.RawString(prefix)
		out.String(string(in.InitiatorURL))
	}
	{
		const prefix string = ",\"destination\":"
		out.RawString(prefix)
		out.String(string(in.Destination))
	}
	{
		const prefix string = ",\"type\":"
		out.RawString(prefix)
		out.String(string(in.Type))
	}
	{
		const prefix string = ",\"timestamp\":"
		out.RawString(prefix)
		if in.Timestamp == nil {
			out.RawString("null")
		} else {
			(*in.Timestamp).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"depth\":"
		out.RawString(prefix)
		out.Int64(int64(in.Depth))
	}
	{
		const prefix string = ",\"completedAttempts\":"
		out.RawString(prefix)
		out.Int64(int64(in.CompletedAttempts))
	}
	{
		const prefix string = ",\"body\":"
		out.RawString(prefix)
		(in.Body).MarshalEasyJSON(out)
	}
	{
		const prefix string = ",\"status\":"
		out.RawString(prefix)
		(in.Status).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

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

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *ReportingAPIEndpoint) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork31(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork32(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.UnsafeFieldName(false)
		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 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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork32(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

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

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

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

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

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

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *LoadNetworkResourceReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork34(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork35(in *jlexer.Lexer, out *LoadNetworkResourceParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "frameId":
			(out.FrameID).UnmarshalEasyJSON(in)
		case "url":
			out.URL = string(in.String())
		case "options":
			if in.IsNull() {
				in.Skip()
				out.Options = nil
			} else {
				if out.Options == nil {
					out.Options = new(LoadNetworkResourceOptions)
				}
				(*out.Options).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork35(out *jwriter.Writer, in LoadNetworkResourceParams) {
	out.RawByte('{')
	first := true
	_ = first
	if in.FrameID != "" {
		const prefix string = ",\"frameId\":"
		first = false
		out.RawString(prefix[1:])
		out.String(string(in.FrameID))
	}
	{
		const prefix string = ",\"url\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.String(string(in.URL))
	}
	{
		const prefix string = ",\"options\":"
		out.RawString(prefix)
		if in.Options == nil {
			out.RawString("null")
		} else {
			(*in.Options).MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *LoadNetworkResourceParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork35(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork36(in *jlexer.Lexer, out *LoadNetworkResourcePageResult) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "success":
			out.Success = bool(in.Bool())
		case "netError":
			out.NetError = float64(in.Float64())
		case "netErrorName":
			out.NetErrorName = string(in.String())
		case "httpStatusCode":
			out.HTTPStatusCode = float64(in.Float64())
		case "stream":
			out.Stream = io.StreamHandle(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 v53 interface{}
					if m, ok := v53.(easyjson.Unmarshaler); ok {
						m.UnmarshalEasyJSON(in)
					} else if m, ok := v53.(json.Unmarshaler); ok {
						_ = m.UnmarshalJSON(in.Raw())
					} else {
						v53 = in.Interface()
					}
					(out.Headers)[key] = v53
					in.WantComma()
				}
				in.Delim('}')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork36(out *jwriter.Writer, in LoadNetworkResourcePageResult) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"success\":"
		out.RawString(prefix[1:])
		out.Bool(bool(in.Success))
	}
	if in.NetError != 0 {
		const prefix string = ",\"netError\":"
		out.RawString(prefix)
		out.Float64(float64(in.NetError))
	}
	if in.NetErrorName != "" {
		const prefix string = ",\"netErrorName\":"
		out.RawString(prefix)
		out.String(string(in.NetErrorName))
	}
	if in.HTTPStatusCode != 0 {
		const prefix string = ",\"httpStatusCode\":"
		out.RawString(prefix)
		out.Float64(float64(in.HTTPStatusCode))
	}
	if in.Stream != "" {
		const prefix string = ",\"stream\":"
		out.RawString(prefix)
		out.String(string(in.Stream))
	}
	if len(in.Headers) != 0 {
		const prefix string = ",\"headers\":"
		out.RawString(prefix)
		{
			out.RawByte('{')
			v54First := true
			for v54Name, v54Value := range in.Headers {
				if v54First {
					v54First = false
				} else {
					out.RawByte(',')
				}
				out.String(string(v54Name))
				out.RawByte(':')
				if m, ok := v54Value.(easyjson.Marshaler); ok {
					m.MarshalEasyJSON(out)
				} else if m, ok := v54Value.(json.Marshaler); ok {
					out.Raw(m.MarshalJSON())
				} else {
					out.Raw(json.Marshal(v54Value))
				}
			}
			out.RawByte('}')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *LoadNetworkResourcePageResult) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork36(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork37(in *jlexer.Lexer, out *LoadNetworkResourceOptions) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "disableCache":
			out.DisableCache = bool(in.Bool())
		case "includeCredentials":
			out.IncludeCredentials = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork37(out *jwriter.Writer, in LoadNetworkResourceOptions) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"disableCache\":"
		out.RawString(prefix[1:])
		out.Bool(bool(in.DisableCache))
	}
	{
		const prefix string = ",\"includeCredentials\":"
		out.RawString(prefix)
		out.Bool(bool(in.IncludeCredentials))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *LoadNetworkResourceOptions) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork37(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork38(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.UnsafeFieldName(false)
		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())
		case "columnNumber":
			out.ColumnNumber = float64(in.Float64())
		case "requestId":
			out.RequestID = RequestID(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork38(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))
	}
	if in.ColumnNumber != 0 {
		const prefix string = ",\"columnNumber\":"
		out.RawString(prefix)
		out.Float64(float64(in.ColumnNumber))
	}
	if in.RequestID != "" {
		const prefix string = ",\"requestId\":"
		out.RawString(prefix)
		out.String(string(in.RequestID))
	}
	out.RawByte('}')
}

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

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

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

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

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

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

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

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

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetSecurityIsolationStatusParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork40(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork41(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.UnsafeFieldName(false)
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork41(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork41(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetResponseBodyReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork41(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork42(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.UnsafeFieldName(false)
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork42(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork42(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetResponseBodyParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork42(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork43(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.UnsafeFieldName(false)
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork43(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork43(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetResponseBodyForInterceptionReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork43(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork44(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.UnsafeFieldName(false)
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork44(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork44(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetResponseBodyForInterceptionParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork44(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork45(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.UnsafeFieldName(false)
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork45(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork45(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetRequestPostDataReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork45(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork46(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.UnsafeFieldName(false)
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork46(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork46(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetRequestPostDataParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork46(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork47(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.UnsafeFieldName(false)
		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 v55 *Cookie
					if in.IsNull() {
						in.Skip()
						v55 = nil
					} else {
						if v55 == nil {
							v55 = new(Cookie)
						}
						(*v55).UnmarshalEasyJSON(in)
					}
					out.Cookies = append(out.Cookies, v55)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork47(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 v56, v57 := range in.Cookies {
				if v56 > 0 {
					out.RawByte(',')
				}
				if v57 == nil {
					out.RawString("null")
				} else {
					(*v57).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetCookiesReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork47(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork48(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.UnsafeFieldName(false)
		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 v58 string
					v58 = string(in.String())
					out.Urls = append(out.Urls, v58)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork48(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 v59, v60 := range in.Urls {
				if v59 > 0 {
					out.RawByte(',')
				}
				out.String(string(v60))
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetCookiesParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork48(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork49(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.UnsafeFieldName(false)
		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 v61 string
					v61 = string(in.String())
					out.TableNames = append(out.TableNames, v61)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork49(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 v62, v63 := range in.TableNames {
				if v62 > 0 {
					out.RawByte(',')
				}
				out.String(string(v63))
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetCertificateReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork49(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork50(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.UnsafeFieldName(false)
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork50(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork50(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetCertificateParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork50(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork51(in *jlexer.Lexer, out *ExemptedSetCookieWithReason) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "exemptionReason":
			(out.ExemptionReason).UnmarshalEasyJSON(in)
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork51(out *jwriter.Writer, in ExemptedSetCookieWithReason) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"exemptionReason\":"
		out.RawString(prefix[1:])
		(in.ExemptionReason).MarshalEasyJSON(out)
	}
	{
		const prefix string = ",\"cookieLine\":"
		out.RawString(prefix)
		out.String(string(in.CookieLine))
	}
	{
		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 ExemptedSetCookieWithReason) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork51(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *ExemptedSetCookieWithReason) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork51(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork52(in *jlexer.Lexer, out *EventWebTransportCreated) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "transportId":
			out.TransportID = RequestID(in.String())
		case "url":
			out.URL = string(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 "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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork52(out *jwriter.Writer, in EventWebTransportCreated) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"transportId\":"
		out.RawString(prefix[1:])
		out.String(string(in.TransportID))
	}
	{
		const prefix string = ",\"url\":"
		out.RawString(prefix)
		out.String(string(in.URL))
	}
	{
		const prefix string = ",\"timestamp\":"
		out.RawString(prefix)
		if in.Timestamp == nil {
			out.RawString("null")
		} else {
			(*in.Timestamp).MarshalEasyJSON(out)
		}
	}
	if in.Initiator != nil {
		const prefix string = ",\"initiator\":"
		out.RawString(prefix)
		(*in.Initiator).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventWebTransportCreated) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork52(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork53(in *jlexer.Lexer, out *EventWebTransportConnectionEstablished) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "transportId":
			out.TransportID = 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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork53(out *jwriter.Writer, in EventWebTransportConnectionEstablished) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"transportId\":"
		out.RawString(prefix[1:])
		out.String(string(in.TransportID))
	}
	{
		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 EventWebTransportConnectionEstablished) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork53(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventWebTransportConnectionEstablished) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork53(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork54(in *jlexer.Lexer, out *EventWebTransportClosed) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "transportId":
			out.TransportID = 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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork54(out *jwriter.Writer, in EventWebTransportClosed) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"transportId\":"
		out.RawString(prefix[1:])
		out.String(string(in.TransportID))
	}
	{
		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 EventWebTransportClosed) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork54(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventWebTransportClosed) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork54(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork55(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.UnsafeFieldName(false)
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork55(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork55(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventWebSocketWillSendHandshakeRequest) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork55(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork56(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.UnsafeFieldName(false)
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork56(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork56(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventWebSocketHandshakeResponseReceived) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork56(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork57(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.UnsafeFieldName(false)
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork57(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork57(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventWebSocketFrameSent) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork57(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork58(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.UnsafeFieldName(false)
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork58(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork58(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventWebSocketFrameReceived) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork58(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork59(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.UnsafeFieldName(false)
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork59(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork59(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventWebSocketFrameError) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork59(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork60(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.UnsafeFieldName(false)
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork60(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork60(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventWebSocketCreated) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork60(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork61(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.UnsafeFieldName(false)
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork61(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork61(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventWebSocketClosed) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork61(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork62(in *jlexer.Lexer, out *EventTrustTokenOperationDone) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "status":
			(out.Status).UnmarshalEasyJSON(in)
		case "type":
			(out.Type).UnmarshalEasyJSON(in)
		case "requestId":
			out.RequestID = RequestID(in.String())
		case "topLevelOrigin":
			out.TopLevelOrigin = string(in.String())
		case "issuerOrigin":
			out.IssuerOrigin = string(in.String())
		case "issuedTokenCount":
			out.IssuedTokenCount = int64(in.Int64())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork62(out *jwriter.Writer, in EventTrustTokenOperationDone) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"status\":"
		out.RawString(prefix[1:])
		(in.Status).MarshalEasyJSON(out)
	}
	{
		const prefix string = ",\"type\":"
		out.RawString(prefix)
		(in.Type).MarshalEasyJSON(out)
	}
	{
		const prefix string = ",\"requestId\":"
		out.RawString(prefix)
		out.String(string(in.RequestID))
	}
	if in.TopLevelOrigin != "" {
		const prefix string = ",\"topLevelOrigin\":"
		out.RawString(prefix)
		out.String(string(in.TopLevelOrigin))
	}
	if in.IssuerOrigin != "" {
		const prefix string = ",\"issuerOrigin\":"
		out.RawString(prefix)
		out.String(string(in.IssuerOrigin))
	}
	if in.IssuedTokenCount != 0 {
		const prefix string = ",\"issuedTokenCount\":"
		out.RawString(prefix)
		out.Int64(int64(in.IssuedTokenCount))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventTrustTokenOperationDone) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork62(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork63(in *jlexer.Lexer, out *EventSubresourceWebBundleMetadataReceived) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "requestId":
			out.RequestID = RequestID(in.String())
		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 v64 string
					v64 = string(in.String())
					out.Urls = append(out.Urls, v64)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork63(out *jwriter.Writer, in EventSubresourceWebBundleMetadataReceived) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"requestId\":"
		out.RawString(prefix[1:])
		out.String(string(in.RequestID))
	}
	{
		const prefix string = ",\"urls\":"
		out.RawString(prefix)
		if in.Urls == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v65, v66 := range in.Urls {
				if v65 > 0 {
					out.RawByte(',')
				}
				out.String(string(v66))
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

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

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventSubresourceWebBundleMetadataError) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork64(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork65(in *jlexer.Lexer, out *EventSubresourceWebBundleInnerResponseParsed) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "innerRequestId":
			out.InnerRequestID = RequestID(in.String())
		case "innerRequestURL":
			out.InnerRequestURL = string(in.String())
		case "bundleRequestId":
			out.BundleRequestID = RequestID(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork65(out *jwriter.Writer, in EventSubresourceWebBundleInnerResponseParsed) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"innerRequestId\":"
		out.RawString(prefix[1:])
		out.String(string(in.InnerRequestID))
	}
	{
		const prefix string = ",\"innerRequestURL\":"
		out.RawString(prefix)
		out.String(string(in.InnerRequestURL))
	}
	if in.BundleRequestID != "" {
		const prefix string = ",\"bundleRequestId\":"
		out.RawString(prefix)
		out.String(string(in.BundleRequestID))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventSubresourceWebBundleInnerResponseParsed) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork65(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork66(in *jlexer.Lexer, out *EventSubresourceWebBundleInnerResponseError) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "innerRequestId":
			out.InnerRequestID = RequestID(in.String())
		case "innerRequestURL":
			out.InnerRequestURL = string(in.String())
		case "errorMessage":
			out.ErrorMessage = string(in.String())
		case "bundleRequestId":
			out.BundleRequestID = RequestID(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork66(out *jwriter.Writer, in EventSubresourceWebBundleInnerResponseError) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"innerRequestId\":"
		out.RawString(prefix[1:])
		out.String(string(in.InnerRequestID))
	}
	{
		const prefix string = ",\"innerRequestURL\":"
		out.RawString(prefix)
		out.String(string(in.InnerRequestURL))
	}
	{
		const prefix string = ",\"errorMessage\":"
		out.RawString(prefix)
		out.String(string(in.ErrorMessage))
	}
	if in.BundleRequestID != "" {
		const prefix string = ",\"bundleRequestId\":"
		out.RawString(prefix)
		out.String(string(in.BundleRequestID))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventSubresourceWebBundleInnerResponseError) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork66(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork67(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.UnsafeFieldName(false)
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork67(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork67(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventSignedExchangeReceived) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork67(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork68(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.UnsafeFieldName(false)
		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 v67 *BlockedSetCookieWithReason
					if in.IsNull() {
						in.Skip()
						v67 = nil
					} else {
						if v67 == nil {
							v67 = new(BlockedSetCookieWithReason)
						}
						(*v67).UnmarshalEasyJSON(in)
					}
					out.BlockedCookies = append(out.BlockedCookies, v67)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "headers":
			if in.IsNull() {
				in.Skip()
			} else {
				in.Delim('{')
				out.Headers = make(Headers)
				for !in.IsDelim('}') {
					key := string(in.String())
					in.WantColon()
					var v68 interface{}
					if m, ok := v68.(easyjson.Unmarshaler); ok {
						m.UnmarshalEasyJSON(in)
					} else if m, ok := v68.(json.Unmarshaler); ok {
						_ = m.UnmarshalJSON(in.Raw())
					} else {
						v68 = in.Interface()
					}
					(out.Headers)[key] = v68
					in.WantComma()
				}
				in.Delim('}')
			}
		case "resourceIPAddressSpace":
			(out.ResourceIPAddressSpace).UnmarshalEasyJSON(in)
		case "statusCode":
			out.StatusCode = int64(in.Int64())
		case "headersText":
			out.HeadersText = string(in.String())
		case "cookiePartitionKey":
			out.CookiePartitionKey = string(in.String())
		case "cookiePartitionKeyOpaque":
			out.CookiePartitionKeyOpaque = bool(in.Bool())
		case "exemptedCookies":
			if in.IsNull() {
				in.Skip()
				out.ExemptedCookies = nil
			} else {
				in.Delim('[')
				if out.ExemptedCookies == nil {
					if !in.IsDelim(']') {
						out.ExemptedCookies = make([]*ExemptedSetCookieWithReason, 0, 8)
					} else {
						out.ExemptedCookies = []*ExemptedSetCookieWithReason{}
					}
				} else {
					out.ExemptedCookies = (out.ExemptedCookies)[:0]
				}
				for !in.IsDelim(']') {
					var v69 *ExemptedSetCookieWithReason
					if in.IsNull() {
						in.Skip()
						v69 = nil
					} else {
						if v69 == nil {
							v69 = new(ExemptedSetCookieWithReason)
						}
						(*v69).UnmarshalEasyJSON(in)
					}
					out.ExemptedCookies = append(out.ExemptedCookies, v69)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork68(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 v70, v71 := range in.BlockedCookies {
				if v70 > 0 {
					out.RawByte(',')
				}
				if v71 == nil {
					out.RawString("null")
				} else {
					(*v71).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('{')
			v72First := true
			for v72Name, v72Value := range in.Headers {
				if v72First {
					v72First = false
				} else {
					out.RawByte(',')
				}
				out.String(string(v72Name))
				out.RawByte(':')
				if m, ok := v72Value.(easyjson.Marshaler); ok {
					m.MarshalEasyJSON(out)
				} else if m, ok := v72Value.(json.Marshaler); ok {
					out.Raw(m.MarshalJSON())
				} else {
					out.Raw(json.Marshal(v72Value))
				}
			}
			out.RawByte('}')
		}
	}
	{
		const prefix string = ",\"resourceIPAddressSpace\":"
		out.RawString(prefix)
		(in.ResourceIPAddressSpace).MarshalEasyJSON(out)
	}
	{
		const prefix string = ",\"statusCode\":"
		out.RawString(prefix)
		out.Int64(int64(in.StatusCode))
	}
	if in.HeadersText != "" {
		const prefix string = ",\"headersText\":"
		out.RawString(prefix)
		out.String(string(in.HeadersText))
	}
	if in.CookiePartitionKey != "" {
		const prefix string = ",\"cookiePartitionKey\":"
		out.RawString(prefix)
		out.String(string(in.CookiePartitionKey))
	}
	if in.CookiePartitionKeyOpaque {
		const prefix string = ",\"cookiePartitionKeyOpaque\":"
		out.RawString(prefix)
		out.Bool(bool(in.CookiePartitionKeyOpaque))
	}
	if len(in.ExemptedCookies) != 0 {
		const prefix string = ",\"exemptedCookies\":"
		out.RawString(prefix)
		{
			out.RawByte('[')
			for v73, v74 := range in.ExemptedCookies {
				if v73 > 0 {
					out.RawByte(',')
				}
				if v74 == nil {
					out.RawString("null")
				} else {
					(*v74).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventResponseReceivedExtraInfo) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork68(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork69(in *jlexer.Lexer, out *EventResponseReceivedEarlyHints) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "requestId":
			out.RequestID = RequestID(in.String())
		case "headers":
			if in.IsNull() {
				in.Skip()
			} else {
				in.Delim('{')
				out.Headers = make(Headers)
				for !in.IsDelim('}') {
					key := string(in.String())
					in.WantColon()
					var v75 interface{}
					if m, ok := v75.(easyjson.Unmarshaler); ok {
						m.UnmarshalEasyJSON(in)
					} else if m, ok := v75.(json.Unmarshaler); ok {
						_ = m.UnmarshalJSON(in.Raw())
					} else {
						v75 = in.Interface()
					}
					(out.Headers)[key] = v75
					in.WantComma()
				}
				in.Delim('}')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork69(out *jwriter.Writer, in EventResponseReceivedEarlyHints) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"requestId\":"
		out.RawString(prefix[1:])
		out.String(string(in.RequestID))
	}
	{
		const prefix string = ",\"headers\":"
		out.RawString(prefix)
		if in.Headers == nil && (out.Flags&jwriter.NilMapAsEmpty) == 0 {
			out.RawString(`null`)
		} else {
			out.RawByte('{')
			v76First := true
			for v76Name, v76Value := range in.Headers {
				if v76First {
					v76First = false
				} else {
					out.RawByte(',')
				}
				out.String(string(v76Name))
				out.RawByte(':')
				if m, ok := v76Value.(easyjson.Marshaler); ok {
					m.MarshalEasyJSON(out)
				} else if m, ok := v76Value.(json.Marshaler); ok {
					out.Raw(m.MarshalJSON())
				} else {
					out.Raw(json.Marshal(v76Value))
				}
			}
			out.RawByte('}')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventResponseReceivedEarlyHints) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork69(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork70(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.UnsafeFieldName(false)
		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 "hasExtraInfo":
			out.HasExtraInfo = bool(in.Bool())
		case "frameId":
			(out.FrameID).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork70(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)
		}
	}
	{
		const prefix string = ",\"hasExtraInfo\":"
		out.RawString(prefix)
		out.Bool(bool(in.HasExtraInfo))
	}
	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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork70(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventResponseReceived) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork70(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork71(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.UnsafeFieldName(false)
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork71(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork71(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventResourceChangedPriority) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork71(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork72(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.UnsafeFieldName(false)
		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([]*AssociatedCookie, 0, 8)
					} else {
						out.AssociatedCookies = []*AssociatedCookie{}
					}
				} else {
					out.AssociatedCookies = (out.AssociatedCookies)[:0]
				}
				for !in.IsDelim(']') {
					var v77 *AssociatedCookie
					if in.IsNull() {
						in.Skip()
						v77 = nil
					} else {
						if v77 == nil {
							v77 = new(AssociatedCookie)
						}
						(*v77).UnmarshalEasyJSON(in)
					}
					out.AssociatedCookies = append(out.AssociatedCookies, v77)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "headers":
			if in.IsNull() {
				in.Skip()
			} else {
				in.Delim('{')
				out.Headers = make(Headers)
				for !in.IsDelim('}') {
					key := string(in.String())
					in.WantColon()
					var v78 interface{}
					if m, ok := v78.(easyjson.Unmarshaler); ok {
						m.UnmarshalEasyJSON(in)
					} else if m, ok := v78.(json.Unmarshaler); ok {
						_ = m.UnmarshalJSON(in.Raw())
					} else {
						v78 = in.Interface()
					}
					(out.Headers)[key] = v78
					in.WantComma()
				}
				in.Delim('}')
			}
		case "connectTiming":
			if in.IsNull() {
				in.Skip()
				out.ConnectTiming = nil
			} else {
				if out.ConnectTiming == nil {
					out.ConnectTiming = new(ConnectTiming)
				}
				(*out.ConnectTiming).UnmarshalEasyJSON(in)
			}
		case "clientSecurityState":
			if in.IsNull() {
				in.Skip()
				out.ClientSecurityState = nil
			} else {
				if out.ClientSecurityState == nil {
					out.ClientSecurityState = new(ClientSecurityState)
				}
				(*out.ClientSecurityState).UnmarshalEasyJSON(in)
			}
		case "siteHasCookieInOtherPartition":
			out.SiteHasCookieInOtherPartition = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork72(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 v79, v80 := range in.AssociatedCookies {
				if v79 > 0 {
					out.RawByte(',')
				}
				if v80 == nil {
					out.RawString("null")
				} else {
					(*v80).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('{')
			v81First := true
			for v81Name, v81Value := range in.Headers {
				if v81First {
					v81First = false
				} else {
					out.RawByte(',')
				}
				out.String(string(v81Name))
				out.RawByte(':')
				if m, ok := v81Value.(easyjson.Marshaler); ok {
					m.MarshalEasyJSON(out)
				} else if m, ok := v81Value.(json.Marshaler); ok {
					out.Raw(m.MarshalJSON())
				} else {
					out.Raw(json.Marshal(v81Value))
				}
			}
			out.RawByte('}')
		}
	}
	{
		const prefix string = ",\"connectTiming\":"
		out.RawString(prefix)
		if in.ConnectTiming == nil {
			out.RawString("null")
		} else {
			(*in.ConnectTiming).MarshalEasyJSON(out)
		}
	}
	if in.ClientSecurityState != nil {
		const prefix string = ",\"clientSecurityState\":"
		out.RawString(prefix)
		(*in.ClientSecurityState).MarshalEasyJSON(out)
	}
	if in.SiteHasCookieInOtherPartition {
		const prefix string = ",\"siteHasCookieInOtherPartition\":"
		out.RawString(prefix)
		out.Bool(bool(in.SiteHasCookieInOtherPartition))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventRequestWillBeSentExtraInfo) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork72(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork73(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.UnsafeFieldName(false)
		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 "redirectHasExtraInfo":
			out.RedirectHasExtraInfo = bool(in.Bool())
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork73(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)
		}
	}
	{
		const prefix string = ",\"redirectHasExtraInfo\":"
		out.RawString(prefix)
		out.Bool(bool(in.RedirectHasExtraInfo))
	}
	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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork73(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventRequestWillBeSent) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork73(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork74(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.UnsafeFieldName(false)
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork74(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork74(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

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

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

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

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

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

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventReportingAPIReportAdded) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork76(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork77(in *jlexer.Lexer, out *EventReportingAPIEndpointsChangedForOrigin) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "origin":
			out.Origin = string(in.String())
		case "endpoints":
			if in.IsNull() {
				in.Skip()
				out.Endpoints = nil
			} else {
				in.Delim('[')
				if out.Endpoints == nil {
					if !in.IsDelim(']') {
						out.Endpoints = make([]*ReportingAPIEndpoint, 0, 8)
					} else {
						out.Endpoints = []*ReportingAPIEndpoint{}
					}
				} else {
					out.Endpoints = (out.Endpoints)[:0]
				}
				for !in.IsDelim(']') {
					var v82 *ReportingAPIEndpoint
					if in.IsNull() {
						in.Skip()
						v82 = nil
					} else {
						if v82 == nil {
							v82 = new(ReportingAPIEndpoint)
						}
						(*v82).UnmarshalEasyJSON(in)
					}
					out.Endpoints = append(out.Endpoints, v82)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork77(out *jwriter.Writer, in EventReportingAPIEndpointsChangedForOrigin) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"origin\":"
		out.RawString(prefix[1:])
		out.String(string(in.Origin))
	}
	{
		const prefix string = ",\"endpoints\":"
		out.RawString(prefix)
		if in.Endpoints == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v83, v84 := range in.Endpoints {
				if v83 > 0 {
					out.RawByte(',')
				}
				if v84 == nil {
					out.RawString("null")
				} else {
					(*v84).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventReportingAPIEndpointsChangedForOrigin) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork77(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork78(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.UnsafeFieldName(false)
		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())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork78(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))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventLoadingFinished) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork78(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork79(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.UnsafeFieldName(false)
		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)
		case "corsErrorStatus":
			if in.IsNull() {
				in.Skip()
				out.CorsErrorStatus = nil
			} else {
				if out.CorsErrorStatus == nil {
					out.CorsErrorStatus = new(CorsErrorStatus)
				}
				(*out.CorsErrorStatus).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork79(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)
	}
	if in.CorsErrorStatus != nil {
		const prefix string = ",\"corsErrorStatus\":"
		out.RawString(prefix)
		(*in.CorsErrorStatus).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventLoadingFailed) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork79(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork80(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.UnsafeFieldName(false)
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork80(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork80(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventEventSourceMessageReceived) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork80(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork81(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.UnsafeFieldName(false)
		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())
		case "data":
			out.Data = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork81(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))
	}
	if in.Data != "" {
		const prefix string = ",\"data\":"
		out.RawString(prefix)
		out.String(string(in.Data))
	}
	out.RawByte('}')
}

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

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

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

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

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EnableReportingAPIParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork82(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork83(in *jlexer.Lexer, out *EnableParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork83(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork83(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EnableParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork83(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork84(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.UnsafeFieldName(false)
		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)
		case "packetLoss":
			out.PacketLoss = float64(in.Float64())
		case "packetQueueLength":
			out.PacketQueueLength = int64(in.Int64())
		case "packetReordering":
			out.PacketReordering = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork84(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)
	}
	if in.PacketLoss != 0 {
		const prefix string = ",\"packetLoss\":"
		out.RawString(prefix)
		out.Float64(float64(in.PacketLoss))
	}
	if in.PacketQueueLength != 0 {
		const prefix string = ",\"packetQueueLength\":"
		out.RawString(prefix)
		out.Int64(int64(in.PacketQueueLength))
	}
	if in.PacketReordering {
		const prefix string = ",\"packetReordering\":"
		out.RawString(prefix)
		out.Bool(bool(in.PacketReordering))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EmulateNetworkConditionsParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork84(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork85(in *jlexer.Lexer, out *DisableParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork85(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork85(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *DisableParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork85(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork86(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.UnsafeFieldName(false)
		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())
		case "partitionKey":
			out.PartitionKey = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork86(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))
	}
	if in.PartitionKey != "" {
		const prefix string = ",\"partitionKey\":"
		out.RawString(prefix)
		out.String(string(in.PartitionKey))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *DeleteCookiesParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork86(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork87(in *jlexer.Lexer, out *CrossOriginOpenerPolicyStatus) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "value":
			(out.Value).UnmarshalEasyJSON(in)
		case "reportOnlyValue":
			(out.ReportOnlyValue).UnmarshalEasyJSON(in)
		case "reportingEndpoint":
			out.ReportingEndpoint = string(in.String())
		case "reportOnlyReportingEndpoint":
			out.ReportOnlyReportingEndpoint = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork87(out *jwriter.Writer, in CrossOriginOpenerPolicyStatus) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"value\":"
		out.RawString(prefix[1:])
		(in.Value).MarshalEasyJSON(out)
	}
	{
		const prefix string = ",\"reportOnlyValue\":"
		out.RawString(prefix)
		(in.ReportOnlyValue).MarshalEasyJSON(out)
	}
	if in.ReportingEndpoint != "" {
		const prefix string = ",\"reportingEndpoint\":"
		out.RawString(prefix)
		out.String(string(in.ReportingEndpoint))
	}
	if in.ReportOnlyReportingEndpoint != "" {
		const prefix string = ",\"reportOnlyReportingEndpoint\":"
		out.RawString(prefix)
		out.String(string(in.ReportOnlyReportingEndpoint))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *CrossOriginOpenerPolicyStatus) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork87(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork88(in *jlexer.Lexer, out *CrossOriginEmbedderPolicyStatus) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "value":
			(out.Value).UnmarshalEasyJSON(in)
		case "reportOnlyValue":
			(out.ReportOnlyValue).UnmarshalEasyJSON(in)
		case "reportingEndpoint":
			out.ReportingEndpoint = string(in.String())
		case "reportOnlyReportingEndpoint":
			out.ReportOnlyReportingEndpoint = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork88(out *jwriter.Writer, in CrossOriginEmbedderPolicyStatus) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"value\":"
		out.RawString(prefix[1:])
		(in.Value).MarshalEasyJSON(out)
	}
	{
		const prefix string = ",\"reportOnlyValue\":"
		out.RawString(prefix)
		(in.ReportOnlyValue).MarshalEasyJSON(out)
	}
	if in.ReportingEndpoint != "" {
		const prefix string = ",\"reportingEndpoint\":"
		out.RawString(prefix)
		out.String(string(in.ReportingEndpoint))
	}
	if in.ReportOnlyReportingEndpoint != "" {
		const prefix string = ",\"reportOnlyReportingEndpoint\":"
		out.RawString(prefix)
		out.String(string(in.ReportOnlyReportingEndpoint))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *CrossOriginEmbedderPolicyStatus) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork88(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork89(in *jlexer.Lexer, out *CorsErrorStatus) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "corsError":
			(out.CorsError).UnmarshalEasyJSON(in)
		case "failedParameter":
			out.FailedParameter = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork89(out *jwriter.Writer, in CorsErrorStatus) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"corsError\":"
		out.RawString(prefix[1:])
		(in.CorsError).MarshalEasyJSON(out)
	}
	{
		const prefix string = ",\"failedParameter\":"
		out.RawString(prefix)
		out.String(string(in.FailedParameter))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *CorsErrorStatus) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork89(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork90(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.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "name":
			out.Name = string(in.String())
		case "value":
			out.Value = string(in.String())
		case "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)
		case "sameParty":
			out.SameParty = bool(in.Bool())
		case "sourceScheme":
			(out.SourceScheme).UnmarshalEasyJSON(in)
		case "sourcePort":
			out.SourcePort = int64(in.Int64())
		case "partitionKey":
			out.PartitionKey = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork90(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)
	}
	if in.SameParty {
		const prefix string = ",\"sameParty\":"
		out.RawString(prefix)
		out.Bool(bool(in.SameParty))
	}
	if in.SourceScheme != "" {
		const prefix string = ",\"sourceScheme\":"
		out.RawString(prefix)
		(in.SourceScheme).MarshalEasyJSON(out)
	}
	if in.SourcePort != 0 {
		const prefix string = ",\"sourcePort\":"
		out.RawString(prefix)
		out.Int64(int64(in.SourcePort))
	}
	if in.PartitionKey != "" {
		const prefix string = ",\"partitionKey\":"
		out.RawString(prefix)
		out.String(string(in.PartitionKey))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *CookieParam) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork90(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork91(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.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "name":
			out.Name = string(in.String())
		case "value":
			out.Value = string(in.String())
		case "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)
		case "sourceScheme":
			(out.SourceScheme).UnmarshalEasyJSON(in)
		case "sourcePort":
			out.SourcePort = int64(in.Int64())
		case "partitionKey":
			out.PartitionKey = string(in.String())
		case "partitionKeyOpaque":
			out.PartitionKeyOpaque = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork91(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)
	}
	{
		const prefix string = ",\"sourceScheme\":"
		out.RawString(prefix)
		(in.SourceScheme).MarshalEasyJSON(out)
	}
	{
		const prefix string = ",\"sourcePort\":"
		out.RawString(prefix)
		out.Int64(int64(in.SourcePort))
	}
	if in.PartitionKey != "" {
		const prefix string = ",\"partitionKey\":"
		out.RawString(prefix)
		out.String(string(in.PartitionKey))
	}
	if in.PartitionKeyOpaque {
		const prefix string = ",\"partitionKeyOpaque\":"
		out.RawString(prefix)
		out.Bool(bool(in.PartitionKeyOpaque))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *Cookie) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork91(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork92(in *jlexer.Lexer, out *ContentSecurityPolicyStatus) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "effectiveDirectives":
			out.EffectiveDirectives = string(in.String())
		case "isEnforced":
			out.IsEnforced = bool(in.Bool())
		case "source":
			(out.Source).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork92(out *jwriter.Writer, in ContentSecurityPolicyStatus) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"effectiveDirectives\":"
		out.RawString(prefix[1:])
		out.String(string(in.EffectiveDirectives))
	}
	{
		const prefix string = ",\"isEnforced\":"
		out.RawString(prefix)
		out.Bool(bool(in.IsEnforced))
	}
	{
		const prefix string = ",\"source\":"
		out.RawString(prefix)
		(in.Source).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

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

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *ConnectTiming) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork93(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork94(in *jlexer.Lexer, out *ClientSecurityState) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "initiatorIsSecureContext":
			out.InitiatorIsSecureContext = bool(in.Bool())
		case "initiatorIPAddressSpace":
			(out.InitiatorIPAddressSpace).UnmarshalEasyJSON(in)
		case "privateNetworkRequestPolicy":
			(out.PrivateNetworkRequestPolicy).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork94(out *jwriter.Writer, in ClientSecurityState) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"initiatorIsSecureContext\":"
		out.RawString(prefix[1:])
		out.Bool(bool(in.InitiatorIsSecureContext))
	}
	{
		const prefix string = ",\"initiatorIPAddressSpace\":"
		out.RawString(prefix)
		(in.InitiatorIPAddressSpace).MarshalEasyJSON(out)
	}
	{
		const prefix string = ",\"privateNetworkRequestPolicy\":"
		out.RawString(prefix)
		(in.PrivateNetworkRequestPolicy).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

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

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

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

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

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

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

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

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *ClearAcceptedEncodingsOverrideParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork97(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork98(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.UnsafeFieldName(false)
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork98(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork98(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *CachedResource) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork98(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork99(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.UnsafeFieldName(false)
		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 v85 SetCookieBlockedReason
					(v85).UnmarshalEasyJSON(in)
					out.BlockedReasons = append(out.BlockedReasons, v85)
					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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork99(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 v86, v87 := range in.BlockedReasons {
				if v86 > 0 {
					out.RawByte(',')
				}
				(v87).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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork99(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *BlockedSetCookieWithReason) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork99(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork100(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.UnsafeFieldName(false)
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork100(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork100(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *AuthChallengeResponse) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork100(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork101(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.UnsafeFieldName(false)
		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 easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork101(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork101(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *AuthChallenge) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork101(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoNetwork102(in *jlexer.Lexer, out *AssociatedCookie) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "cookie":
			if in.IsNull() {
				in.Skip()
				out.Cookie = nil
			} else {
				if out.Cookie == nil {
					out.Cookie = new(Cookie)
				}
				(*out.Cookie).UnmarshalEasyJSON(in)
			}
		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 v88 CookieBlockedReason
					(v88).UnmarshalEasyJSON(in)
					out.BlockedReasons = append(out.BlockedReasons, v88)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "exemptionReason":
			(out.ExemptionReason).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoNetwork102(out *jwriter.Writer, in AssociatedCookie) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"cookie\":"
		out.RawString(prefix[1:])
		if in.Cookie == nil {
			out.RawString("null")
		} else {
			(*in.Cookie).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"blockedReasons\":"
		out.RawString(prefix)
		if in.BlockedReasons == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v89, v90 := range in.BlockedReasons {
				if v89 > 0 {
					out.RawByte(',')
				}
				(v90).MarshalEasyJSON(out)
			}
			out.RawByte(']')
		}
	}
	if in.ExemptionReason != "" {
		const prefix string = ",\"exemptionReason\":"
		out.RawString(prefix)
		(in.ExemptionReason).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

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