import { AgentToolContract } from '@rozenite/agent-shared';
import { AgentToolDescriptor } from '@rozenite/agent-shared';

export declare type Cookie = {
    name: string;
    value: string;
    domain?: string;
    path?: string;
    expires?: string;
    maxAge?: string;
    secure?: boolean;
    httpOnly?: boolean;
    sameSite?: string;
};

declare const createNetworkActivityAgentState: () => {
    startRecording(metadata?: Partial<RecordingMetadata>): {
        recording: {
            isRecording: boolean;
            startedAt: number | null;
            stoppedAt: number | null;
            httpRequestCount: number;
            realtimeConnectionCount: number;
            http: {
                totalRecorded: number;
                evictedCount: number;
                truncated: boolean;
                capacity: number;
            };
            realtime: {
                totalRecorded: number;
                evictedCount: number;
                truncated: boolean;
                capacity: number;
            };
            generation: number;
            enabledInspectors: {
                http: boolean;
                websocket: boolean;
                sse: boolean;
            };
        };
    };
    stopRecording(): {
        recording: {
            isRecording: boolean;
            startedAt: number | null;
            stoppedAt: number | null;
            httpRequestCount: number;
            realtimeConnectionCount: number;
            http: {
                totalRecorded: number;
                evictedCount: number;
                truncated: boolean;
                capacity: number;
            };
            realtime: {
                totalRecorded: number;
                evictedCount: number;
                truncated: boolean;
                capacity: number;
            };
            generation: number;
            enabledInspectors: {
                http: boolean;
                websocket: boolean;
                sse: boolean;
            };
        };
    };
    getStatus: () => {
        recording: {
            isRecording: boolean;
            startedAt: number | null;
            stoppedAt: number | null;
            httpRequestCount: number;
            realtimeConnectionCount: number;
            http: {
                totalRecorded: number;
                evictedCount: number;
                truncated: boolean;
                capacity: number;
            };
            realtime: {
                totalRecorded: number;
                evictedCount: number;
                truncated: boolean;
                capacity: number;
            };
            generation: number;
            enabledInspectors: {
                http: boolean;
                websocket: boolean;
                sse: boolean;
            };
        };
    };
    getHttpRecord(requestId: string): HttpAgentRecord | null;
    getRealtimeRecord(requestId: string): RealtimeAgentRecord | null;
    listRequests(input: {
        limit?: number;
        cursor?: string;
    }): {
        items: {
            requestId: string;
            method: HttpMethod;
            url: string;
            status: number | null;
            type: ResourceType;
            startTimeMs: number;
            endTimeMs: number | null;
            durationMs: number | null;
            transferSize: number | null;
            encodedDataLength: number | null;
            outcome: string;
        }[];
        page: {
            limit: number;
            hasMore: boolean;
            nextCursor?: string;
        };
        recording: {
            isRecording: boolean;
            startedAt: number | null;
            stoppedAt: number | null;
            httpRequestCount: number;
            realtimeConnectionCount: number;
            http: {
                totalRecorded: number;
                evictedCount: number;
                truncated: boolean;
                capacity: number;
            };
            realtime: {
                totalRecorded: number;
                evictedCount: number;
                truncated: boolean;
                capacity: number;
            };
            generation: number;
            enabledInspectors: {
                http: boolean;
                websocket: boolean;
                sse: boolean;
            };
        };
    };
    listRealtimeConnections(input: {
        limit?: number;
        cursor?: string;
    }): {
        items: ({
            requestId: string;
            kind: "websocket";
            url: string;
            status: "connecting" | "open" | "closing" | "closed" | "error";
            startedAt: number;
            endedAt: number | null;
            durationMs: number | null;
            messageCount: number;
            error: string | null;
            closeCode: number | null;
            httpStatus?: undefined;
        } | {
            requestId: string;
            kind: "sse";
            url: string | null;
            status: "connecting" | "open" | "closed" | "error";
            startedAt: number;
            endedAt: number | null;
            durationMs: number | null;
            messageCount: number;
            error: string | null;
            httpStatus: number | null;
            closeCode?: undefined;
        })[];
        page: {
            limit: number;
            hasMore: boolean;
            nextCursor?: string;
        };
        recording: {
            isRecording: boolean;
            startedAt: number | null;
            stoppedAt: number | null;
            httpRequestCount: number;
            realtimeConnectionCount: number;
            http: {
                totalRecorded: number;
                evictedCount: number;
                truncated: boolean;
                capacity: number;
            };
            realtime: {
                totalRecorded: number;
                evictedCount: number;
                truncated: boolean;
                capacity: number;
            };
            generation: number;
            enabledInspectors: {
                http: boolean;
                websocket: boolean;
                sse: boolean;
            };
        };
    };
    getRequestDetails(requestId: string): {
        request: {
            requestId: string;
            method: HttpMethod;
            url: string;
            type: ResourceType;
            initiator: Initiator;
            startTimeMs: number;
            endTimeMs: number | null;
            durationMs: number | null;
            request: Request_2;
            response: Response_2 | null;
            loadingFinished: boolean;
            loadingFailed: boolean;
            failureText: string | null;
            canceled: boolean;
            progress: {
                loaded: number;
                total: number;
                lengthComputable: boolean;
            } | null;
            ttfb: number | null;
            size: number | null;
        };
        recording: {
            isRecording: boolean;
            startedAt: number | null;
            stoppedAt: number | null;
            httpRequestCount: number;
            realtimeConnectionCount: number;
            http: {
                totalRecorded: number;
                evictedCount: number;
                truncated: boolean;
                capacity: number;
            };
            realtime: {
                totalRecorded: number;
                evictedCount: number;
                truncated: boolean;
                capacity: number;
            };
            generation: number;
            enabledInspectors: {
                http: boolean;
                websocket: boolean;
                sse: boolean;
            };
        };
    };
    getRealtimeConnectionDetails(requestId: string): {
        connection: {
            requestId: string;
            kind: "websocket";
            url: string;
            socketId: string;
            status: "connecting" | "open" | "closing" | "closed" | "error";
            startedAt: number;
            endedAt: number | null;
            durationMs: number | null;
            protocols: string[] | null;
            options: string[];
            error: string | null;
            closeCode: number | null;
            closeReason: string | null;
            messages: WebSocketAgentMessage[];
            request?: undefined;
            response?: undefined;
            initiator?: undefined;
            resourceType?: undefined;
        } | {
            requestId: string;
            kind: "sse";
            status: "connecting" | "open" | "closed" | "error";
            startedAt: number;
            endedAt: number | null;
            durationMs: number | null;
            request: Request_2 | null;
            response: Response_2 | null;
            initiator: Initiator | null;
            resourceType: ResourceType | null;
            error: string | null;
            messages: SSEAgentMessage[];
            url?: undefined;
            socketId?: undefined;
            protocols?: undefined;
            options?: undefined;
            closeCode?: undefined;
            closeReason?: undefined;
        };
        recording: {
            isRecording: boolean;
            startedAt: number | null;
            stoppedAt: number | null;
            httpRequestCount: number;
            realtimeConnectionCount: number;
            http: {
                totalRecorded: number;
                evictedCount: number;
                truncated: boolean;
                capacity: number;
            };
            realtime: {
                totalRecorded: number;
                evictedCount: number;
                truncated: boolean;
                capacity: number;
            };
            generation: number;
            enabledInspectors: {
                http: boolean;
                websocket: boolean;
                sse: boolean;
            };
        };
    };
    getRequestBody(requestId: string): NetworkActivityAgentBodyResult;
    onRequestSent(event: HttpEventMap["request-sent"]): void;
    onRequestProgress(event: HttpEventMap["request-progress"]): void;
    onResponseReceived(event: HttpEventMap["response-received"]): void;
    onRequestCompleted(event: HttpEventMap["request-completed"]): void;
    onRequestFailed(event: HttpEventMap["request-failed"]): void;
    onWebSocketConnect(event: WebSocketEventMap_2["websocket-connect"]): void;
    onWebSocketOpen(event: WebSocketEventMap_2["websocket-open"]): void;
    onWebSocketClose(event: WebSocketEventMap_2["websocket-close"]): void;
    onWebSocketMessageSent(event: WebSocketEventMap_2["websocket-message-sent"]): void;
    onWebSocketMessageReceived(event: WebSocketEventMap_2["websocket-message-received"]): void;
    onWebSocketError(event: WebSocketEventMap_2["websocket-error"]): void;
    onWebSocketConnectionStatusChanged(event: WebSocketEventMap_2["websocket-connection-status-changed"]): void;
    onSSEOpen(event: SSEEventMap["sse-open"]): void;
    onSSEMessage(event: SSEEventMap["sse-message"]): void;
    onSSEError(event: SSEEventMap["sse-error"]): void;
    onSSEClose(event: SSEEventMap["sse-close"]): void;
};

