network

type AuthChallenge struct {
	Source *string `json:"source,omitempty"` // Source of the authentication challenge.
	Origin string  `json:"origin"`           // Origin of the challenger.
	Scheme string  `json:"scheme"`           // The authentication scheme used, such as basic or digest
	Realm  string  `json:"realm"`            // The realm of the challenge. May be empty.
}

type AuthChallengeResponse struct {
	Response string  `json:"response"`           // The decision on what to do in response to the authorization challenge.  Default means deferring to the default behavior of the net stack, which will likely either the Cancel authentication or display a popup dialog box.
	Username *string `json:"username,omitempty"` // The username to provide, possibly empty. Should only be set if response is ProvideCredentials.
	Password *string `json:"password,omitempty"` // The password to provide, possibly empty. Should only be set if response is ProvideCredentials.
}

type BlockedReason int

type CachedResource struct {
	URL      string       `json:"url"`                // Resource URL. This is the url of the original network request.
	Type     ResourceType `json:"type"`               // Type of this resource.
	Response *Response    `json:"response,omitempty"` // Cached response data.
	BodySize float64      `json:"bodySize"`           // Cached response body size.
}

type CanClearBrowserCacheReply struct {
	Result bool `json:"result"` // True if browser cache can be cleared.
}

type CanClearBrowserCookiesReply struct {
	Result bool `json:"result"` // True if browser cookies can be cleared.
}

type CanEmulateNetworkConditionsReply struct {
	Result bool `json:"result"` // True if emulation of network conditions is supported.
}

type ConnectionType int

type ContinueInterceptedRequestArgs struct {
	InterceptionID        InterceptionID         `json:"interceptionId"`                  //
	ErrorReason           ErrorReason            `json:"errorReason,omitempty"`           // If set this causes the request to fail with the given reason. Must not be set in response to an authChallenge.
	RawResponse           *string                `json:"rawResponse,omitempty"`           // If set the requests completes using with the provided base64 encoded raw response, including HTTP status line and headers etc... Must not be set in response to an authChallenge.
	URL                   *string                `json:"url,omitempty"`                   // If set the request url will be modified in a way that's not observable by page. Must not be set in response to an authChallenge.
	Method                *string                `json:"method,omitempty"`                // If set this allows the request method to be overridden. Must not be set in response to an authChallenge.
	PostData              *string                `json:"postData,omitempty"`              // If set this allows postData to be set. Must not be set in response to an authChallenge.
	Headers               Headers                `json:"headers,omitempty"`               // If set this allows the request headers to be changed. Must not be set in response to an authChallenge.
	AuthChallengeResponse *AuthChallengeResponse `json:"authChallengeResponse,omitempty"` // Response to a requestIntercepted with an authChallenge. Must not be set otherwise.
}

type Cookie struct {
	Name     string         `json:"name"`               // Cookie name.
	Value    string         `json:"value"`              // Cookie value.
	Domain   string         `json:"domain"`             // Cookie domain.
	Path     string         `json:"path"`               // Cookie path.
	Expires  float64        `json:"expires"`            // Cookie expiration date as the number of seconds since the UNIX epoch.
	Size     int            `json:"size"`               // Cookie size.
	HTTPOnly bool           `json:"httpOnly"`           // True if cookie is http-only.
	Secure   bool           `json:"secure"`             // True if cookie is secure.
	Session  bool           `json:"session"`            // True in case of session cookie.
	SameSite CookieSameSite `json:"sameSite,omitempty"` // Cookie SameSite type.
}

type CookieSameSite int

type DataReceivedClient interface {
	// Recv calls RecvMsg on rpcc.Stream, blocks until the event is
	// triggered, context canceled or connection closed.
	Recv() (*DataReceivedReply, error)
	rpcc.Stream
}

type DataReceivedReply struct {
	RequestID         RequestID     `json:"requestId"`         // Request identifier.
	Timestamp         MonotonicTime `json:"timestamp"`         // Timestamp.
	DataLength        int           `json:"dataLength"`        // Data chunk length.
	EncodedDataLength int           `json:"encodedDataLength"` // Actual bytes received (might be less than dataLength for compressed encodings).
}

type DeleteCookieArgs struct {
	CookieName string `json:"cookieName"` // Name of the cookie to remove.
	URL        string `json:"url"`        // URL to match cooke domain and path.
}

