@t-req/sdk 0.1.0

package/dist/gen/types.gen.d.ts

@@ -0,0 +1,1138 @@
+export type ClientOptions = {
+    baseUrl: 'http://localhost:4097' | (string & {});
+};
+export type GetHealthData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/health';
+};
+export type GetHealthResponses = {
+    /**
+     * Server is healthy
+     */
+    200: {
+        healthy: true;
+        version: string;
+    };
+};
+export type GetHealthResponse = GetHealthResponses[keyof GetHealthResponses];
+export type GetCapabilitiesData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/capabilities';
+};
+export type GetCapabilitiesResponses = {
+    /**
+     * Server capabilities
+     */
+    200: {
+        protocolVersion: string;
+        version: string;
+        features: {
+            sessions: boolean;
+            diagnostics: boolean;
+            streamingBodies: boolean;
+        };
+    };
+};
+export type GetCapabilitiesResponse = GetCapabilitiesResponses[keyof GetCapabilitiesResponses];
+export type GetConfigData = {
+    body?: never;
+    path?: never;
+    query?: {
+        profile?: string;
+        path?: string;
+    };
+    url: '/config';
+};
+export type GetConfigResponses = {
+    /**
+     * Resolved configuration summary
+     */
+    200: {
+        configPath?: string;
+        projectRoot: string;
+        format?: 'jsonc' | 'json' | 'ts' | 'js' | 'mjs';
+        profile?: string;
+        availableProfiles: Array<string>;
+        layersApplied: Array<string>;
+        resolvedConfig: {
+            variables: {
+                [key: string]: unknown;
+            };
+            defaults: {
+                timeoutMs: number;
+                followRedirects: boolean;
+                validateSSL: boolean;
+                proxy?: string;
+                headers: {
+                    [key: string]: string;
+                };
+            };
+            cookies: {
+                enabled: boolean;
+                jarPath?: string;
+                mode: 'disabled' | 'memory' | 'persistent';
+            };
+            security: {
+                allowExternalFiles: boolean;
+                allowPluginsOutsideProject: boolean;
+                pluginPermissions?: {
+                    [key: string]: Array<string>;
+                };
+            };
+            resolverNames: Array<string>;
+        };
+        warnings: Array<string>;
+    };
+};
+export type GetConfigResponse = GetConfigResponses[keyof GetConfigResponses];
+export type PostParseData = {
+    body?: {
+        content?: string;
+        path?: string;
+        includeDiagnostics?: boolean;
+    };
+    path?: never;
+    query?: never;
+    url: '/parse';
+};
+export type PostParseErrors = {
+    /**
+     * Invalid request
+     */
+    400: {
+        error: {
+            code: string;
+            message: string;
+            details?: unknown;
+        };
+    };
+};
+export type PostParseError = PostParseErrors[keyof PostParseErrors];
+export type PostParseResponses = {
+    /**
+     * Parsed requests with diagnostics
+     */
+    200: {
+        requests: Array<{
+            request?: {
+                index: number;
+                name?: string;
+                method: string;
+                url: string;
+                headers: {
+                    [key: string]: string;
+                };
+                hasBody: boolean;
+                hasFormData: boolean;
+                hasBodyFile: boolean;
+                meta: {
+                    [key: string]: string;
+                };
+            };
+            diagnostics: Array<{
+                severity: 'error' | 'warning' | 'info';
+                code: string;
+                message: string;
+                range: {
+                    start: {
+                        line: number;
+                        column: number;
+                    };
+                    end: {
+                        line: number;
+                        column: number;
+                    };
+                };
+            }>;
+        }>;
+        diagnostics: Array<{
+            severity: 'error' | 'warning' | 'info';
+            code: string;
+            message: string;
+            range: {
+                start: {
+                    line: number;
+                    column: number;
+                };
+                end: {
+                    line: number;
+                    column: number;
+                };
+            };
+        }>;
+        resolved: {
+            workspaceRoot: string;
+            projectRoot: string;
+            httpFilePath?: string;
+            basePath: string;
+            configPath?: string;
+        };
+    };
+};
+export type PostParseResponse = PostParseResponses[keyof PostParseResponses];
+export type PostExecuteData = {
+    body?: {
+        content?: string;
+        path?: string;
+        requestName?: string;
+        requestIndex?: number;
+        sessionId?: string;
+        profile?: string;
+        variables?: {
+            [key: string]: unknown;
+        };
+        flowId?: string;
+        reqLabel?: string;
+        timeoutMs?: number;
+        basePath?: string;
+        followRedirects?: boolean;
+        validateSSL?: boolean;
+    };
+    path?: never;
+    query?: never;
+    url: '/execute';
+};
+export type PostExecuteErrors = {
+    /**
+     * Invalid request
+     */
+    400: {
+        error: {
+            code: string;
+            message: string;
+            details?: unknown;
+        };
+    };
+    /**
+     * Request not found
+     */
+    404: {
+        error: {
+            code: string;
+            message: string;
+            details?: unknown;
+        };
+    };
+};
+export type PostExecuteError = PostExecuteErrors[keyof PostExecuteErrors];
+export type PostExecuteResponses = {
+    /**
+     * Request executed successfully
+     */
+    200: {
+        runId: string;
+        reqExecId?: string;
+        flowId?: string;
+        session?: {
+            sessionId: string;
+            snapshotVersion: number;
+        };
+        request: {
+            index: number;
+            name?: string;
+            method: string;
+            url: string;
+        };
+        resolved: {
+            workspaceRoot: string;
+            projectRoot: string;
+            httpFilePath?: string;
+            basePath: string;
+            configPath?: string;
+        };
+        response: {
+            status: number;
+            statusText: string;
+            headers: Array<{
+                name: string;
+                value: string;
+            }>;
+            bodyMode: 'buffered' | 'none';
+            body?: string;
+            encoding: 'utf-8' | 'base64';
+            truncated: boolean;
+            bodyBytes: number;
+        };
+        limits: {
+            maxBodyBytes: number;
+        };
+        timing: {
+            startTime: number;
+            endTime: number;
+            durationMs: number;
+        };
+    };
+};
+export type PostExecuteResponse = PostExecuteResponses[keyof PostExecuteResponses];
+export type PostExecuteSseData = {
+    body?: {
+        content?: string;
+        path?: string;
+        requestName?: string;
+        requestIndex?: number;
+        sessionId?: string;
+        profile?: string;
+        variables?: {
+            [key: string]: unknown;
+        };
+        flowId?: string;
+        reqLabel?: string;
+        timeout?: number;
+        lastEventId?: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/execute/sse';
+};
+export type PostExecuteSseErrors = {
+    /**
+     * Invalid request or not an SSE request
+     */
+    400: {
+        error: {
+            code: string;
+            message: string;
+            details?: unknown;
+        };
+    };
+    /**
+     * Request not found
+     */
+    404: {
+        error: {
+            code: string;
+            message: string;
+            details?: unknown;
+        };
+    };
+};
+export type PostExecuteSseError = PostExecuteSseErrors[keyof PostExecuteSseErrors];
+export type PostExecuteSseResponses = {
+    /**
+     * SSE event stream
+     */
+    200: {
+        type: 'parseStarted' | 'parseFinished' | 'interpolateStarted' | 'interpolateFinished' | 'compileStarted' | 'compileFinished' | 'fetchStarted' | 'fetchFinished' | 'error' | 'sessionUpdated' | 'flowStarted' | 'flowFinished' | 'requestQueued' | 'executionFailed' | 'scriptStarted' | 'scriptOutput' | 'scriptFinished' | 'testStarted' | 'testOutput' | 'testFinished';
+        ts: number;
+        runId: string;
+        sessionId?: string;
+        flowId?: string;
+        reqExecId?: string;
+        seq: number;
+        payload: {
+            [key: string]: unknown;
+        };
+    };
+};
+export type PostExecuteSseResponse = PostExecuteSseResponses[keyof PostExecuteSseResponses];
+export type PostSessionData = {
+    body?: {
+        variables?: {
+            [key: string]: unknown;
+        };
+    };
+    path?: never;
+    query?: never;
+    url: '/session';
+};
+export type PostSessionResponses = {
+    /**
+     * Session created
+     */
+    201: {
+        sessionId: string;
+    };
+};
+export type PostSessionResponse = PostSessionResponses[keyof PostSessionResponses];
+export type DeleteSessionByIdData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: never;
+    url: '/session/{id}';
+};
+export type DeleteSessionByIdErrors = {
+    /**
+     * Session not found
+     */
+    404: {
+        error: {
+            code: string;
+            message: string;
+            details?: unknown;
+        };
+    };
+};
+export type DeleteSessionByIdError = DeleteSessionByIdErrors[keyof DeleteSessionByIdErrors];
+export type DeleteSessionByIdResponses = {
+    /**
+     * Session deleted
+     */
+    204: void;
+};
+export type DeleteSessionByIdResponse = DeleteSessionByIdResponses[keyof DeleteSessionByIdResponses];
+export type GetSessionByIdData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: never;
+    url: '/session/{id}';
+};
+export type GetSessionByIdErrors = {
+    /**
+     * Session not found
+     */
+    404: {
+        error: {
+            code: string;
+            message: string;
+            details?: unknown;
+        };
+    };
+};
+export type GetSessionByIdError = GetSessionByIdErrors[keyof GetSessionByIdErrors];
+export type GetSessionByIdResponses = {
+    /**
+     * Session state
+     */
+    200: {
+        sessionId: string;
+        variables: {
+            [key: string]: unknown;
+        };
+        cookieCount: number;
+        createdAt: number;
+        lastUsedAt: number;
+        snapshotVersion: number;
+    };
+};
+export type GetSessionByIdResponse = GetSessionByIdResponses[keyof GetSessionByIdResponses];
+export type PutSessionByIdVariablesData = {
+    body?: {
+        variables: {
+            [key: string]: unknown;
+        };
+        mode: 'merge' | 'replace';
+    };
+    path: {
+        id: string;
+    };
+    query?: never;
+    url: '/session/{id}/variables';
+};
+export type PutSessionByIdVariablesErrors = {
+    /**
+     * Session not found
+     */
+    404: {
+        error: {
+            code: string;
+            message: string;
+            details?: unknown;
+        };
+    };
+};
+export type PutSessionByIdVariablesError = PutSessionByIdVariablesErrors[keyof PutSessionByIdVariablesErrors];
+export type PutSessionByIdVariablesResponses = {
+    /**
+     * Variables updated
+     */
+    200: {
+        sessionId: string;
+        snapshotVersion: number;
+    };
+};
+export type PutSessionByIdVariablesResponse = PutSessionByIdVariablesResponses[keyof PutSessionByIdVariablesResponses];
+export type PostFlowsData = {
+    body?: {
+        sessionId?: string;
+        label?: string;
+        meta?: {
+            [key: string]: unknown;
+        };
+    };
+    path?: never;
+    query?: never;
+    url: '/flows';
+};
+export type PostFlowsErrors = {
+    /**
+     * Session not found (if sessionId provided)
+     */
+    404: {
+        error: {
+            code: string;
+            message: string;
+            details?: unknown;
+        };
+    };
+};
+export type PostFlowsError = PostFlowsErrors[keyof PostFlowsErrors];
+export type PostFlowsResponses = {
+    /**
+     * Flow created
+     */
+    201: {
+        flowId: string;
+    };
+};
+export type PostFlowsResponse = PostFlowsResponses[keyof PostFlowsResponses];
+export type PostFlowsByFlowIdFinishData = {
+    body?: never;
+    path: {
+        flowId: string;
+    };
+    query?: never;
+    url: '/flows/{flowId}/finish';
+};
+export type PostFlowsByFlowIdFinishErrors = {
+    /**
+     * Flow not found
+     */
+    404: {
+        error: {
+            code: string;
+            message: string;
+            details?: unknown;
+        };
+    };
+};
+export type PostFlowsByFlowIdFinishError = PostFlowsByFlowIdFinishErrors[keyof PostFlowsByFlowIdFinishErrors];
+export type PostFlowsByFlowIdFinishResponses = {
+    /**
+     * Flow finished with summary
+     */
+    200: {
+        flowId: string;
+        summary: {
+            total: number;
+            succeeded: number;
+            failed: number;
+            durationMs: number;
+        };
+    };
+};
+export type PostFlowsByFlowIdFinishResponse = PostFlowsByFlowIdFinishResponses[keyof PostFlowsByFlowIdFinishResponses];
+export type GetFlowsByFlowIdExecutionsByReqExecIdData = {
+    body?: never;
+    path: {
+        flowId: string;
+        reqExecId: string;
+    };
+    query?: never;
+    url: '/flows/{flowId}/executions/{reqExecId}';
+};
+export type GetFlowsByFlowIdExecutionsByReqExecIdErrors = {
+    /**
+     * Flow or execution not found
+     */
+    404: {
+        error: {
+            code: string;
+            message: string;
+            details?: unknown;
+        };
+    };
+};
+export type GetFlowsByFlowIdExecutionsByReqExecIdError = GetFlowsByFlowIdExecutionsByReqExecIdErrors[keyof GetFlowsByFlowIdExecutionsByReqExecIdErrors];
+export type GetFlowsByFlowIdExecutionsByReqExecIdResponses = {
+    /**
+     * Execution details
+     */
+    200: {
+        reqExecId: string;
+        flowId: string;
+        sessionId?: string;
+        reqLabel?: string;
+        source?: {
+            kind: 'file' | 'string';
+            path?: string;
+            requestIndex?: number;
+            requestName?: string;
+        };
+        rawHttpBlock?: string;
+        method?: string;
+        urlTemplate?: string;
+        urlResolved?: string;
+        headers?: Array<{
+            name: string;
+            value: string;
+        }>;
+        bodyPreview?: string;
+        timing: {
+            startTime: number;
+            endTime?: number;
+            durationMs?: number;
+            ttfb?: number;
+        };
+        response?: {
+            status: number;
+            statusText: string;
+            headers: Array<{
+                name: string;
+                value: string;
+            }>;
+            body?: string;
+            encoding: 'utf-8' | 'base64';
+            truncated: boolean;
+            bodyBytes: number;
+        };
+        pluginHooks?: Array<{
+            pluginName: string;
+            hook: string;
+            durationMs: number;
+            modified: boolean;
+        }>;
+        status: 'pending' | 'running' | 'success' | 'failed';
+        error?: {
+            stage: string;
+            message: string;
+        };
+    };
+};
+export type GetFlowsByFlowIdExecutionsByReqExecIdResponse = GetFlowsByFlowIdExecutionsByReqExecIdResponses[keyof GetFlowsByFlowIdExecutionsByReqExecIdResponses];
+export type GetWorkspaceFilesData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Comma-separated additional glob patterns to ignore
+         */
+        ignore?: string;
+    };
+    url: '/workspace/files';
+};
+export type GetWorkspaceFilesResponses = {
+    /**
+     * List of .http files
+     */
+    200: {
+        files: Array<{
+            path: string;
+            name: string;
+            requestCount: number;
+            lastModified: number;
+        }>;
+        workspaceRoot: string;
+    };
+};
+export type GetWorkspaceFilesResponse = GetWorkspaceFilesResponses[keyof GetWorkspaceFilesResponses];
+export type GetWorkspaceRequestsData = {
+    body?: never;
+    path?: never;
+    query: {
+        /**
+         * Path to .http file (relative to workspace)
+         */
+        path: string;
+    };
+    url: '/workspace/requests';
+};
+export type GetWorkspaceRequestsErrors = {
+    /**
+     * Invalid path
+     */
+    400: {
+        error: {
+            code: string;
+            message: string;
+            details?: unknown;
+        };
+    };
+    /**
+     * File not found
+     */
+    404: {
+        error: {
+            code: string;
+            message: string;
+            details?: unknown;
+        };
+    };
+};
+export type GetWorkspaceRequestsError = GetWorkspaceRequestsErrors[keyof GetWorkspaceRequestsErrors];
+export type GetWorkspaceRequestsResponses = {
+    /**
+     * List of requests
+     */
+    200: {
+        path: string;
+        requests: Array<{
+            index: number;
+            name?: string;
+            method: string;
+            url: string;
+            protocol?: 'http' | 'sse';
+        }>;
+    };
+};
+export type GetWorkspaceRequestsResponse = GetWorkspaceRequestsResponses[keyof GetWorkspaceRequestsResponses];
+export type DeleteWorkspaceFileData = {
+    body?: never;
+    path?: never;
+    query: {
+        /**
+         * Path to .http file (relative to workspace)
+         */
+        path: string;
+    };
+    url: '/workspace/file';
+};
+export type DeleteWorkspaceFileErrors = {
+    /**
+     * Invalid request
+     */
+    400: {
+        error: {
+            code: string;
+            message: string;
+            details?: unknown;
+        };
+    };
+    /**
+     * Path outside workspace
+     */
+    403: {
+        error: {
+            code: string;
+            message: string;
+            details?: unknown;
+        };
+    };
+    /**
+     * File not found
+     */
+    404: {
+        error: {
+            code: string;
+            message: string;
+            details?: unknown;
+        };
+    };
+};
+export type DeleteWorkspaceFileError = DeleteWorkspaceFileErrors[keyof DeleteWorkspaceFileErrors];
+export type DeleteWorkspaceFileResponses = {
+    /**
+     * File deleted
+     */
+    204: void;
+};
+export type DeleteWorkspaceFileResponse = DeleteWorkspaceFileResponses[keyof DeleteWorkspaceFileResponses];
+export type GetWorkspaceFileData = {
+    body?: never;
+    path?: never;
+    query: {
+        /**
+         * Path to .http file (relative to workspace)
+         */
+        path: string;
+    };
+    url: '/workspace/file';
+};
+export type GetWorkspaceFileErrors = {
+    /**
+     * Invalid path
+     */
+    400: {
+        error: {
+            code: string;
+            message: string;
+            details?: unknown;
+        };
+    };
+    /**
+     * Path outside workspace
+     */
+    403: {
+        error: {
+            code: string;
+            message: string;
+            details?: unknown;
+        };
+    };
+    /**
+     * File not found
+     */
+    404: {
+        error: {
+            code: string;
+            message: string;
+            details?: unknown;
+        };
+    };
+};
+export type GetWorkspaceFileError = GetWorkspaceFileErrors[keyof GetWorkspaceFileErrors];
+export type GetWorkspaceFileResponses = {
+    /**
+     * File content
+     */
+    200: {
+        path: string;
+        content: string;
+        lastModified: number;
+    };
+};
+export type GetWorkspaceFileResponse = GetWorkspaceFileResponses[keyof GetWorkspaceFileResponses];
+export type PostWorkspaceFileData = {
+    body?: {
+        path: string;
+        content?: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/workspace/file';
+};
+export type PostWorkspaceFileErrors = {
+    /**
+     * Invalid path or file already exists
+     */
+    400: {
+        error: {
+            code: string;
+            message: string;
+            details?: unknown;
+        };
+    };
+    /**
+     * Path outside workspace
+     */
+    403: {
+        error: {
+            code: string;
+            message: string;
+            details?: unknown;
+        };
+    };
+};
+export type PostWorkspaceFileError = PostWorkspaceFileErrors[keyof PostWorkspaceFileErrors];
+export type PostWorkspaceFileResponses = {
+    /**
+     * File created
+     */
+    201: {
+        path: string;
+        content: string;
+        lastModified: number;
+    };
+};
+export type PostWorkspaceFileResponse = PostWorkspaceFileResponses[keyof PostWorkspaceFileResponses];
+export type PutWorkspaceFileData = {
+    body?: {
+        path: string;
+        content: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/workspace/file';
+};
+export type PutWorkspaceFileErrors = {
+    /**
+     * Invalid request
+     */
+    400: {
+        error: {
+            code: string;
+            message: string;
+            details?: unknown;
+        };
+    };
+    /**
+     * Path outside workspace
+     */
+    403: {
+        error: {
+            code: string;
+            message: string;
+            details?: unknown;
+        };
+    };
+    /**
+     * File not found
+     */
+    404: {
+        error: {
+            code: string;
+            message: string;
+            details?: unknown;
+        };
+    };
+};
+export type PutWorkspaceFileError = PutWorkspaceFileErrors[keyof PutWorkspaceFileErrors];
+export type PutWorkspaceFileResponses = {
+    /**
+     * File updated successfully
+     */
+    200: unknown;
+};
+export type PostScriptData = {
+    body?: {
+        filePath: string;
+        runnerId?: string;
+        flowId?: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/script';
+};
+export type PostScriptErrors = {
+    /**
+     * Invalid request or runner
+     */
+    400: {
+        error: {
+            code: string;
+            message: string;
+            details?: unknown;
+        };
+    };
+    /**
+     * Path outside workspace
+     */
+    403: {
+        error: {
+            code: string;
+            message: string;
+            details?: unknown;
+        };
+    };
+    /**
+     * Flow not found (if flowId provided)
+     */
+    404: {
+        error: {
+            code: string;
+            message: string;
+            details?: unknown;
+        };
+    };
+};
+export type PostScriptError = PostScriptErrors[keyof PostScriptErrors];
+export type PostScriptResponses = {
+    /**
+     * Script started, subscribe to flow SSE for output
+     */
+    200: {
+        runId: string;
+        flowId: string;
+    };
+};
+export type PostScriptResponse = PostScriptResponses[keyof PostScriptResponses];
+export type DeleteScriptByRunIdData = {
+    body?: never;
+    path: {
+        runId: string;
+    };
+    query?: never;
+    url: '/script/{runId}';
+};
+export type DeleteScriptByRunIdErrors = {
+    /**
+     * Script not found or already finished
+     */
+    404: {
+        error: {
+            code: string;
+            message: string;
+            details?: unknown;
+        };
+    };
+};
+export type DeleteScriptByRunIdError = DeleteScriptByRunIdErrors[keyof DeleteScriptByRunIdErrors];
+export type DeleteScriptByRunIdResponses = {
+    /**
+     * Script cancelled
+     */
+    204: void;
+};
+export type DeleteScriptByRunIdResponse = DeleteScriptByRunIdResponses[keyof DeleteScriptByRunIdResponses];
+export type GetScriptRunnersData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Optional file path to filter available runners
+         */
+        filePath?: string;
+    };
+    url: '/script/runners';
+};
+export type GetScriptRunnersResponses = {
+    /**
+     * Available runners with detected default
+     */
+    200: {
+        detected: string | null;
+        options: Array<{
+            id: string;
+            label: string;
+        }>;
+    };
+};
+export type GetScriptRunnersResponse = GetScriptRunnersResponses[keyof GetScriptRunnersResponses];
+export type PostTestData = {
+    body?: {
+        filePath: string;
+        frameworkId?: string;
+        flowId?: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/test';
+};
+export type PostTestErrors = {
+    /**
+     * Invalid request or framework
+     */
+    400: {
+        error: {
+            code: string;
+            message: string;
+            details?: unknown;
+        };
+    };
+    /**
+     * Path outside workspace
+     */
+    403: {
+        error: {
+            code: string;
+            message: string;
+            details?: unknown;
+        };
+    };
+    /**
+     * Flow not found (if flowId provided)
+     */
+    404: {
+        error: {
+            code: string;
+            message: string;
+            details?: unknown;
+        };
+    };
+};
+export type PostTestError = PostTestErrors[keyof PostTestErrors];
+export type PostTestResponses = {
+    /**
+     * Tests started, subscribe to flow SSE for output
+     */
+    200: {
+        runId: string;
+        flowId: string;
+    };
+};
+export type PostTestResponse = PostTestResponses[keyof PostTestResponses];
+export type DeleteTestByRunIdData = {
+    body?: never;
+    path: {
+        runId: string;
+    };
+    query?: never;
+    url: '/test/{runId}';
+};
+export type DeleteTestByRunIdErrors = {
+    /**
+     * Test not found or already finished
+     */
+    404: {
+        error: {
+            code: string;
+            message: string;
+            details?: unknown;
+        };
+    };
+};
+export type DeleteTestByRunIdError = DeleteTestByRunIdErrors[keyof DeleteTestByRunIdErrors];
+export type DeleteTestByRunIdResponses = {
+    /**
+     * Test cancelled
+     */
+    204: void;
+};
+export type DeleteTestByRunIdResponse = DeleteTestByRunIdResponses[keyof DeleteTestByRunIdResponses];
+export type GetTestFrameworksData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Optional file path to help detect the framework
+         */
+        filePath?: string;
+    };
+    url: '/test/frameworks';
+};
+export type GetTestFrameworksResponses = {
+    /**
+     * Available frameworks with detected default
+     */
+    200: {
+        detected: string | null;
+        options: Array<{
+            id: string;
+            label: string;
+        }>;
+    };
+};
+export type GetTestFrameworksResponse = GetTestFrameworksResponses[keyof GetTestFrameworksResponses];
+export type GetPluginsData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/plugins';
+};
+export type GetPluginsResponses = {
+    /**
+     * List of loaded plugins with their capabilities
+     */
+    200: {
+        plugins: Array<{
+            name: string;
+            version?: string;
+            source: 'npm' | 'file' | 'inline' | 'subprocess';
+            permissions: Array<string>;
+            capabilities: {
+                hasHooks: boolean;
+                hasResolvers: boolean;
+                hasCommands: boolean;
+                hasMiddleware: boolean;
+                hasTools: boolean;
+            };
+        }>;
+        count: number;
+    };
+};
+export type GetPluginsResponse = GetPluginsResponses[keyof GetPluginsResponses];
+export type GetEventData = {
+    body?: never;
+    path?: never;
+    query?: {
+        sessionId?: string;
+        flowId?: string;
+    };
+    url: '/event';
+};
+export type GetEventResponses = {
+    /**
+     * SSE stream
+     */
+    200: {
+        type: 'parseStarted' | 'parseFinished' | 'interpolateStarted' | 'interpolateFinished' | 'compileStarted' | 'compileFinished' | 'fetchStarted' | 'fetchFinished' | 'error' | 'sessionUpdated' | 'flowStarted' | 'flowFinished' | 'requestQueued' | 'executionFailed' | 'scriptStarted' | 'scriptOutput' | 'scriptFinished' | 'testStarted' | 'testOutput' | 'testFinished';
+        ts: number;
+        runId: string;
+        sessionId?: string;
+        flowId?: string;
+        reqExecId?: string;
+        seq: number;
+        payload: {
+            [key: string]: unknown;
+        };
+    };
+};
+export type GetEventResponse = GetEventResponses[keyof GetEventResponses];
+//# sourceMappingURL=types.gen.d.ts.map