declare type HttpAgentRecord = {
    requestId: RequestId;
    request: Request_2;
    resourceType: ResourceType;
    initiator: Initiator;
    startTimeMs: number;
    status: 'pending' | 'loading' | 'finished' | 'failed';
    progress?: HttpEventMap['request-progress'];
    response?: Response_2;
    endTimeMs?: number;
    durationMs?: number;
    size?: number | null;
    ttfb?: number;
    error?: string;
    canceled?: boolean;
};

declare type HttpEventMap = {
    'request-sent': {
        requestId: RequestId;
        request: Request_2;
        timestamp: Timestamp;
        initiator: Initiator;
        type: ResourceType;
        source?: NetworkEventSource;
    };
    'response-received': {
        requestId: RequestId;
        timestamp: Timestamp;
        type: ResourceType;
        response: Response_2;
        source?: NetworkEventSource;
    };
    'request-completed': {
        requestId: RequestId;
        timestamp: Timestamp;
        duration: number;
        size: number | null;
        ttfb: number;
        source?: NetworkEventSource;
    };
    'request-failed': {
        requestId: RequestId;
        timestamp: Timestamp;
        type: ResourceType;
        error: string;
        canceled: boolean;
        source?: NetworkEventSource;
    };
    'request-progress': {
        requestId: RequestId;
        timestamp: Timestamp;
        loaded: number;
        total: number;
        lengthComputable: boolean;
        source?: NetworkEventSource;
    };
    'get-response-body': {
        requestId: RequestId;
    };
    'response-body': {
        requestId: RequestId;
        body: ResponseBody;
    };
    'set-overrides': {
        overrides: [string, RequestOverride][];
    };
};