type EmulateNetworkConditionsArgs struct {
	Offline            bool           `json:"offline"`                  // True to emulate internet disconnection.
	Latency            float64        `json:"latency"`                  // Additional latency (ms).
	DownloadThroughput float64        `json:"downloadThroughput"`       // Maximal aggregated download throughput.
	UploadThroughput   float64        `json:"uploadThroughput"`         // Maximal aggregated upload throughput.
	ConnectionType     ConnectionType `json:"connectionType,omitempty"` // Connection type if known.
}

type EnableArgs struct {
	MaxTotalBufferSize    *int `json:"maxTotalBufferSize,omitempty"`    // Buffer size in bytes to use when preserving network payloads (XHRs, etc).
	MaxResourceBufferSize *int `json:"maxResourceBufferSize,omitempty"` // Per-resource buffer size in bytes to use when preserving network payloads (XHRs, etc).
}

type ErrorReason int

type EventSourceMessageReceivedClient interface {
	// Recv calls RecvMsg on rpcc.Stream, blocks until the event is
	// triggered, context canceled or connection closed.
	Recv() (*EventSourceMessageReceivedReply, error)
	rpcc.Stream
}

type EventSourceMessageReceivedReply struct {
	RequestID RequestID     `json:"requestId"` // Request identifier.
	Timestamp MonotonicTime `json:"timestamp"` // Timestamp.
	EventName string        `json:"eventName"` // Message type.
	EventID   string        `json:"eventId"`   // Message identifier.
	Data      string        `json:"data"`      // Message content.
}

type GetAllCookiesReply struct {
	Cookies []Cookie `json:"cookies"` // Array of cookie objects.
}

type GetCertificateArgs struct {
	Origin string `json:"origin"` // Origin to get certificate for.
}

type GetCertificateReply struct {
	TableNames []string `json:"tableNames"` //
}

type GetCookiesArgs struct {
	URLs []string `json:"urls,omitempty"` // The list of URLs for which applicable cookies will be fetched
}

type GetCookiesReply struct {
	Cookies []Cookie `json:"cookies"` // Array of cookie objects.
}

type GetResponseBodyArgs struct {
	RequestID RequestID `json:"requestId"` // Identifier of the network request to get content for.
}

type GetResponseBodyReply struct {
	Body          string `json:"body"`          // Response body.
	Base64Encoded bool   `json:"base64Encoded"` // True, if content was sent as base64.
}

type Headers []byte

type Initiator struct {
	Type       string              `json:"type"`                 // Type of this initiator.
	Stack      *runtime.StackTrace `json:"stack,omitempty"`      // Initiator JavaScript stack trace, set for Script only.
	URL        *string             `json:"url,omitempty"`        // Initiator URL, set for Parser type or for Script type (when script is importing module).
	LineNumber *float64            `json:"lineNumber,omitempty"` // Initiator line number, set for Parser type or for Script type (when script is importing module) (0-based).
}

type InterceptionID string

type LoaderID string

type LoadingFailedClient interface {
	// Recv calls RecvMsg on rpcc.Stream, blocks until the event is
	// triggered, context canceled or connection closed.
	Recv() (*LoadingFailedReply, error)
	rpcc.Stream
}

type LoadingFailedReply struct {
	RequestID     RequestID     `json:"requestId"`               // Request identifier.
	Timestamp     MonotonicTime `json:"timestamp"`               // Timestamp.
	Type          ResourceType  `json:"type"`                    // Resource type.
	ErrorText     string        `json:"errorText"`               // User friendly error message.
	Canceled      *bool         `json:"canceled,omitempty"`      // True if loading was canceled.
	BlockedReason BlockedReason `json:"blockedReason,omitempty"` // The reason why loading was blocked, if any.
}

type LoadingFinishedClient interface {
	// Recv calls RecvMsg on rpcc.Stream, blocks until the event is
	// triggered, context canceled or connection closed.
	Recv() (*LoadingFinishedReply, error)
	rpcc.Stream
}

type LoadingFinishedReply struct {
	RequestID         RequestID     `json:"requestId"`         // Request identifier.
	Timestamp         MonotonicTime `json:"timestamp"`         // Timestamp.
	EncodedDataLength float64       `json:"encodedDataLength"` // Total number of bytes received for this request.
}

type MonotonicTime float64

