@rozenite/network-activity-plugin 1.0.0-alpha.8 → 1.0.0-alpha.9

package/dist/assets/{App-R2ZMH9wJ.css → App-DoHQsY5s.css}

@@ -553,6 +553,9 @@ video {
 .z-10 {
   z-index: 10;
 }
+.-m-2 {
+  margin: -0.5rem;
+}
 .m-0 {
   margin: 0px;
 }
@@ -562,9 +565,18 @@ video {
 .mb-3 {
   margin-bottom: 0.75rem;
 }
+.ml-0 {
+  margin-left: 0px;
+}
+.ml-2 {
+  margin-left: 0.5rem;
+}
 .mt-2 {
   margin-top: 0.5rem;
 }
+.inline-block {
+  display: inline-block;
+}
 .flex {
   display: flex;
 }
@@ -613,6 +625,12 @@ video {
 .h-screen {
   height: 100vh;
 }
+.max-h-96 {
+  max-height: 24rem;
+}
+.min-h-0 {
+  min-height: 0px;
+}
 .w-1\/2 {
   width: 50%;
 }
@@ -649,12 +667,19 @@ video {
 .min-w-0 {
   min-width: 0px;
 }
+.max-w-xs {
+  max-width: 20rem;
+}
 .flex-1 {
   flex: 1 1 0%;
 }
 .shrink-0 {
   flex-shrink: 0;
 }
+.translate-y-0\.75 {
+  --tw-translate-y: 0.1875rem;
+  transform: translate(var(--tw-translate-x), var(--tw-translate-y)) rotate(var(--tw-rotate)) skewX(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y));
+}
 @keyframes spin {
 
   to {
@@ -712,6 +737,11 @@ video {
   margin-top: calc(0.5rem * calc(1 - var(--tw-space-y-reverse)));
   margin-bottom: calc(0.5rem * var(--tw-space-y-reverse));
 }
+.space-y-3 > :not([hidden]) ~ :not([hidden]) {
+  --tw-space-y-reverse: 0;
+  margin-top: calc(0.75rem * calc(1 - var(--tw-space-y-reverse)));
+  margin-bottom: calc(0.75rem * var(--tw-space-y-reverse));
+}
 .space-y-4 > :not([hidden]) ~ :not([hidden]) {
   --tw-space-y-reverse: 0;
   margin-top: calc(1rem * calc(1 - var(--tw-space-y-reverse)));
@@ -731,6 +761,9 @@ video {
 .overflow-x-auto {
   overflow-x: auto;
 }
+.overflow-y-auto {
+  overflow-y: auto;
+}
 .truncate {
   overflow: hidden;
   text-overflow: ellipsis;
@@ -961,6 +994,9 @@ video {
 .font-semibold {
   font-weight: 600;
 }
+.capitalize {
+  text-transform: capitalize;
+}
 .italic {
   font-style: italic;
 }
@@ -1057,6 +1093,9 @@ video {
 .underline-offset-4 {
   text-underline-offset: 4px;
 }
+.opacity-0 {
+  opacity: 0;
+}
 .outline {
   outline-style: solid;
 }
@@ -1149,6 +1188,10 @@ video {
   --tw-text-opacity: 1;
   color: rgb(243 244 246 / var(--tw-text-opacity, 1));
 }
+.hover\:text-gray-300:hover {
+  --tw-text-opacity: 1;
+  color: rgb(209 213 219 / var(--tw-text-opacity, 1));
+}
 .hover\:text-red-300:hover {
   --tw-text-opacity: 1;
   color: rgb(252 165 165 / var(--tw-text-opacity, 1));
@@ -1195,6 +1238,9 @@ video {
 .disabled\:opacity-50:disabled {
   opacity: 0.5;
 }
+.group:hover .group-hover\:opacity-100 {
+  opacity: 1;
+}
 .data-\[state\=active\]\:bg-background[data-state="active"] {
   background-color: hsl(var(--background));
 }

package/dist/event-source.cjs

@@ -0,0 +1,22 @@
+"use strict";
+const NOOP = () => {
+};
+const MOCK_EVENT_SOURCE = class {
+  constructor() {
+    this.open = NOOP;
+    this.close = NOOP;
+    this.addEventListener = NOOP;
+    this.removeEventListener = NOOP;
+    this.dispatch = NOOP;
+    this.removeAllEventListeners = NOOP;
+  }
+};
+const getEventSource = () => {
+  try {
+    const { default: EventSource } = require("react-native-sse");
+    return EventSource;
+  } catch {
+    return MOCK_EVENT_SOURCE;
+  }
+};
+exports.getEventSource = getEventSource;

package/dist/event-source.js

@@ -0,0 +1,23 @@
+const NOOP = () => {
+};
+const MOCK_EVENT_SOURCE = class {
+  constructor() {
+    this.open = NOOP;
+    this.close = NOOP;
+    this.addEventListener = NOOP;
+    this.removeEventListener = NOOP;
+    this.dispatch = NOOP;
+    this.removeAllEventListeners = NOOP;
+  }
+};
+const getEventSource = () => {
+  try {
+    const { default: EventSource } = require("react-native-sse");
+    return EventSource;
+  } catch {
+    return MOCK_EVENT_SOURCE;
+  }
+};
+export {
+  getEventSource as g
+};

package/dist/rozenite.json

@@ -1 +1 @@
-{"name":"@rozenite/network-activity-plugin","version":"1.0.0-alpha.7","description":"Network Activity for Rozenite.","panels":[{"name":"Network Activity","source":"/App.html"}]}
+{"name":"@rozenite/network-activity-plugin","version":"1.0.0-alpha.8","description":"Network Activity for Rozenite.","panels":[{"name":"Network Activity","source":"/App.html"}]}

package/dist/src/react-native/{network-inspector.d.ts → http/network-inspector.d.ts}

@@ -1,4 +1,4 @@
-import { NetworkActivityDevToolsClient } from '../shared/client';
+import { NetworkActivityDevToolsClient } from '../../shared/client';
 export type NetworkInspector = {
     enable: () => void;
     disable: () => void;

package/dist/src/react-native/sse/event-source.d.ts

@@ -0,0 +1,2 @@
+import { default as EventSource } from 'react-native-sse';
+export declare const getEventSource: () => typeof EventSource;

package/dist/src/react-native/sse/sse-inspector.d.ts

@@ -0,0 +1,9 @@
+import { SSEEventMap } from '../../shared/sse-events';
+export type SSEInspector = {
+    enable: () => void;
+    disable: () => void;
+    isEnabled: () => boolean;
+    dispose: () => void;
+    on: <TEventType extends keyof SSEEventMap>(event: TEventType, callback: (data: SSEEventMap[TEventType]) => void) => () => void;
+};
+export declare const getSSEInspector: () => SSEInspector;

package/dist/src/react-native/sse/sse-interceptor.d.ts

@@ -0,0 +1,36 @@
+import { default as EventSource, MessageEvent, ErrorEvent, OpenEvent, CloseEvent, TimeoutEvent, ExceptionEvent } from 'react-native-sse';
+export type SSEInterceptorConnectCallback = (url: string, request: EventSource) => void;
+export type SSEInterceptorMessageCallback = (event: MessageEvent, request: EventSource) => void;
+export type SSEInterceptorErrorCallback = (error: ErrorEvent | TimeoutEvent | ExceptionEvent, request: EventSource) => void;
+export type SSEInterceptorOpenEventCallback = (event: OpenEvent, request: EventSource) => void;
+export type SSEInterceptorCloseCallback = (event: CloseEvent, request: EventSource) => void;
+/**
+ * A network interceptor which monkey-patches EventSource open method
+ * to gather all SSE connections and events, in order to show their
+ * information in the Network Activity panel.
+ */
+export declare const SSEInterceptor: {
+    /**
+     * Invoked when EventSource.open() is called (connection attempt starting).
+     */
+    setConnectCallback(callback: SSEInterceptorConnectCallback): void;
+    /**
+     * Invoked when a message event is received.
+     */
+    setMessageCallback(callback: SSEInterceptorMessageCallback): void;
+    /**
+     * Invoked when an error event occurs.
+     */
+    setErrorCallback(callback: SSEInterceptorErrorCallback): void;
+    /**
+     * Invoked when the connection is successfully opened (open event fired).
+     */
+    setOpenEventCallback(callback: SSEInterceptorOpenEventCallback): void;
+    /**
+     * Invoked when the connection is closed.
+     */
+    setCloseCallback(callback: SSEInterceptorCloseCallback): void;
+    isInterceptorEnabled(): boolean;
+    enableInterception(): void;
+    disableInterception(): void;
+};

package/dist/src/react-native/sse/types.d.ts

@@ -0,0 +1,6 @@
+import { default as EventSource } from 'react-native-sse';
+export interface EventSourceWithInternals<E extends string = never> extends EventSource<E> {
+    url: string;
+    /** Used internally to mark the underlying XHR to skip it in XHR interceptor. */
+    _xhr?: XMLHttpRequest;
+}

package/dist/src/react-native/utils.d.ts

@@ -0,0 +1,6 @@
+type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+type LastOf<T> = UnionToIntersection<T extends unknown ? () => T : never> extends () => infer R ? R : never;
+type Push<T extends unknown[], V> = [...T, V];
+export type UnionToTuple<T, L = LastOf<T>> = [T] extends [never] ? [] : Push<UnionToTuple<Exclude<T, L>>, L>;
+export declare const getContentType: (request: XMLHttpRequest) => string;
+export {};

package/dist/src/react-native/websocket/websocket-inspector.d.ts

@@ -0,0 +1,9 @@
+import { WebSocketEventMap } from '../../shared/websocket-events';
+export type WebSocketInspector = {
+    enable: () => void;
+    disable: () => void;
+    isEnabled: () => boolean;
+    dispose: () => void;
+    on: <TEventType extends keyof WebSocketEventMap>(event: TEventType, callback: (data: WebSocketEventMap[TEventType]) => void) => () => void;
+};
+export declare const getWebSocketInspector: () => WebSocketInspector;

package/dist/src/react-native/websocket/websocket-interceptor.d.ts

@@ -0,0 +1,74 @@
+import { default as WebSocketInterceptor } from 'react-native/Libraries/WebSocket/WebSocketInterceptor';
+export interface WebSocketInterceptor {
+    /**
+     * Invoked when RCTWebSocketModule.close(...) is called.
+     */
+    setCloseCallback(callback: (code: number | null, reason: string | null, socketId: number) => void): void;
+    /**
+     * Invoked when RCTWebSocketModule.send(...) or sendBinary(...) is called.
+     */
+    setSendCallback(callback: (data: string, socketId: number) => void): void;
+    /**
+     * Invoked when RCTWebSocketModule.connect(...) is called.
+     */
+    setConnectCallback(callback: (url: string, protocols: string[] | null, options: string[], socketId: number) => void): void;
+    /**
+     * Invoked when event "websocketOpen" happens.
+     */
+    setOnOpenCallback(callback: (socketId: number) => void): void;
+    /**
+     * Invoked when event "websocketMessage" happens.
+     */
+    setOnMessageCallback(callback: (data: string, socketId: number) => void): void;
+    /**
+     * Invoked when event "websocketFailed" happens.
+     */
+    setOnErrorCallback(callback: (error: string, socketId: number) => void): void;
+    /**
+     * Invoked when event "websocketClosed" happens.
+     */
+    setOnCloseCallback(callback: (error: {
+        code: number;
+        reason?: string;
+    }, socketId: number) => void): void;
+    isInterceptorEnabled(): boolean;
+    enableInterception(): void;
+    disableInterception(): void;
+}
+export interface WebSocketInterceptorPreRN079 {
+    /**
+     * Invoked when RCTWebSocketModule.close(...) is called.
+     */
+    setCloseCallback(callback: (code: number | null, reason: string | null, socketId: number) => void): void;
+    /**
+     * Invoked when RCTWebSocketModule.send(...) or sendBinary(...) is called.
+     */
+    setSendCallback(callback: (data: string, socketId: number) => void): void;
+    /**
+     * Invoked when RCTWebSocketModule.connect(...) is called.
+     */
+    setConnectCallback(callback: (url: string, protocols: string[] | null, options: string[], socketId: number) => void): void;
+    /**
+     * Invoked when event "websocketOpen" happens.
+     */
+    setOnOpenCallback(callback: (socketId: number) => void): void;
+    /**
+     * Invoked when event "websocketMessage" happens.
+     */
+    setOnMessageCallback(callback: (socketId: number, data: string) => void): void;
+    /**
+     * Invoked when event "websocketFailed" happens.
+     */
+    setOnErrorCallback(callback: (socketId: number, error: string) => void): void;
+    /**
+     * Invoked when event "websocketClosed" happens.
+     */
+    setOnCloseCallback(callback: (socketId: number, error: {
+        code: number;
+        reason?: string;
+    }) => void): void;
+    isInterceptorEnabled(): boolean;
+    enableInterception(): void;
+    disableInterception(): void;
+}
+export declare const getWebSocketInterceptor: () => WebSocketInterceptor;

package/dist/src/shared/client.d.ts

@@ -1,10 +1,13 @@
 import { RozeniteDevToolsClient } from '@rozenite/plugin-bridge';
+import { WebSocketEventMap } from './websocket-events';
+import { SSEEventMap } from './sse-events';
 export type HttpHeaders = Record<string, string>;
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD';
 export type RequestId = string;
 export type Timestamp = number;
 export type Request = {
     url: string;
-    method: string;
+    method: HttpMethod;
     headers: HttpHeaders;
     postData?: string;
 };
@@ -61,5 +64,5 @@ export type NetworkActivityEventMap = {
         requestId: RequestId;
         body: string | null;
     };
-};
+} & WebSocketEventMap & SSEEventMap;
 export type NetworkActivityDevToolsClient = RozeniteDevToolsClient<NetworkActivityEventMap>;

package/dist/src/shared/sse-events.d.ts

@@ -0,0 +1,35 @@
+import { Response } from './client';
+export type SSEConnectionStatus = 'connecting' | 'open' | 'closed';
+export type SSERequestId = string;
+export type SSEOpenEvent = {
+    type: 'sse-open';
+    requestId: SSERequestId;
+    timestamp: number;
+    response: Response;
+};
+export type SSEMessageEvent = {
+    type: 'sse-message';
+    requestId: SSERequestId;
+    timestamp: number;
+    data: string;
+};
+export type SSEErrorEvent = {
+    type: 'sse-error';
+    requestId: SSERequestId;
+    timestamp: number;
+    error: {
+        type: 'error' | 'timeout' | 'exception';
+        message: string;
+    };
+};
+export type SSECloseEvent = {
+    type: 'sse-close';
+    requestId: SSERequestId;
+    timestamp: number;
+};
+export type SSEEvent = SSEOpenEvent | SSEMessageEvent | SSEErrorEvent | SSECloseEvent;
+export type SSEEventMap = {
+    [K in SSEEvent['type']]: Extract<SSEEvent, {
+        type: K;
+    }>;
+};

package/dist/src/shared/websocket-events.d.ts

@@ -0,0 +1,60 @@
+export type WebSocketMessageType = 'text' | 'binary';
+export type WebSocketConnectionStatus = 'connecting' | 'open' | 'closing' | 'closed';
+export type WebSocketConnectEvent = {
+    type: 'websocket-connect';
+    url: string;
+    socketId: number;
+    timestamp: number;
+    protocols: string[] | null;
+    options: string[];
+};
+export type WebSocketOpenEvent = {
+    type: 'websocket-open';
+    url: string;
+    socketId: number;
+    timestamp: number;
+};
+export type WebSocketCloseEvent = {
+    type: 'websocket-close';
+    url: string;
+    socketId: number;
+    timestamp: number;
+    code: number;
+    reason?: string;
+};
+export type WebSocketMessageSentEvent = {
+    type: 'websocket-message-sent';
+    url: string;
+    socketId: number;
+    timestamp: number;
+    data: string;
+    messageType: WebSocketMessageType;
+};
+export type WebSocketMessageReceivedEvent = {
+    type: 'websocket-message-received';
+    url: string;
+    socketId: number;
+    timestamp: number;
+    data: string;
+    messageType: WebSocketMessageType;
+};
+export type WebSocketErrorEvent = {
+    type: 'websocket-error';
+    url: string;
+    socketId: number;
+    timestamp: number;
+    error: string;
+};
+export type WebSocketConnectionStatusChangedEvent = {
+    type: 'websocket-connection-status-changed';
+    url: string;
+    socketId: number;
+    timestamp: number;
+    status: WebSocketConnectionStatus;
+};
+export type WebSocketEvent = WebSocketConnectEvent | WebSocketOpenEvent | WebSocketCloseEvent | WebSocketMessageSentEvent | WebSocketMessageReceivedEvent | WebSocketErrorEvent | WebSocketConnectionStatusChangedEvent;
+export type WebSocketEventMap = {
+    [K in WebSocketEvent['type']]: Extract<WebSocketEvent, {
+        type: K;
+    }>;
+};

package/dist/src/ui/components/Badge.d.ts

@@ -1,7 +1,7 @@
 import { VariantProps } from 'class-variance-authority';
 import * as React from 'react';
 declare const badgeVariants: (props?: ({
-    variant?: "default" | "secondary" | "destructive" | "outline" | null | undefined;
+    variant?: "default" | "destructive" | "outline" | "secondary" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 export interface BadgeProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {
 }

package/dist/src/ui/components/Button.d.ts

@@ -1,7 +1,7 @@
 import { VariantProps } from 'class-variance-authority';
 import * as React from 'react';
 declare const buttonVariants: (props?: ({
-    variant?: "default" | "secondary" | "destructive" | "outline" | "link" | "ghost" | null | undefined;
+    variant?: "default" | "destructive" | "outline" | "secondary" | "ghost" | "link" | null | undefined;
     size?: "default" | "sm" | "lg" | "icon" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {

package/dist/src/ui/components/JsonTreeCopyableItem.d.ts

@@ -0,0 +1,7 @@
+import { PropsWithChildren } from 'react';
+type JsonTreeCopyableItemProps = PropsWithChildren<{
+    getCopyableValue: () => string;
+    className?: string;
+}>;
+export declare const JsonTreeCopyableItem: ({ children, getCopyableValue, className }: JsonTreeCopyableItemProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/ui/components/RequestList.d.ts

@@ -1,31 +1,16 @@
-import { NetworkEntry } from '../types';
+import { ProcessedRequest } from '../state/model';
 import { RequestId } from '../../shared/client';
-import * as React from 'react';
 type NetworkRequest = {
-    id: string;
+    id: RequestId;
     name: string;
-    status: number;
+    status: string | number;
     method: string;
     domain: string;
     path: string;
     size: string;
     time: string;
     type: string;
-    initiator: string;
     startTime: string;
-    requestBody?: {
-        type: string;
-        data: string;
-    };
-    responseBody?: {
-        type: string;
-        data: string | null;
-    };
-};
-type RequestListProps = {
-    networkEntries: Map<RequestId, NetworkEntry>;
-    selectedRequestId: RequestId | null;
-    onRequestSelect: (requestId: RequestId) => void;
 };
 declare const formatSize: (bytes: number) => string;
 declare const formatDuration: (duration: number) => string;
@@ -35,11 +20,6 @@ declare const extractDomainAndPath: (url: string) => {
     path: string;
 };
 declare const generateName: (url: string) => string;
-declare const formatInitiator: (initiator: any) => string;
-declare const mapResourceType: (type: string) => string;
-declare const getTypeColor: (type: string) => string;
-declare const getStatusColor: (status: number) => "text-gray-400" | "text-green-400" | "text-yellow-400" | "text-red-400";
-declare const processNetworkEntries: (networkEntries: Map<RequestId, NetworkEntry>) => NetworkRequest[];
-export declare const RequestList: React.FC<RequestListProps>;
-export { formatSize, formatDuration, formatStartTime, extractDomainAndPath, generateName, formatInitiator, mapResourceType, getTypeColor, getStatusColor, processNetworkEntries, };
-export type { NetworkRequest };
+declare const processNetworkRequests: (processedRequests: ProcessedRequest[]) => NetworkRequest[];
+export declare const RequestList: () => import("react/jsx-runtime").JSX.Element;
+export { formatSize, formatDuration, formatStartTime, extractDomainAndPath, generateName, processNetworkRequests, };

package/dist/src/ui/components/SidePanel.d.ts

@@ -0,0 +1 @@
+export declare const SidePanel: () => import("react/jsx-runtime").JSX.Element | null;

package/dist/src/ui/components/Toolbar.d.ts

@@ -0,0 +1 @@
+export declare const Toolbar: () => import("react/jsx-runtime").JSX.Element;

package/dist/src/ui/hooks/useCopyToClipboard.d.ts

@@ -0,0 +1,4 @@
+export declare function useCopyToClipboard(): {
+    isCopied: boolean;
+    copy: (value: string) => Promise<void>;
+};

package/dist/src/ui/state/derived.d.ts

@@ -0,0 +1,5 @@
+import { NetworkActivityState } from './store';
+import { ProcessedRequest } from './model';
+export declare const getProcessedRequests: (obj: NetworkActivityState) => ProcessedRequest[];
+export declare const getSelectedRequest: (obj: NetworkActivityState) => import('./model').NetworkEntry | null;
+export declare const getRequestSummary: (requestId: string) => ((state: NetworkActivityState) => ProcessedRequest | null);

package/dist/src/ui/state/hooks.d.ts

@@ -0,0 +1,17 @@
+import { NetworkActivityState } from './store';
+export declare const useNetworkActivityStore: <T>(selector: (state: NetworkActivityState) => T) => T;
+export declare const useProcessedRequests: () => import('./model').ProcessedRequest[];
+export declare const useSelectedRequest: () => import('./model').NetworkEntry | null;
+export declare const useHasSelectedRequest: () => boolean;
+export declare const useSelectedRequestId: () => string | null;
+export declare const useIsRecording: () => boolean;
+export declare const useNetworkActivityActions: () => {
+    setRecording: (isRecording: boolean) => void;
+    setSelectedRequest: (requestId: import('../../shared/client').RequestId | null) => void;
+    clearRequests: () => void;
+};
+export declare const useNetworkActivityClientManagement: () => {
+    setupClient: (client: import('../../shared/client').NetworkActivityDevToolsClient) => void;
+    cleanupClient: () => void;
+};
+export declare const useWebSocketMessages: (requestId: string) => import('./model').WebSocketMessage[];

package/dist/src/ui/state/model.d.ts

@@ -0,0 +1,98 @@
+import { Initiator, ResourceType } from '../../shared/client';
+export type RequestId = string;
+export type Timestamp = number;
+export type SocketId = number;
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD';
+export type NetworkEntryType = 'http' | 'websocket' | 'sse';
+export type HttpData = {
+    type: string;
+    data: string;
+};
+export type HttpRequest = {
+    url: string;
+    method: HttpMethod;
+    headers: Record<string, string>;
+    body?: HttpData;
+};
+export type HttpResponse = {
+    url: string;
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    contentType: string;
+    size: number;
+    responseTime: Timestamp;
+    body?: HttpData;
+};
+export type HttpStatus = 'pending' | 'loading' | 'finished' | 'failed';
+export type HttpNetworkEntry = {
+    id: RequestId;
+    type: 'http';
+    timestamp: Timestamp;
+    duration?: number;
+    request: HttpRequest;
+    response?: HttpResponse;
+    status: HttpStatus;
+    error?: string;
+    canceled?: boolean;
+    ttfb?: number;
+    size?: number;
+    initiator?: Initiator;
+    resourceType?: ResourceType;
+};
+export type SSEMessage = {
+    id: string;
+    data: string;
+    timestamp: Timestamp;
+};
+export type SSEStatus = 'connecting' | 'open' | 'closed' | 'error';
+export type SSENetworkEntry = {
+    id: RequestId;
+    type: 'sse';
+    timestamp: Timestamp;
+    duration?: number;
+    request: HttpRequest;
+    response?: HttpResponse;
+    status: SSEStatus;
+    messages: SSEMessage[];
+    error?: string;
+    initiator?: Initiator;
+    resourceType?: ResourceType;
+};
+export type WebSocketConnection = {
+    url: string;
+    socketId: SocketId;
+    protocols?: string[];
+    options?: string[];
+};
+export type WebSocketMessage = {
+    id: string;
+    direction: 'sent' | 'received';
+    data: string;
+    messageType: 'text' | 'binary';
+    timestamp: Timestamp;
+};
+export type WebSocketStatus = 'connecting' | 'open' | 'closing' | 'closed' | 'error';
+export type WebSocketNetworkEntry = {
+    id: RequestId;
+    type: 'websocket';
+    timestamp: Timestamp;
+    duration?: number;
+    connection: WebSocketConnection;
+    status: WebSocketStatus;
+    error?: string;
+    closeCode?: number;
+    closeReason?: string;
+};
+export type NetworkEntry = HttpNetworkEntry | WebSocketNetworkEntry | SSENetworkEntry;
+export type ProcessedRequest = {
+    id: RequestId;
+    type: NetworkEntryType;
+    name: string;
+    status: HttpStatus | WebSocketStatus | SSEStatus;
+    timestamp: Timestamp;
+    duration?: number;
+    size?: number;
+    method: HttpMethod | 'WS' | 'SSE';
+    httpStatus?: number;
+};