export declare type HttpHeaders = Record<string, string | string[]>;

export declare type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD';

export declare type Initiator = {
    type: string;
    symbolicationStatus?: 'pending' | 'complete' | 'failed' | 'unavailable';
    symbolicationError?: string;
    functionName?: string;
    url?: string;
    lineNumber?: number;
    columnNumber?: number;
    generatedUrl?: string;
    generatedLineNumber?: number;
    generatedColumnNumber?: number;
    codeFrame?: InitiatorCodeFrame | null;
    stack?: InitiatorStackFrame[];
};

declare type InitiatorCodeFrame = {
    content: string;
    fileName: string;
    location?: {
        row: number;
        column: number;
    } | null;
};

declare type InitiatorStackFrame = {
    functionName?: string;
    url?: string;
    lineNumber?: number;
    columnNumber?: number;
    generatedUrl?: string;
    generatedLineNumber?: number;
    generatedColumnNumber?: number;
    isCollapsed?: boolean;
};

export declare const NETWORK_ACTIVITY_AGENT_PLUGIN_ID = "@rozenite/network-activity-plugin";

export declare type NetworkActivityAgentBodyResult = {
    requestId: string;
    available: boolean;
    body?: string;
    base64Encoded?: boolean;
    decoded?: boolean;
    mimeType?: string;
    reason?: string;
};

export declare type NetworkActivityAgentState = ReturnType<typeof createNetworkActivityAgentState>;

export declare type NetworkActivityGetRealtimeConnectionDetailsArgs = NetworkActivityRequestIdArgs;

export declare type NetworkActivityGetRealtimeConnectionDetailsResult = ReturnType<NetworkActivityAgentState['getRealtimeConnectionDetails']>;

export declare type NetworkActivityGetRecordingStatusArgs = undefined;

export declare type NetworkActivityGetRecordingStatusResult = ReturnType<NetworkActivityAgentState['getStatus']>;