type ReplayXHRArgs struct {
	RequestID RequestID `json:"requestId"` // Identifier of XHR to replay.
}

type Request struct {
	URL              string                     `json:"url"`                        // Request URL.
	Method           string                     `json:"method"`                     // HTTP request method.
	Headers          Headers                    `json:"headers"`                    // HTTP request headers.
	PostData         *string                    `json:"postData,omitempty"`         // HTTP POST request data.
	MixedContentType *security.MixedContentType `json:"mixedContentType,omitempty"` // The mixed content type of the request.
	InitialPriority  ResourcePriority           `json:"initialPriority"`            // Priority of the resource request at the time request is sent.
	ReferrerPolicy   string                     `json:"referrerPolicy"`             // The referrer policy of the request, as defined in https://www.w3.org/TR/referrer-policy/
	IsLinkPreload    *bool                      `json:"isLinkPreload,omitempty"`    // Whether is loaded via link preload.
}

type RequestID string

type RequestInterceptedClient interface {
	// Recv calls RecvMsg on rpcc.Stream, blocks until the event is
	// triggered, context canceled or connection closed.
	Recv() (*RequestInterceptedReply, error)
	rpcc.Stream
}

type RequestInterceptedReply struct {
	InterceptionID     InterceptionID `json:"interceptionId"`               // Each request the page makes will have a unique id, however if any redirects are encountered while processing that fetch, they will be reported with the same id as the original fetch. Likewise if HTTP authentication is needed then the same fetch id will be used.
	Request            Request        `json:"request"`                      //
	ResourceType       ResourceType   `json:"resourceType"`                 // How the requested resource will be used.
	RedirectHeaders    Headers        `json:"redirectHeaders,omitempty"`    // HTTP response headers, only sent if a redirect was intercepted.
	RedirectStatusCode *int           `json:"redirectStatusCode,omitempty"` // HTTP response code, only sent if a redirect was intercepted.
	RedirectURL        *string        `json:"redirectUrl,omitempty"`        // Redirect location, only sent if a redirect was intercepted.
	AuthChallenge      *AuthChallenge `json:"authChallenge,omitempty"`      // Details of the Authorization Challenge encountered. If this is set then continueInterceptedRequest must contain an authChallengeResponse.
}

type RequestServedFromCacheClient interface {
	// Recv calls RecvMsg on rpcc.Stream, blocks until the event is
	// triggered, context canceled or connection closed.
	Recv() (*RequestServedFromCacheReply, error)
	rpcc.Stream
}

type RequestServedFromCacheReply struct {
	RequestID RequestID `json:"requestId"` // Request identifier.
}

type RequestWillBeSentClient interface {
	// Recv calls RecvMsg on rpcc.Stream, blocks until the event is
	// triggered, context canceled or connection closed.
	Recv() (*RequestWillBeSentReply, error)
	rpcc.Stream
}

type RequestWillBeSentReply struct {
	RequestID        RequestID      `json:"requestId"`                  // Request identifier.
	LoaderID         LoaderID       `json:"loaderId"`                   // Loader identifier. Empty string if the request is fetched form worker.
	DocumentURL      string         `json:"documentURL"`                // URL of the document this request is loaded for.
	Request          Request        `json:"request"`                    // Request data.
	Timestamp        MonotonicTime  `json:"timestamp"`                  // Timestamp.
	WallTime         TimeSinceEpoch `json:"wallTime"`                   // Timestamp.
	Initiator        Initiator      `json:"initiator"`                  // Request initiator.
	RedirectResponse *Response      `json:"redirectResponse,omitempty"` // Redirect response data.
	Type             *ResourceType  `json:"type,omitempty"`             // Type of this resource.
	FrameID          *FrameID       `json:"frameId,omitempty"`          // Frame identifier.
}

type ResourceChangedPriorityClient interface {
	// Recv calls RecvMsg on rpcc.Stream, blocks until the event is
	// triggered, context canceled or connection closed.
	Recv() (*ResourceChangedPriorityReply, error)
	rpcc.Stream
}

type ResourceChangedPriorityReply struct {
	RequestID   RequestID        `json:"requestId"`   // Request identifier.
	NewPriority ResourcePriority `json:"newPriority"` // New priority
	Timestamp   MonotonicTime    `json:"timestamp"`   // Timestamp.
}

type ResourcePriority int

