@nice2dev/ui-tools 1.0.10

package/dist/api-testing.d.ts

@@ -0,0 +1,1146 @@
+/**
+ * @file api-testing.ts
+ * @module @nice2dev/ui-tools
+ * @description PRO-13.2 — API Testing
+ *
+ * Types for API testing tools: HTTP client, request builder, collections,
+ * environments, test automation, WebSocket, gRPC, GraphQL playground.
+ */
+/** HTTP method type */
+export type APITestHttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS' | 'TRACE' | 'CONNECT';
+/** Request body type */
+export type RequestBodyType = 'none' | 'form-data' | 'x-www-form-urlencoded' | 'raw' | 'binary' | 'graphql';
+/** Raw body format */
+export type RawBodyFormat = 'json' | 'xml' | 'text' | 'html' | 'javascript';
+/** Authentication type */
+export type APIAuthType = 'none' | 'basic' | 'bearer' | 'api-key' | 'oauth2' | 'aws-signature' | 'digest' | 'ntlm' | 'hawk' | 'custom';
+/** API workspace */
+export interface APIWorkspace {
+    id: string;
+    name: string;
+    description?: string;
+    type: 'personal' | 'team' | 'public';
+    collections: APICollection[];
+    environments: APIEnvironment[];
+    globals?: APIEnvironment;
+    createdAt: Date;
+    updatedAt: Date;
+    owner?: string;
+    members?: WorkspaceMember[];
+}
+/** Workspace member */
+export interface WorkspaceMember {
+    userId: string;
+    email: string;
+    role: 'viewer' | 'editor' | 'admin';
+    joinedAt: Date;
+}
+/** API collection */
+export interface APICollection {
+    id: string;
+    name: string;
+    description?: string;
+    version?: string;
+    schema?: string;
+    items: (APIFolder | APIRequest)[];
+    auth?: APIAuthentication;
+    variables?: APIVariable[];
+    preRequestScript?: string;
+    testScript?: string;
+    events?: CollectionEvent[];
+    createdAt: Date;
+    updatedAt: Date;
+}
+/** Collection folder */
+export interface APIFolder {
+    type: 'folder';
+    id: string;
+    name: string;
+    description?: string;
+    items: (APIFolder | APIRequest)[];
+    auth?: APIAuthentication;
+    preRequestScript?: string;
+    testScript?: string;
+}
+/** API request */
+export interface APIRequest {
+    type: 'request';
+    id: string;
+    name: string;
+    description?: string;
+    url: RequestURL;
+    method: APITestHttpMethod;
+    headers: RequestHeader[];
+    auth?: APIAuthentication;
+    body?: RequestBody;
+    settings?: RequestSettings;
+    preRequestScript?: string;
+    testScript?: string;
+    tags?: string[];
+    createdAt?: Date;
+    updatedAt?: Date;
+}
+/** Request URL */
+export interface RequestURL {
+    raw: string;
+    protocol?: string;
+    host?: string[];
+    port?: string;
+    path?: string[];
+    query?: RequestQueryParam[];
+    hash?: string;
+    variable?: URLVariable[];
+}
+/** Query parameter */
+export interface RequestQueryParam {
+    key: string;
+    value: string;
+    description?: string;
+    disabled?: boolean;
+}
+/** URL variable (path parameter) */
+export interface URLVariable {
+    key: string;
+    value: string;
+    description?: string;
+}
+/** Request header */
+export interface RequestHeader {
+    key: string;
+    value: string;
+    description?: string;
+    disabled?: boolean;
+    type?: string;
+}
+/** Request body */
+export interface RequestBody {
+    mode: RequestBodyType;
+    raw?: string;
+    formdata?: FormDataItem[];
+    urlencoded?: URLEncodedItem[];
+    file?: FileItem;
+    graphql?: GraphQLBody;
+    options?: BodyOptions;
+}
+/** Form data item */
+export interface FormDataItem {
+    key: string;
+    value?: string;
+    type: 'text' | 'file';
+    src?: string | string[];
+    description?: string;
+    contentType?: string;
+    disabled?: boolean;
+}
+/** URL encoded item */
+export interface URLEncodedItem {
+    key: string;
+    value: string;
+    description?: string;
+    disabled?: boolean;
+}
+/** File item */
+export interface FileItem {
+    src: string;
+    content?: ArrayBuffer;
+}
+/** GraphQL body */
+export interface GraphQLBody {
+    query: string;
+    variables?: string;
+    operationName?: string;
+}
+/** Body options */
+export interface BodyOptions {
+    raw?: {
+        language: RawBodyFormat;
+    };
+}
+/** Request settings */
+export interface RequestSettings {
+    followRedirects?: boolean;
+    maxRedirects?: number;
+    timeout?: number;
+    strictSSL?: boolean;
+    proxy?: ProxySettings;
+    certificate?: CertificateSettings;
+    encoding?: string;
+}
+/** Proxy settings */
+export interface ProxySettings {
+    enabled: boolean;
+    host?: string;
+    port?: number;
+    auth?: {
+        username: string;
+        password: string;
+    };
+    bypass?: string[];
+}
+/** Certificate settings */
+export interface CertificateSettings {
+    pfx?: {
+        src: string;
+    };
+    cert?: {
+        src: string;
+    };
+    key?: {
+        src: string;
+    };
+    passphrase?: string;
+}
+/** API authentication */
+export interface APIAuthentication {
+    type: APIAuthType;
+    basic?: BasicAuth;
+    bearer?: BearerAuth;
+    apiKey?: APIKeyAuth;
+    oauth2?: OAuth2Auth;
+    awsSignature?: AWSSignatureAuth;
+    digest?: DigestAuth;
+    ntlm?: NTLMAuth;
+    hawk?: HawkAuth;
+    custom?: CustomAuth;
+}
+/** Basic authentication */
+export interface BasicAuth {
+    username: string;
+    password: string;
+}
+/** Bearer token authentication */
+export interface BearerAuth {
+    token: string;
+    prefix?: string;
+}
+/** API key authentication */
+export interface APIKeyAuth {
+    key: string;
+    value: string;
+    in: 'header' | 'query';
+}
+/** OAuth2 authentication */
+export interface OAuth2Auth {
+    grantType: 'authorization_code' | 'client_credentials' | 'password' | 'implicit' | 'refresh_token';
+    accessTokenUrl?: string;
+    authorizationUrl?: string;
+    clientId?: string;
+    clientSecret?: string;
+    scope?: string;
+    state?: string;
+    redirectUri?: string;
+    username?: string;
+    password?: string;
+    refreshToken?: string;
+    accessToken?: string;
+    tokenName?: string;
+    headerPrefix?: string;
+    addTokenTo?: 'header' | 'query';
+    challengeAlgorithm?: 'S256' | 'plain';
+    usePkce?: boolean;
+}
+/** AWS signature authentication */
+export interface AWSSignatureAuth {
+    accessKey: string;
+    secretKey: string;
+    region: string;
+    service: string;
+    sessionToken?: string;
+}
+/** Digest authentication */
+export interface DigestAuth {
+    username: string;
+    password: string;
+    realm?: string;
+    nonce?: string;
+    nonceCount?: string;
+    algorithm?: 'MD5' | 'MD5-sess' | 'SHA-256' | 'SHA-256-sess' | 'SHA-512-256' | 'SHA-512-256-sess';
+    qop?: 'auth' | 'auth-int';
+    opaque?: string;
+    clientNonce?: string;
+}
+/** NTLM authentication */
+export interface NTLMAuth {
+    username: string;
+    password: string;
+    domain?: string;
+    workstation?: string;
+}
+/** Hawk authentication */
+export interface HawkAuth {
+    authId: string;
+    authKey: string;
+    algorithm: 'sha256' | 'sha1';
+    user?: string;
+    nonce?: string;
+    ext?: string;
+    app?: string;
+    dlg?: string;
+    timestamp?: string;
+}
+/** Custom authentication */
+export interface CustomAuth {
+    headers?: Record<string, string>;
+    query?: Record<string, string>;
+}
+/** Collection event */
+export interface CollectionEvent {
+    listen: 'prerequest' | 'test';
+    script: EventScript;
+}
+/** Event script */
+export interface EventScript {
+    id?: string;
+    type: 'text/javascript';
+    exec: string[];
+}
+/** API environment */
+export interface APIEnvironment {
+    id: string;
+    name: string;
+    values: APIVariable[];
+    createdAt?: Date;
+    updatedAt?: Date;
+}
+/** API variable */
+export interface APIVariable {
+    key: string;
+    value: string;
+    type?: 'default' | 'secret' | 'any';
+    description?: string;
+    enabled?: boolean;
+    sessionValue?: string;
+}
+/** Variable scope */
+export type VariableScope = 'collection' | 'environment' | 'global' | 'local' | 'data';
+/** Variable resolution */
+export interface VariableResolution {
+    original: string;
+    resolved: string;
+    variables: ResolvedVariable[];
+    errors?: VariableError[];
+}
+/** Resolved variable */
+export interface ResolvedVariable {
+    name: string;
+    value: string;
+    scope: VariableScope;
+}
+/** Variable error */
+export interface VariableError {
+    name: string;
+    message: string;
+}
+/** API response */
+export interface APIResponse {
+    id: string;
+    requestId: string;
+    status: number;
+    statusText: string;
+    headers: ResponseHeader[];
+    cookies: ResponseCookie[];
+    body: ResponseBody;
+    timing: ResponseTiming;
+    size: ResponseSize;
+    originalRequest: APIRequest;
+    timestamp: Date;
+}
+/** Response header */
+export interface ResponseHeader {
+    key: string;
+    value: string;
+}
+/** Response cookie */
+export interface ResponseCookie {
+    name: string;
+    value: string;
+    domain?: string;
+    path?: string;
+    expires?: Date;
+    httpOnly?: boolean;
+    secure?: boolean;
+    sameSite?: 'Strict' | 'Lax' | 'None';
+}
+/** Response body */
+export interface ResponseBody {
+    raw: string;
+    size: number;
+    contentType?: string;
+    encoding?: string;
+    parsed?: unknown;
+    truncated?: boolean;
+}
+/** Response timing */
+export interface ResponseTiming {
+    total: number;
+    dns?: number;
+    tcp?: number;
+    tls?: number;
+    firstByte?: number;
+    download?: number;
+    blocked?: number;
+}
+/** Response size */
+export interface ResponseSize {
+    total: number;
+    headers: number;
+    body: number;
+}
+/** Request history item */
+export interface RequestHistoryItem {
+    id: string;
+    request: APIRequest;
+    response?: APIResponse;
+    timestamp: Date;
+    duration?: number;
+    success: boolean;
+    environmentId?: string;
+}
+/** Script context */
+export interface ScriptContext {
+    /** Request object */
+    request: ScriptRequest;
+    /** Response object (test scripts only) */
+    response?: ScriptResponse;
+    /** Variables */
+    variables: ScriptVariables;
+    /** Environment */
+    environment: ScriptEnvironment;
+    /** Globals */
+    globals: ScriptGlobals;
+    /** Collection variables */
+    collectionVariables: ScriptCollectionVariables;
+    /** Iteration data */
+    iterationData: ScriptIterationData;
+    /** Console */
+    console: ScriptConsole;
+    /** Test functions (test scripts only) */
+    pm?: PostmanSandbox;
+}
+/** Script request */
+export interface ScriptRequest {
+    url: string;
+    method: string;
+    headers: Record<string, string>;
+    body?: string;
+    addHeader(key: string, value: string): void;
+    removeHeader(key: string): void;
+}
+/** Script response */
+export interface ScriptResponse {
+    code: number;
+    status: string;
+    headers: Record<string, string>;
+    body: string;
+    json(): unknown;
+    text(): string;
+    responseTime: number;
+    responseSize: number;
+}
+/** Script variables interface */
+export interface ScriptVariables {
+    get(key: string): string | undefined;
+    set(key: string, value: string): void;
+    has(key: string): boolean;
+    clear(): void;
+    toObject(): Record<string, string>;
+}
+/** Script environment */
+export interface ScriptEnvironment extends ScriptVariables {
+}
+/** Script globals */
+export interface ScriptGlobals extends ScriptVariables {
+}
+/** Script collection variables */
+export interface ScriptCollectionVariables extends ScriptVariables {
+}
+/** Script iteration data */
+export interface ScriptIterationData {
+    get(key: string): unknown;
+    toObject(): Record<string, unknown>;
+}
+/** Script console */
+export interface ScriptConsole {
+    log(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+    clear(): void;
+}
+/** Postman sandbox API */
+export interface PostmanSandbox {
+    test: TestFunction;
+    expect: ChaiExpect;
+    response: ScriptResponse;
+    request: ScriptRequest;
+    environment: ScriptEnvironment;
+    globals: ScriptGlobals;
+    collectionVariables: ScriptCollectionVariables;
+    variables: ScriptVariables;
+    iterationData: ScriptIterationData;
+    cookies: CookieJar;
+    info: RequestInfo;
+    sendRequest(request: string | APIRequest, callback: (error: Error | null, response: ScriptResponse) => void): void;
+    visualizer: Visualizer;
+}
+/** Test function */
+export interface TestFunction {
+    (name: string, fn: () => void): void;
+    skip(name: string, fn: () => void): void;
+}
+/** Chai expect (simplified) */
+export interface ChaiExpect {
+    (value: unknown): ChaiAssertion;
+}
+/** Chai assertion (simplified) */
+export interface ChaiAssertion {
+    to: ChaiAssertion;
+    be: ChaiAssertion;
+    been: ChaiAssertion;
+    have: ChaiAssertion;
+    not: ChaiAssertion;
+    equal(value: unknown): ChaiAssertion;
+    eql(value: unknown): ChaiAssertion;
+    include(value: unknown): ChaiAssertion;
+    property(name: string, value?: unknown): ChaiAssertion;
+    lengthOf(length: number): ChaiAssertion;
+    above(value: number): ChaiAssertion;
+    below(value: number): ChaiAssertion;
+    a(type: string): ChaiAssertion;
+    an(type: string): ChaiAssertion;
+    ok: ChaiAssertion;
+    true: ChaiAssertion;
+    false: ChaiAssertion;
+    null: ChaiAssertion;
+    undefined: ChaiAssertion;
+    empty: ChaiAssertion;
+    oneOf(list: unknown[]): ChaiAssertion;
+    status(code: number): ChaiAssertion;
+    header(name: string, value?: string): ChaiAssertion;
+    jsonBody(path?: string): ChaiAssertion;
+}
+/** Cookie jar */
+export interface CookieJar {
+    get(url: string, name: string): string | undefined;
+    getAll(url: string): ResponseCookie[];
+    set(url: string, name: string, value: string, options?: CookieOptions): void;
+    clear(url: string): void;
+}
+/** Cookie options */
+export interface CookieOptions {
+    domain?: string;
+    path?: string;
+    expires?: Date;
+    maxAge?: number;
+    httpOnly?: boolean;
+    secure?: boolean;
+    sameSite?: 'Strict' | 'Lax' | 'None';
+}
+/** Request info */
+export interface RequestInfo {
+    eventName: string;
+    iteration: number;
+    iterationCount: number;
+    requestName: string;
+    requestId: string;
+}
+/** Visualizer */
+export interface Visualizer {
+    set(template: string, data?: unknown): void;
+    clear(): void;
+}
+/** Script execution result */
+export interface ScriptExecutionResult {
+    success: boolean;
+    duration: number;
+    console: ConsoleOutput[];
+    tests?: TestResult[];
+    visualizer?: string;
+    error?: ScriptError;
+    variableChanges?: VariableChange[];
+}
+/** Console output */
+export interface ConsoleOutput {
+    level: 'log' | 'info' | 'warn' | 'error';
+    message: string;
+    timestamp: Date;
+}
+/** Test result */
+export interface TestResult {
+    name: string;
+    passed: boolean;
+    error?: string;
+    duration?: number;
+    skipped?: boolean;
+}
+/** Script error */
+export interface ScriptError {
+    name: string;
+    message: string;
+    stack?: string;
+    line?: number;
+    column?: number;
+}
+/** Variable change */
+export interface VariableChange {
+    scope: VariableScope;
+    key: string;
+    oldValue?: string;
+    newValue?: string;
+    action: 'set' | 'unset';
+}
+/** Schema validation config */
+export interface SchemaValidationConfig {
+    /** JSON Schema */
+    schema?: object;
+    /** OpenAPI spec reference */
+    openApiSpec?: string;
+    /** Schema path in spec */
+    schemaPath?: string;
+    /** Strict mode */
+    strict?: boolean;
+    /** Allow additional properties */
+    allowAdditional?: boolean;
+}
+/** Validation result */
+export interface ValidationResult {
+    valid: boolean;
+    errors: ValidationError[];
+    warnings?: ValidationWarning[];
+}
+/** Validation error */
+export interface ValidationError {
+    path: string;
+    message: string;
+    keyword?: string;
+    params?: Record<string, unknown>;
+    schemaPath?: string;
+}
+/** Validation warning */
+export interface ValidationWarning {
+    path: string;
+    message: string;
+}
+/** Test suite */
+export interface TestSuite {
+    id: string;
+    name: string;
+    description?: string;
+    collectionId: string;
+    environmentId?: string;
+    dataFile?: string;
+    iterations?: number;
+    delay?: number;
+    timeout?: number;
+    bail?: boolean;
+    ignoreRedirects?: boolean;
+    insecure?: boolean;
+    folder?: string;
+    reporters?: TestReporter[];
+    createdAt: Date;
+    updatedAt: Date;
+}
+/** Test reporter */
+export interface TestReporter {
+    name: 'cli' | 'json' | 'junit' | 'html' | 'custom';
+    options?: Record<string, unknown>;
+}
+/** Test run */
+export interface TestRun {
+    id: string;
+    suiteId: string;
+    status: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+    startTime: Date;
+    endTime?: Date;
+    totalRequests: number;
+    completedRequests: number;
+    passedTests: number;
+    failedTests: number;
+    skippedTests: number;
+    totalAssertions: number;
+    passedAssertions: number;
+    failedAssertions: number;
+    iterations: TestIteration[];
+    summary?: TestRunSummary;
+    error?: string;
+}
+/** Test iteration */
+export interface TestIteration {
+    index: number;
+    requests: TestRequestResult[];
+    data?: Record<string, unknown>;
+}
+/** Test request result */
+export interface TestRequestResult {
+    requestId: string;
+    requestName: string;
+    url: string;
+    method: string;
+    status?: number;
+    responseTime?: number;
+    responseSize?: number;
+    tests: TestResult[];
+    assertions: AssertionResult[];
+    preRequestScript?: ScriptExecutionResult;
+    testScript?: ScriptExecutionResult;
+    error?: string;
+    skipped?: boolean;
+}
+/** Assertion result */
+export interface AssertionResult {
+    name: string;
+    passed: boolean;
+    message?: string;
+    actual?: unknown;
+    expected?: unknown;
+}
+/** Test run summary */
+export interface TestRunSummary {
+    duration: number;
+    requests: {
+        total: number;
+        pending: number;
+        passed: number;
+        failed: number;
+    };
+    tests: {
+        total: number;
+        passed: number;
+        failed: number;
+        skipped: number;
+    };
+    assertions: {
+        total: number;
+        passed: number;
+        failed: number;
+    };
+    dataUsed?: boolean;
+    iterationsCompleted: number;
+    iterationsTotal: number;
+}
+/** Load test configuration */
+export interface LoadTestConfig {
+    id: string;
+    name: string;
+    description?: string;
+    collectionId: string;
+    environmentId?: string;
+    scenario: LoadTestScenario;
+    thresholds?: LoadTestThreshold[];
+    tags?: Record<string, string>;
+}
+/** Load test scenario */
+export interface LoadTestScenario {
+    type: 'constant' | 'ramp-up' | 'stages' | 'per-vu-iterations';
+    vus?: number;
+    duration?: string;
+    iterations?: number;
+    stages?: LoadTestStage[];
+    maxVus?: number;
+    startVus?: number;
+    gracefulStop?: string;
+}
+/** Load test stage */
+export interface LoadTestStage {
+    duration: string;
+    target: number;
+}
+/** Load test threshold */
+export interface LoadTestThreshold {
+    metric: string;
+    condition: string;
+    abortOnFail?: boolean;
+}
+/** Load test result */
+export interface LoadTestResult {
+    id: string;
+    configId: string;
+    status: 'pending' | 'running' | 'completed' | 'failed' | 'aborted';
+    startTime: Date;
+    endTime?: Date;
+    metrics: LoadTestMetrics;
+    thresholdResults: ThresholdResult[];
+    checks: LoadTestCheck[];
+    errors: LoadTestError[];
+    summary?: LoadTestSummary;
+}
+/** Load test metrics */
+export interface LoadTestMetrics {
+    http_reqs: MetricData;
+    http_req_duration: MetricData;
+    http_req_waiting: MetricData;
+    http_req_connecting: MetricData;
+    http_req_tls_handshaking: MetricData;
+    http_req_sending: MetricData;
+    http_req_receiving: MetricData;
+    http_req_blocked: MetricData;
+    http_req_failed: MetricData;
+    vus: MetricData;
+    vus_max: MetricData;
+    iterations: MetricData;
+    iteration_duration: MetricData;
+    data_received: MetricData;
+    data_sent: MetricData;
+    [key: string]: MetricData;
+}
+/** Metric data */
+export interface MetricData {
+    type: 'counter' | 'gauge' | 'rate' | 'trend';
+    contains?: 'time' | 'data' | 'default';
+    values: MetricValues;
+}
+/** Metric values */
+export interface MetricValues {
+    count?: number;
+    rate?: number;
+    value?: number;
+    avg?: number;
+    min?: number;
+    max?: number;
+    med?: number;
+    'p(90)'?: number;
+    'p(95)'?: number;
+    'p(99)'?: number;
+}
+/** Threshold result */
+export interface ThresholdResult {
+    metric: string;
+    condition: string;
+    passed: boolean;
+    value: number;
+}
+/** Load test check */
+export interface LoadTestCheck {
+    name: string;
+    passes: number;
+    fails: number;
+}
+/** Load test error */
+export interface LoadTestError {
+    name: string;
+    count: number;
+}
+/** Load test summary */
+export interface LoadTestSummary {
+    totalRequests: number;
+    requestsPerSecond: number;
+    failRate: number;
+    avgDuration: number;
+    p95Duration: number;
+    p99Duration: number;
+    dataReceived: number;
+    dataSent: number;
+    peakVus: number;
+}
+/** Mock response config */
+export interface MockResponseConfig {
+    id: string;
+    name: string;
+    requestId?: string;
+    url: string;
+    method: APITestHttpMethod;
+    isActive: boolean;
+    priority?: number;
+    response: MockedResponse;
+    conditions?: MockCondition[];
+    delay?: number;
+    delayVariation?: number;
+}
+/** Mocked response */
+export interface MockedResponse {
+    statusCode: number;
+    statusMessage?: string;
+    headers: Record<string, string>;
+    body: string | object;
+    bodyMode?: 'raw' | 'file' | 'dynamic';
+    filePath?: string;
+    dynamicScript?: string;
+}
+/** Mock condition */
+export interface MockCondition {
+    type: 'header' | 'query' | 'body' | 'path';
+    key?: string;
+    operator: 'equals' | 'contains' | 'matches' | 'exists' | 'not-exists';
+    value?: string;
+}
+/** Mock server */
+export interface MockServer {
+    id: string;
+    name: string;
+    collectionId: string;
+    url: string;
+    isRunning: boolean;
+    port?: number;
+    mocks: MockResponseConfig[];
+    logs: MockServerLog[];
+    createdAt: Date;
+}
+/** Mock server log */
+export interface MockServerLog {
+    id: string;
+    timestamp: Date;
+    method: string;
+    path: string;
+    matched: boolean;
+    mockId?: string;
+    requestHeaders: Record<string, string>;
+    requestBody?: string;
+    responseStatus: number;
+    responseTime: number;
+}
+/** Import format */
+export type ImportFormat = 'postman-v2.1' | 'postman-v2.0' | 'openapi-3.0' | 'openapi-3.1' | 'swagger-2.0' | 'insomnia-v4' | 'har' | 'curl' | 'raw';
+/** Import result */
+export interface ImportResult {
+    success: boolean;
+    format: ImportFormat;
+    collection?: APICollection;
+    environment?: APIEnvironment;
+    errors?: ImportError[];
+    warnings?: ImportWarning[];
+}
+/** Import error */
+export interface ImportError {
+    message: string;
+    path?: string;
+}
+/** Import warning */
+export interface ImportWarning {
+    message: string;
+    path?: string;
+}
+/** Export options */
+export interface ExportOptions {
+    format: ImportFormat;
+    includeEnvironment?: boolean;
+    includeHistory?: boolean;
+    prettyPrint?: boolean;
+}
+/** WebSocket connection */
+export interface WebSocketConnection {
+    id: string;
+    name: string;
+    url: string;
+    status: 'disconnected' | 'connecting' | 'connected' | 'error';
+    protocols?: string[];
+    headers?: Record<string, string>;
+    auth?: APIAuthentication;
+    autoReconnect?: boolean;
+    reconnectAttempts?: number;
+    reconnectInterval?: number;
+    messages: WebSocketMessage[];
+    createdAt: Date;
+    connectedAt?: Date;
+}
+/** WebSocket message */
+export interface WebSocketMessage {
+    id: string;
+    direction: 'sent' | 'received';
+    type: 'text' | 'binary' | 'ping' | 'pong';
+    data: string | ArrayBuffer;
+    timestamp: Date;
+    size: number;
+}
+/** WebSocket saved message */
+export interface WebSocketSavedMessage {
+    id: string;
+    name: string;
+    type: 'text' | 'binary';
+    data: string;
+    description?: string;
+}
+/** gRPC connection */
+export interface GRPCConnection {
+    id: string;
+    name: string;
+    serverUrl: string;
+    protoFiles: ProtoFile[];
+    status: 'disconnected' | 'connected' | 'error';
+    tls?: GRPCTLSConfig;
+    auth?: GRPCAuth;
+    metadata?: Record<string, string>;
+    services: GRPCService[];
+}
+/** Proto file */
+export interface ProtoFile {
+    id: string;
+    name: string;
+    content: string;
+    path?: string;
+}
+/** gRPC TLS config */
+export interface GRPCTLSConfig {
+    enabled: boolean;
+    insecure?: boolean;
+    rootCert?: string;
+    clientCert?: string;
+    clientKey?: string;
+    serverName?: string;
+}
+/** gRPC authentication */
+export interface GRPCAuth {
+    type: 'none' | 'basic' | 'bearer' | 'google-oauth' | 'insecure';
+    token?: string;
+    username?: string;
+    password?: string;
+}
+/** gRPC service */
+export interface GRPCService {
+    name: string;
+    fullName: string;
+    methods: GRPCMethod[];
+}
+/** gRPC method */
+export interface GRPCMethod {
+    name: string;
+    fullName: string;
+    requestType: string;
+    responseType: string;
+    clientStreaming: boolean;
+    serverStreaming: boolean;
+    requestSchema?: object;
+    responseSchema?: object;
+}
+/** gRPC request */
+export interface GRPCRequest {
+    id: string;
+    connectionId: string;
+    service: string;
+    method: string;
+    message: object;
+    metadata?: Record<string, string>;
+    deadline?: number;
+}
+/** gRPC response */
+export interface GRPCResponse {
+    id: string;
+    requestId: string;
+    status: GRPCStatus;
+    messages: object[];
+    metadata?: Record<string, string>;
+    trailers?: Record<string, string>;
+    duration: number;
+    error?: GRPCError;
+}
+/** gRPC status */
+export interface GRPCStatus {
+    code: number;
+    details: string;
+}
+/** gRPC error */
+export interface GRPCError {
+    code: number;
+    message: string;
+    details?: unknown[];
+}
+/** GraphQL playground config */
+export interface GraphQLPlaygroundConfig {
+    id: string;
+    name: string;
+    endpoint: string;
+    headers?: Record<string, string>;
+    auth?: APIAuthentication;
+    introspection?: boolean;
+    subscriptionEndpoint?: string;
+    schema?: string;
+    tabs: GraphQLTab[];
+    settings?: GraphQLPlaygroundSettings;
+}
+/** GraphQL tab */
+export interface GraphQLTab {
+    id: string;
+    name: string;
+    query: string;
+    variables?: string;
+    headers?: Record<string, string>;
+    operationName?: string;
+    responses: GraphQLResponse[];
+}
+/** GraphQL response */
+export interface GraphQLResponse {
+    id: string;
+    timestamp: Date;
+    data?: unknown;
+    errors?: GraphQLError[];
+    extensions?: unknown;
+    duration: number;
+}
+/** GraphQL error */
+export interface GraphQLError {
+    message: string;
+    locations?: Array<{
+        line: number;
+        column: number;
+    }>;
+    path?: Array<string | number>;
+    extensions?: unknown;
+}
+/** GraphQL playground settings */
+export interface GraphQLPlaygroundSettings {
+    theme?: 'light' | 'dark';
+    'editor.theme'?: string;
+    'editor.fontFamily'?: string;
+    'editor.fontSize'?: number;
+    'editor.reuseHeaders'?: boolean;
+    'tracing.hideTracingResponse'?: boolean;
+    'queryPlan.hideQueryPlanResponse'?: boolean;
+    'schema.polling.enable'?: boolean;
+    'schema.polling.interval'?: number;
+}
+/** GraphQL subscription */
+export interface GraphQLSubscription {
+    id: string;
+    tabId: string;
+    query: string;
+    variables?: object;
+    status: 'connecting' | 'connected' | 'error' | 'closed';
+    messages: GraphQLSubscriptionMessage[];
+    startTime: Date;
+    error?: string;
+}
+/** GraphQL subscription message */
+export interface GraphQLSubscriptionMessage {
+    id: string;
+    timestamp: Date;
+    type: 'data' | 'error' | 'complete';
+    payload?: unknown;
+}
+/** API client configuration */
+export interface APIClientConfig {
+    /** Theme */
+    theme?: 'light' | 'dark' | 'system';
+    /** Request timeout (ms) */
+    timeout?: number;
+    /** Follow redirects */
+    followRedirects?: boolean;
+    /** Max redirects */
+    maxRedirects?: number;
+    /** Verify SSL */
+    verifySSL?: boolean;
+    /** Proxy settings */
+    proxy?: ProxySettings;
+    /** Default headers */
+    defaultHeaders?: Record<string, string>;
+    /** Auto-save history */
+    saveHistory?: boolean;
+    /** Max history items */
+    maxHistoryItems?: number;
+    /** Pretty print responses */
+    prettyPrint?: boolean;
+    /** Syntax highlighting */
+    syntaxHighlight?: boolean;
+    /** Editor settings */
+    editor?: EditorSettings;
+    /** Keyboard shortcuts */
+    shortcuts?: Record<string, string>;
+}
+/** Editor settings */
+export interface EditorSettings {
+    fontFamily?: string;
+    fontSize?: number;
+    tabSize?: number;
+    wordWrap?: boolean;
+    minimap?: boolean;
+    lineNumbers?: boolean;
+}
+//# sourceMappingURL=api-testing.d.ts.map