export declare type NetworkActivityGetRequestBodyArgs = NetworkActivityRequestIdArgs;

export declare type NetworkActivityGetRequestBodyResult = NetworkActivityAgentBodyResult;

export declare type NetworkActivityGetRequestDetailsArgs = NetworkActivityRequestIdArgs;

export declare type NetworkActivityGetRequestDetailsResult = ReturnType<NetworkActivityAgentState['getRequestDetails']>;

export declare type NetworkActivityGetResponseBodyArgs = NetworkActivityRequestIdArgs;

export declare type NetworkActivityGetResponseBodyResult = NetworkActivityAgentBodyResult;

export declare type NetworkActivityListRealtimeConnectionsArgs = NetworkActivityPaginationArgs;

export declare type NetworkActivityListRealtimeConnectionsResult = ReturnType<NetworkActivityAgentState['listRealtimeConnections']>;

export declare type NetworkActivityListRequestsArgs = NetworkActivityPaginationArgs;

export declare type NetworkActivityListRequestsResult = ReturnType<NetworkActivityAgentState['listRequests']>;

export declare type NetworkActivityPaginationArgs = {
    limit?: number;
    cursor?: string;
};

export declare type NetworkActivityRequestIdArgs = {
    requestId: string;
};

export declare type NetworkActivityStartRecordingArgs = undefined;

export declare type NetworkActivityStartRecordingResult = NetworkActivityGetRecordingStatusResult & {
    started: true;
};

export declare type NetworkActivityStopRecordingArgs = undefined;

export declare type NetworkActivityStopRecordingResult = NetworkActivityGetRecordingStatusResult & {
    stopped: true;
};