type ResourceTiming struct {
	RequestTime       float64 `json:"requestTime"`       // Timing's requestTime is a baseline in seconds, while the other numbers are ticks in milliseconds relatively to this requestTime.
	ProxyStart        float64 `json:"proxyStart"`        // Started resolving proxy.
	ProxyEnd          float64 `json:"proxyEnd"`          // Finished resolving proxy.
	DNSStart          float64 `json:"dnsStart"`          // Started DNS address resolve.
	DNSEnd            float64 `json:"dnsEnd"`            // Finished DNS address resolve.
	ConnectStart      float64 `json:"connectStart"`      // Started connecting to the remote host.
	ConnectEnd        float64 `json:"connectEnd"`        // Connected to the remote host.
	SslStart          float64 `json:"sslStart"`          // Started SSL handshake.
	SslEnd            float64 `json:"sslEnd"`            // Finished SSL handshake.
	WorkerStart       float64 `json:"workerStart"`       // Started running ServiceWorker.
	WorkerReady       float64 `json:"workerReady"`       // Finished Starting ServiceWorker.
	SendStart         float64 `json:"sendStart"`         // Started sending request.
	SendEnd           float64 `json:"sendEnd"`           // Finished sending request.
	PushStart         float64 `json:"pushStart"`         // Time the server started pushing request.
	PushEnd           float64 `json:"pushEnd"`           // Time the server finished pushing request.
	ReceiveHeadersEnd float64 `json:"receiveHeadersEnd"` // Finished receiving response headers.
}

type Response struct {
	URL                string           `json:"url"`                          // Response URL. This URL can be different from CachedResource.url in case of redirect.
	Status             float64          `json:"status"`                       // HTTP response status code.
	StatusText         string           `json:"statusText"`                   // HTTP response status text.
	Headers            Headers          `json:"headers"`                      // HTTP response headers.
	HeadersText        *string          `json:"headersText,omitempty"`        // HTTP response headers text.
	MimeType           string           `json:"mimeType"`                     // Resource mimeType as determined by the browser.
	RequestHeaders     Headers          `json:"requestHeaders,omitempty"`     // Refined HTTP request headers that were actually transmitted over the network.
	RequestHeadersText *string          `json:"requestHeadersText,omitempty"` // HTTP request headers text.
	ConnectionReused   bool             `json:"connectionReused"`             // Specifies whether physical connection was actually reused for this request.
	ConnectionID       float64          `json:"connectionId"`                 // Physical connection id that was actually used for this request.
	RemoteIPAddress    *string          `json:"remoteIPAddress,omitempty"`    // Remote IP address.
	RemotePort         *int             `json:"remotePort,omitempty"`         // Remote port.
	FromDiskCache      *bool            `json:"fromDiskCache,omitempty"`      // Specifies that the request was served from the disk cache.
	FromServiceWorker  *bool            `json:"fromServiceWorker,omitempty"`  // Specifies that the request was served from the ServiceWorker.
	EncodedDataLength  float64          `json:"encodedDataLength"`            // Total number of bytes received for this request so far.
	Timing             *ResourceTiming  `json:"timing,omitempty"`             // Timing information for the given request.
	Protocol           *string          `json:"protocol,omitempty"`           // Protocol used to fetch this request.
	SecurityState      security.State   `json:"securityState"`                // Security state of the request resource.
	SecurityDetails    *SecurityDetails `json:"securityDetails,omitempty"`    // Security details for the request.
}

type ResponseReceivedClient interface {
	// Recv calls RecvMsg on rpcc.Stream, blocks until the event is
	// triggered, context canceled or connection closed.
	Recv() (*ResponseReceivedReply, error)
	rpcc.Stream
}

type ResponseReceivedReply struct {
	RequestID RequestID     `json:"requestId"`         // Request identifier.
	LoaderID  LoaderID      `json:"loaderId"`          // Loader identifier. Empty string if the request is fetched form worker.
	Timestamp MonotonicTime `json:"timestamp"`         // Timestamp.
	Type      ResourceType  `json:"type"`              // Resource type.
	Response  Response      `json:"response"`          // Response data.
	FrameID   *FrameID      `json:"frameId,omitempty"` // Frame identifier.
}