export declare const networkActivityToolDefinitions: {
    readonly startRecording: AgentToolContract<undefined, NetworkActivityStartRecordingResult>;
    readonly stopRecording: AgentToolContract<undefined, NetworkActivityStopRecordingResult>;
    readonly getRecordingStatus: AgentToolContract<undefined, {
        recording: {
            isRecording: boolean;
            startedAt: number | null;
            stoppedAt: number | null;
            httpRequestCount: number;
            realtimeConnectionCount: number;
            http: {
                totalRecorded: number;
                evictedCount: number;
                truncated: boolean;
                capacity: number;
            };
            realtime: {
                totalRecorded: number;
                evictedCount: number;
                truncated: boolean;
                capacity: number;
            };
            generation: number;
            enabledInspectors: {
                http: boolean;
                websocket: boolean;
                sse: boolean;
            };
        };
    }>;
    readonly listRequests: AgentToolContract<NetworkActivityPaginationArgs, {
        items: {
            requestId: string;
            method: HttpMethod;
            url: string;
            status: number | null;
            type: ResourceType;
            startTimeMs: number;
            endTimeMs: number | null;
            durationMs: number | null;
            transferSize: number | null;
            encodedDataLength: number | null;
            outcome: string;
        }[];
        page: {
            limit: number;
            hasMore: boolean;
            nextCursor?: string;
        };
        recording: {
            isRecording: boolean;
            startedAt: number | null;
            stoppedAt: number | null;
            httpRequestCount: number;
            realtimeConnectionCount: number;
            http: {
                totalRecorded: number;
                evictedCount: number;
                truncated: boolean;
                capacity: number;
            };
            realtime: {
                totalRecorded: number;
                evictedCount: number;
                truncated: boolean;
                capacity: number;
            };
            generation: number;
            enabledInspectors: {
                http: boolean;
                websocket: boolean;
                sse: boolean;
            };
        };
    }>;
    readonly getRequestDetails: AgentToolContract<NetworkActivityRequestIdArgs, {
        request: {
            requestId: string;
            method: HttpMethod;
            url: string;
            type: ResourceType;
            initiator: Initiator;
            startTimeMs: number;
            endTimeMs: number | null;
            durationMs: number | null;
            request: Request_2;
            response: Response_2 | null;
            loadingFinished: boolean;
            loadingFailed: boolean;
            failureText: string | null;
            canceled: boolean;
            progress: {
                loaded: number;
                total: number;
                lengthComputable: boolean;
            } | null;
            ttfb: number | null;
            size: number | null;
        };
        recording: {
            isRecording: boolean;
            startedAt: number | null;
            stoppedAt: number | null;
            httpRequestCount: number;
            realtimeConnectionCount: number;
            http: {
                totalRecorded: number;
                evictedCount: number;
                truncated: boolean;
                capacity: number;
            };
            realtime: {
                totalRecorded: number;
                evictedCount: number;
                truncated: boolean;
                capacity: number;
            };
            generation: number;
            enabledInspectors: {
                http: boolean;
                websocket: boolean;
                sse: boolean;
            };
        };
    }>;
    readonly getRequestBody: AgentToolContract<NetworkActivityRequestIdArgs, NetworkActivityAgentBodyResult>;
    readonly getResponseBody: AgentToolContract<NetworkActivityRequestIdArgs, NetworkActivityAgentBodyResult>;
    readonly listRealtimeConnections: AgentToolContract<NetworkActivityPaginationArgs, {
        items: ({
            requestId: string;
            kind: "websocket";
            url: string;
            status: "connecting" | "open" | "closing" | "closed" | "error";
            startedAt: number;
            endedAt: number | null;
            durationMs: number | null;
            messageCount: number;
            error: string | null;
            closeCode: number | null;
            httpStatus?: undefined;
        } | {
            requestId: string;
            kind: "sse";
            url: string | null;
            status: "connecting" | "open" | "closed" | "error";
            startedAt: number;
            endedAt: number | null;
            durationMs: number | null;
            messageCount: number;
            error: string | null;
            httpStatus: number | null;
            closeCode?: undefined;
        })[];
        page: {
            limit: number;
            hasMore: boolean;
            nextCursor?: string;
        };
        recording: {
            isRecording: boolean;
            startedAt: number | null;
            stoppedAt: number | null;
            httpRequestCount: number;
            realtimeConnectionCount: number;
            http: {
                totalRecorded: number;
                evictedCount: number;
                truncated: boolean;
                capacity: number;
            };
            realtime: {
                totalRecorded: number;
                evictedCount: number;
                truncated: boolean;
                capacity: number;
            };
            generation: number;
            enabledInspectors: {
                http: boolean;
                websocket: boolean;
                sse: boolean;
            };
        };
    }>;
    readonly getRealtimeConnectionDetails: AgentToolContract<NetworkActivityRequestIdArgs, {
        connection: {
            requestId: string;
            kind: "websocket";
            url: string;
            socketId: string;
            status: "connecting" | "open" | "closing" | "closed" | "error";
            startedAt: number;
            endedAt: number | null;
            durationMs: number | null;
            protocols: string[] | null;
            options: string[];
            error: string | null;
            closeCode: number | null;
            closeReason: string | null;
            messages: {
                id: string;
                direction: "sent" | "received";
                data: string;
                messageType: "text" | "binary";
                timestamp: number;
            }[];
            request?: undefined;
            response?: undefined;
            initiator?: undefined;
            resourceType?: undefined;
        } | {
            requestId: string;
            kind: "sse";
            status: "connecting" | "open" | "closed" | "error";
            startedAt: number;
            endedAt: number | null;
            durationMs: number | null;
            request: Request_2 | null;
            response: Response_2 | null;
            initiator: Initiator | null;
            resourceType: ResourceType | null;
            error: string | null;
            messages: {
                id: string;
                type: string;
                data: string;
                timestamp: number;
            }[];
            url?: undefined;
            socketId?: undefined;
            protocols?: undefined;
            options?: undefined;
            closeCode?: undefined;
            closeReason?: undefined;
        };
        recording: {
            isRecording: boolean;
            startedAt: number | null;
            stoppedAt: number | null;
            httpRequestCount: number;
            realtimeConnectionCount: number;
            http: {
                totalRecorded: number;
                evictedCount: number;
                truncated: boolean;
                capacity: number;
            };
            realtime: {
                totalRecorded: number;
                evictedCount: number;
                truncated: boolean;
                capacity: number;
            };
            generation: number;
            enabledInspectors: {
                http: boolean;
                websocket: boolean;
                sse: boolean;
            };
        };
    }>;
};

export declare const networkActivityTools: {
    readonly startRecording: AgentToolDescriptor<undefined, NetworkActivityStartRecordingResult>;
    readonly stopRecording: AgentToolDescriptor<undefined, NetworkActivityStopRecordingResult>;
    readonly getRecordingStatus: AgentToolDescriptor<undefined, {
    recording: {
    isRecording: boolean;
    startedAt: number | null;
    stoppedAt: number | null;
    httpRequestCount: number;
    realtimeConnectionCount: number;
    http: {
    totalRecorded: number;
    evictedCount: number;
    truncated: boolean;
    capacity: number;
    };
    realtime: {
    totalRecorded: number;
    evictedCount: number;
    truncated: boolean;
    capacity: number;
    };
    generation: number;
    enabledInspectors: {
    http: boolean;
    websocket: boolean;
    sse: boolean;
    };
    };
    }>;
    readonly listRequests: AgentToolDescriptor<NetworkActivityPaginationArgs, {
    items: {
    requestId: string;
    method: HttpMethod;
    url: string;
    status: number | null;
    type: ResourceType;
    startTimeMs: number;
    endTimeMs: number | null;
    durationMs: number | null;
    transferSize: number | null;
    encodedDataLength: number | null;
    outcome: string;
    }[];
    page: {
    limit: number;
    hasMore: boolean;
    nextCursor?: string;
    };
    recording: {
    isRecording: boolean;
    startedAt: number | null;
    stoppedAt: number | null;
    httpRequestCount: number;
    realtimeConnectionCount: number;
    http: {
    totalRecorded: number;
    evictedCount: number;
    truncated: boolean;
    capacity: number;
    };
    realtime: {
    totalRecorded: number;
    evictedCount: number;
    truncated: boolean;
    capacity: number;
    };
    generation: number;
    enabledInspectors: {
    http: boolean;
    websocket: boolean;
    sse: boolean;
    };
    };
    }>;
    readonly getRequestDetails: AgentToolDescriptor<NetworkActivityRequestIdArgs, {
    request: {
    requestId: string;
    method: HttpMethod;
    url: string;
    type: ResourceType;
    initiator: Initiator;
    startTimeMs: number;
    endTimeMs: number | null;
    durationMs: number | null;
    request: Request_2;
    response: Response_2 | null;
    loadingFinished: boolean;
    loadingFailed: boolean;
    failureText: string | null;
    canceled: boolean;
    progress: {
    loaded: number;
    total: number;
    lengthComputable: boolean;
    } | null;
    ttfb: number | null;
    size: number | null;
    };
    recording: {
    isRecording: boolean;
    startedAt: number | null;
    stoppedAt: number | null;
    httpRequestCount: number;
    realtimeConnectionCount: number;
    http: {
    totalRecorded: number;
    evictedCount: number;
    truncated: boolean;
    capacity: number;
    };
    realtime: {
    totalRecorded: number;
    evictedCount: number;
    truncated: boolean;
    capacity: number;
    };
    generation: number;
    enabledInspectors: {
    http: boolean;
    websocket: boolean;
    sse: boolean;
    };
    };
    }>;
    readonly getRequestBody: AgentToolDescriptor<NetworkActivityRequestIdArgs, NetworkActivityAgentBodyResult>;
    readonly getResponseBody: AgentToolDescriptor<NetworkActivityRequestIdArgs, NetworkActivityAgentBodyResult>;
    readonly listRealtimeConnections: AgentToolDescriptor<NetworkActivityPaginationArgs, {
    items: ({
    requestId: string;
    kind: "websocket";
    url: string;
    status: "connecting" | "open" | "closing" | "closed" | "error";
    startedAt: number;
    endedAt: number | null;
    durationMs: number | null;
    messageCount: number;
    error: string | null;
    closeCode: number | null;
    httpStatus?: undefined;
    } | {
    requestId: string;
    kind: "sse";
    url: string | null;
    status: "connecting" | "open" | "closed" | "error";
    startedAt: number;
    endedAt: number | null;
    durationMs: number | null;
    messageCount: number;
    error: string | null;
    httpStatus: number | null;
    closeCode?: undefined;
    })[];
    page: {
    limit: number;
    hasMore: boolean;
    nextCursor?: string;
    };
    recording: {
    isRecording: boolean;
    startedAt: number | null;
    stoppedAt: number | null;
    httpRequestCount: number;
    realtimeConnectionCount: number;
    http: {
    totalRecorded: number;
    evictedCount: number;
    truncated: boolean;
    capacity: number;
    };
    realtime: {
    totalRecorded: number;
    evictedCount: number;
    truncated: boolean;
    capacity: number;
    };
    generation: number;
    enabledInspectors: {
    http: boolean;
    websocket: boolean;
    sse: boolean;
    };
    };
    }>;
    readonly getRealtimeConnectionDetails: AgentToolDescriptor<NetworkActivityRequestIdArgs, {
    connection: {
    requestId: string;
    kind: "websocket";
    url: string;
    socketId: string;
    status: "connecting" | "open" | "closing" | "closed" | "error";
    startedAt: number;
    endedAt: number | null;
    durationMs: number | null;
    protocols: string[] | null;
    options: string[];
    error: string | null;
    closeCode: number | null;
    closeReason: string | null;
    messages: {
    id: string;
    direction: "sent" | "received";
    data: string;
    messageType: "text" | "binary";
    timestamp: number;
    }[];
    request?: undefined;
    response?: undefined;
    initiator?: undefined;
    resourceType?: undefined;
    } | {
    requestId: string;
    kind: "sse";
    status: "connecting" | "open" | "closed" | "error";
    startedAt: number;
    endedAt: number | null;
    durationMs: number | null;
    request: Request_2 | null;
    response: Response_2 | null;
    initiator: Initiator | null;
    resourceType: ResourceType | null;
    error: string | null;
    messages: {
    id: string;
    type: string;
    data: string;
    timestamp: number;
    }[];
    url?: undefined;
    socketId?: undefined;
    protocols?: undefined;
    options?: undefined;
    closeCode?: undefined;
    closeReason?: undefined;
    };
    recording: {
    isRecording: boolean;
    startedAt: number | null;
    stoppedAt: number | null;
    httpRequestCount: number;
    realtimeConnectionCount: number;
    http: {
    totalRecorded: number;
    evictedCount: number;
    truncated: boolean;
    capacity: number;
    };
    realtime: {
    totalRecorded: number;
    evictedCount: number;
    truncated: boolean;
    capacity: number;
    };
    generation: number;
    enabledInspectors: {
    http: boolean;
    websocket: boolean;
    sse: boolean;
    };
    };
    }>;
};