type SecurityDetails struct {
	Protocol                       string                       `json:"protocol"`                       // Protocol name (e.g. "TLS 1.2" or "QUIC").
	KeyExchange                    string                       `json:"keyExchange"`                    // Key Exchange used by the connection, or the empty string if not applicable.
	KeyExchangeGroup               *string                      `json:"keyExchangeGroup,omitempty"`     // (EC)DH group used by the connection, if applicable.
	Cipher                         string                       `json:"cipher"`                         // Cipher name.
	Mac                            *string                      `json:"mac,omitempty"`                  // TLS MAC. Note that AEAD ciphers do not have separate MACs.
	CertificateID                  security.CertificateID       `json:"certificateId"`                  // Certificate ID value.
	SubjectName                    string                       `json:"subjectName"`                    // Certificate subject name.
	SanList                        []string                     `json:"sanList"`                        // Subject Alternative Name (SAN) DNS names and IP addresses.
	Issuer                         string                       `json:"issuer"`                         // Name of the issuing CA.
	ValidFrom                      TimeSinceEpoch               `json:"validFrom"`                      // Certificate valid from date.
	ValidTo                        TimeSinceEpoch               `json:"validTo"`                        // Certificate valid to (expiration) date
	SignedCertificateTimestampList []SignedCertificateTimestamp `json:"signedCertificateTimestampList"` // List of signed certificate timestamps (SCTs).
}

type SetBlockedURLsArgs struct {
	URLs []string `json:"urls"` // URL patterns to block. Wildcards ('*') are allowed.
}

type SetBypassServiceWorkerArgs struct {
	Bypass bool `json:"bypass"` // Bypass service worker and load from network.
}

type SetCacheDisabledArgs struct {
	CacheDisabled bool `json:"cacheDisabled"` // Cache disabled state.
}

type SetCookieArgs struct {
	URL            string         `json:"url"`                      // The request-URI to associate with the setting of the cookie. This value can affect the default domain and path values of the created cookie.
	Name           string         `json:"name"`                     // The name of the cookie.
	Value          string         `json:"value"`                    // The value of the cookie.
	Domain         *string        `json:"domain,omitempty"`         // If omitted, the cookie becomes a host-only cookie.
	Path           *string        `json:"path,omitempty"`           // Defaults to the path portion of the url parameter.
	Secure         *bool          `json:"secure,omitempty"`         // Defaults ot false.
	HTTPOnly       *bool          `json:"httpOnly,omitempty"`       // Defaults to false.
	SameSite       CookieSameSite `json:"sameSite,omitempty"`       // Defaults to browser default behavior.
	ExpirationDate TimeSinceEpoch `json:"expirationDate,omitempty"` // If omitted, the cookie becomes a session cookie.
}

type SetCookieReply struct {
	Success bool `json:"success"` // True if successfully set cookie.
}

type SetDataSizeLimitsForTestArgs struct {
	MaxTotalSize    int `json:"maxTotalSize"`    // Maximum total buffer size.
	MaxResourceSize int `json:"maxResourceSize"` // Maximum per-resource size.
}

type SetExtraHTTPHeadersArgs struct {
	Headers Headers `json:"headers"` // Map with extra HTTP headers.
}

type SetRequestInterceptionEnabledArgs struct {
	Enabled bool `json:"enabled"` // Whether or not HTTP requests should be intercepted and Network.requestIntercepted events sent.
}

type SetUserAgentOverrideArgs struct {
	UserAgent string `json:"userAgent"` // User agent to use.
}

type SignedCertificateTimestamp struct {
	Status             string         `json:"status"`             // Validation status.
	Origin             string         `json:"origin"`             // Origin.
	LogDescription     string         `json:"logDescription"`     // Log name / description.
	LogID              string         `json:"logId"`              // Log ID.
	Timestamp          TimeSinceEpoch `json:"timestamp"`          // Issuance date.
	HashAlgorithm      string         `json:"hashAlgorithm"`      // Hash algorithm.
	SignatureAlgorithm string         `json:"signatureAlgorithm"` // Signature algorithm.
	SignatureData      string         `json:"signatureData"`      // Signature data.
}

type TimeSinceEpoch float64

type WebSocketClosedClient interface {
	// Recv calls RecvMsg on rpcc.Stream, blocks until the event is
	// triggered, context canceled or connection closed.
	Recv() (*WebSocketClosedReply, error)
	rpcc.Stream
}

type WebSocketClosedReply struct {
	RequestID RequestID     `json:"requestId"` // Request identifier.
	Timestamp MonotonicTime `json:"timestamp"` // Timestamp.
}