declare type NetworkEventSource = 'builtin' | 'nitro';

declare type RealtimeAgentRecord = WebSocketAgentRecord | SSEAgentRecord;

declare type RecordingMetadata = {
    enabledInspectors: {
        http: boolean;
        websocket: boolean;
        sse: boolean;
    };
};

declare type Request_2 = {
    url: string;
    method: HttpMethod;
    headers: HttpHeaders;
    postData?: RequestPostData;
};
export { Request_2 as Request }

export declare type RequestBinaryPostData = {
    type: 'binary';
    value: {
        size: number;
        type?: string;
        name?: string;
    };
};

export declare type RequestFormDataPostData = {
    type: 'form-data';
    value: Record<string, RequestTextPostData | RequestBinaryPostData>;
};

export declare type RequestId = string;

export declare type RequestOverride = {
    status?: number;
    body?: string;
};

export declare type RequestPostData = RequestTextPostData | RequestFormDataPostData | RequestBinaryPostData | null | undefined;

export declare type RequestTextPostData = {
    type: 'text';
    value: string;
};

export declare type ResourceType = 'XHR' | 'Fetch' | 'Other';

declare type Response_2 = {
    url: string;
    status: number;
    statusText: string;
    headers: HttpHeaders;
    contentType: string;
    size: number | null;
    responseTime: Timestamp;
};
export { Response_2 as Response }

declare type ResponseBody = string | {
    kind: 'binary';
    base64: string;
} | {
    kind: 'binary-too-large';
    size: number;
} | null;

declare type SSEAgentMessage = {
    id: string;
    type: string;
    data: string;
    timestamp: number;
};

declare type SSEAgentRecord = {
    requestId: string;
    kind: 'sse';
    status: 'connecting' | 'open' | 'closed' | 'error';
    startedAt: number;
    endedAt?: number;
    durationMs?: number;
    request?: Request_2;
    response?: Response_2;
    initiator?: Initiator;
    resourceType?: ResourceType;
    error?: string;
    messages: SSEAgentMessage[];
};

declare type SSECloseEvent = {
    type: 'sse-close';
    requestId: SSERequestId;
    timestamp: number;
};

declare type SSEErrorEvent = {
    type: 'sse-error';
    requestId: SSERequestId;
    timestamp: number;
    error: {
        type: 'error' | 'timeout' | 'exception';
        message: string;
    };
};

declare type SSEEvent = SSEOpenEvent | SSEMessageEvent | SSEErrorEvent | SSECloseEvent;

declare type SSEEventMap = {
    [K in SSEEvent['type']]: Extract<SSEEvent, {
        type: K;
    }>;
};

declare type SSEMessageEvent = {
    type: 'sse-message';
    requestId: SSERequestId;
    timestamp: number;
    payload: {
        type: string;
        data: string;
    };
};

declare type SSEOpenEvent = {
    type: 'sse-open';
    requestId: SSERequestId;
    timestamp: number;
    response: Response_2;
};

declare type SSERequestId = string;

declare type Timestamp = number;

declare type WebSocketAgentMessage = {
    id: string;
    direction: 'sent' | 'received';
    data: string;
    messageType: 'text' | 'binary';
    timestamp: number;
};

declare type WebSocketAgentRecord = {
    requestId: string;
    kind: 'websocket';
    url: string;
    socketId: string;
    status: 'connecting' | 'open' | 'closing' | 'closed' | 'error';
    startedAt: number;
    endedAt?: number;
    durationMs?: number;
    protocols?: string[] | null;
    options?: string[];
    error?: string;
    closeCode?: number;
    closeReason?: string;
    messages: WebSocketAgentMessage[];
};

declare type WebSocketCloseEvent = {
    type: 'websocket-close';
    url: string;
    socketId: string;
    timestamp: number;
    code: number;
    reason?: string;
    source?: NetworkEventSource;
};

declare type WebSocketConnectEvent = {
    type: 'websocket-connect';
    url: string;
    socketId: string;
    timestamp: number;
    protocols: string[] | null;
    options: string[];
    source?: NetworkEventSource;
};

declare type WebSocketConnectionStatus = 'connecting' | 'open' | 'closing' | 'closed';

declare type WebSocketConnectionStatusChangedEvent = {
    type: 'websocket-connection-status-changed';
    url: string;
    socketId: string;
    timestamp: number;
    status: WebSocketConnectionStatus;
    source?: NetworkEventSource;
};

declare type WebSocketErrorEvent = {
    type: 'websocket-error';
    url: string;
    socketId: string;
    timestamp: number;
    error: string;
    source?: NetworkEventSource;
};

declare type WebSocketEvent = WebSocketConnectEvent | WebSocketOpenEvent | WebSocketCloseEvent | WebSocketMessageSentEvent | WebSocketMessageReceivedEvent | WebSocketErrorEvent | WebSocketConnectionStatusChangedEvent;

declare type WebSocketEventMap_2 = {
    [K in WebSocketEvent['type']]: Extract<WebSocketEvent, {
        type: K;
    }>;
};

declare type WebSocketMessageReceivedEvent = {
    type: 'websocket-message-received';
    url: string;
    socketId: string;
    timestamp: number;
    data: string;
    messageType: WebSocketMessageType;
    source?: NetworkEventSource;
};

declare type WebSocketMessageSentEvent = {
    type: 'websocket-message-sent';
    url: string;
    socketId: string;
    timestamp: number;
    data: string;
    messageType: WebSocketMessageType;
    source?: NetworkEventSource;
};

declare type WebSocketMessageType = 'text' | 'binary';

declare type WebSocketOpenEvent = {
    type: 'websocket-open';
    url: string;
    socketId: string;
    timestamp: number;
    source?: NetworkEventSource;
};

export { }