type WebSocketCreatedClient interface {
	// Recv calls RecvMsg on rpcc.Stream, blocks until the event is
	// triggered, context canceled or connection closed.
	Recv() (*WebSocketCreatedReply, error)
	rpcc.Stream
}

type WebSocketCreatedReply struct {
	RequestID RequestID  `json:"requestId"`           // Request identifier.
	URL       string     `json:"url"`                 // WebSocket request URL.
	Initiator *Initiator `json:"initiator,omitempty"` // Request initiator.
}

type WebSocketFrame struct {
	Opcode      float64 `json:"opcode"`      // WebSocket frame opcode.
	Mask        bool    `json:"mask"`        // WebSocke frame mask.
	PayloadData string  `json:"payloadData"` // WebSocke frame payload data.
}

type WebSocketFrameErrorClient interface {
	// Recv calls RecvMsg on rpcc.Stream, blocks until the event is
	// triggered, context canceled or connection closed.
	Recv() (*WebSocketFrameErrorReply, error)
	rpcc.Stream
}

type WebSocketFrameErrorReply struct {
	RequestID    RequestID     `json:"requestId"`    // Request identifier.
	Timestamp    MonotonicTime `json:"timestamp"`    // Timestamp.
	ErrorMessage string        `json:"errorMessage"` // WebSocket frame error message.
}

type WebSocketFrameReceivedClient interface {
	// Recv calls RecvMsg on rpcc.Stream, blocks until the event is
	// triggered, context canceled or connection closed.
	Recv() (*WebSocketFrameReceivedReply, error)
	rpcc.Stream
}

type WebSocketFrameReceivedReply struct {
	RequestID RequestID      `json:"requestId"` // Request identifier.
	Timestamp MonotonicTime  `json:"timestamp"` // Timestamp.
	Response  WebSocketFrame `json:"response"`  // WebSocket response data.
}

type WebSocketFrameSentClient interface {
	// Recv calls RecvMsg on rpcc.Stream, blocks until the event is
	// triggered, context canceled or connection closed.
	Recv() (*WebSocketFrameSentReply, error)
	rpcc.Stream
}

type WebSocketFrameSentReply struct {
	RequestID RequestID      `json:"requestId"` // Request identifier.
	Timestamp MonotonicTime  `json:"timestamp"` // Timestamp.
	Response  WebSocketFrame `json:"response"`  // WebSocket response data.
}

type WebSocketHandshakeResponseReceivedClient interface {
	// Recv calls RecvMsg on rpcc.Stream, blocks until the event is
	// triggered, context canceled or connection closed.
	Recv() (*WebSocketHandshakeResponseReceivedReply, error)
	rpcc.Stream
}

type WebSocketHandshakeResponseReceivedReply struct {
	RequestID RequestID         `json:"requestId"` // Request identifier.
	Timestamp MonotonicTime     `json:"timestamp"` // Timestamp.
	Response  WebSocketResponse `json:"response"`  // WebSocket response data.
}

type WebSocketRequest struct {
	Headers Headers `json:"headers"` // HTTP request headers.
}

type WebSocketResponse struct {
	Status             float64 `json:"status"`                       // HTTP response status code.
	StatusText         string  `json:"statusText"`                   // HTTP response status text.
	Headers            Headers `json:"headers"`                      // HTTP response headers.
	HeadersText        *string `json:"headersText,omitempty"`        // HTTP response headers text.
	RequestHeaders     Headers `json:"requestHeaders,omitempty"`     // HTTP request headers.
	RequestHeadersText *string `json:"requestHeadersText,omitempty"` // HTTP request headers text.
}

type WebSocketWillSendHandshakeRequestClient interface {
	// Recv calls RecvMsg on rpcc.Stream, blocks until the event is
	// triggered, context canceled or connection closed.
	Recv() (*WebSocketWillSendHandshakeRequestReply, error)
	rpcc.Stream
}

type WebSocketWillSendHandshakeRequestReply struct {
	RequestID RequestID        `json:"requestId"` // Request identifier.
	Timestamp MonotonicTime    `json:"timestamp"` // Timestamp.
	WallTime  TimeSinceEpoch   `json:"wallTime"`  // UTC Timestamp.
	Request   WebSocketRequest `json:"request"`   // WebSocket request data.
}