/**
 * UI Bridge Server Types
 *
 * Shared types for server adapters.
 */
import type { UIBridgeConfig, ElementHistoryOptions } from '@qontinui/ui-bridge/core';
import type { UiBridgeErrorCode } from '@qontinui/ui-bridge/diagnostics';
import type { ControlActionRequest, ControlActionResponse, ComponentActionRequest, ComponentActionResponse, FindRequest, FindResponse, ControlSnapshot, WorkflowRunRequest, WorkflowRunResponse } from '@qontinui/ui-bridge/control';
import type { RenderLogEntry, RenderLogEntryType } from '@qontinui/ui-bridge/render-log';
import type { SearchCriteria, SearchResponse, NLActionRequest, NLActionResponse, AssertionRequest, AssertionResult, BatchAssertionRequest, BatchAssertionResult, SemanticSnapshot, SemanticDiff, SemanticSearchCriteria, SemanticSearchResponse, ScreenAnalysis } from '@qontinui/ui-bridge/ai';
import type { PageHealthReport } from './page-health';
/**
 * Server configuration
 */
export interface UIBridgeServerConfig extends UIBridgeConfig {
    /** Base path for API routes */
    basePath?: string;
    /** Enable CORS */
    cors?: boolean | CORSOptions;
    /** Authentication middleware */
    authenticate?: (req: unknown) => boolean | Promise<boolean>;
    /** Rate limiting */
    rateLimit?: RateLimitOptions;
}
/**
 * CORS options
 */
export interface CORSOptions {
    /** Allowed origins */
    origin?: string | string[] | boolean;
    /** Allowed methods */
    methods?: string[];
    /** Allowed headers */
    headers?: string[];
    /** Expose headers */
    exposeHeaders?: string[];
    /** Allow credentials */
    credentials?: boolean;
    /** Max age for preflight cache */
    maxAge?: number;
}
/**
 * Rate limit options
 */
export interface RateLimitOptions {
    /** Time window in milliseconds */
    windowMs?: number;
    /** Max requests per window */
    max?: number;
    /** Message when rate limited */
    message?: string;
}
/**
 * API response wrapper
 */
export interface APIResponse<T = unknown> {
    /** Whether the request succeeded */
    success: boolean;
    /** Response data */
    data?: T;
    /** Error message if failed (human-readable, dual-audience — plan goal #3) */
    error?: string;
    /**
     * Stable machine-readable diagnostic code. Populated on every
     * `success: false` response (plan Phase 1 — required on failure;
     * optional at the type level only because successful responses omit it).
     * Always a canonical `UiBridgeErrorCode` (mapped from internal/legacy
     * codes via `error-mapper.ts`).
     */
    code?: UiBridgeErrorCode;
    /** Request timestamp */
    timestamp: number;
    /** Response time in milliseconds (set by server) */
    durationMs?: number;
}
/**
 * Render log query parameters
 */
export interface RenderLogQuery {
    /** Filter by entry type */
    type?: RenderLogEntryType;
    /** Filter entries since timestamp */
    since?: number;
    /** Filter entries until timestamp */
    until?: number;
    /** Limit number of results */
    limit?: number;
}
/**
 * Server handler interface
 *
 * Implementations provide these handlers for different frameworks.
 */
export interface UIBridgeServerHandlers {
    getRenderLog: (query?: RenderLogQuery) => Promise<APIResponse<RenderLogEntry[]>>;
    clearRenderLog: () => Promise<APIResponse<void>>;
    captureSnapshot: () => Promise<APIResponse<unknown>>;
    getRenderLogPath: () => Promise<APIResponse<{
        path: string;
    }>>;
    getElements: () => Promise<APIResponse<ControlSnapshot['elements']>>;
    getElement: (id: string) => Promise<APIResponse<ControlSnapshot['elements'][0]>>;
    getElementState: (id: string) => Promise<APIResponse<unknown>>;
    executeElementAction: (id: string, request: ControlActionRequest) => Promise<APIResponse<ControlActionResponse>>;
    getComponents: () => Promise<APIResponse<ControlSnapshot['components']>>;
    getComponent: (id: string) => Promise<APIResponse<ControlSnapshot['components'][0]>>;
    getComponentState: (id: string) => Promise<APIResponse<{
        state: Record<string, unknown>;
        computed: Record<string, unknown>;
        timestamp: number;
    }>>;
    executeComponentAction: (id: string, request: ComponentActionRequest) => Promise<APIResponse<ComponentActionResponse>>;
    find: (request?: FindRequest) => Promise<APIResponse<FindResponse>>;
    /**
     * @deprecated Use find() instead
     */
    discover: (request?: FindRequest) => Promise<APIResponse<FindResponse>>;
    getControlSnapshot: () => Promise<APIResponse<ControlSnapshot>>;
    getWorkflows: () => Promise<APIResponse<ControlSnapshot['workflows']>>;
    runWorkflow: (id: string, request?: WorkflowRunRequest) => Promise<APIResponse<WorkflowRunResponse>>;
    getWorkflowStatus: (runId: string) => Promise<APIResponse<WorkflowRunResponse>>;
    getActionHistory: (limit?: number) => Promise<APIResponse<unknown[]>>;
    getMetrics: () => Promise<APIResponse<unknown>>;
    highlightElement: (id: string) => Promise<APIResponse<void>>;
    getElementTree: () => Promise<APIResponse<unknown>>;
    aiSearch: (criteria: SearchCriteria) => Promise<APIResponse<SearchResponse>>;
    aiExecute: (request: NLActionRequest) => Promise<APIResponse<NLActionResponse>>;
    aiAssert: (request: AssertionRequest) => Promise<APIResponse<AssertionResult>>;
    aiAssertBatch: (request: BatchAssertionRequest) => Promise<APIResponse<BatchAssertionResult>>;
    getSemanticSnapshot: () => Promise<APIResponse<SemanticSnapshot>>;
    getSemanticDiff: (since?: number) => Promise<APIResponse<SemanticDiff | null>>;
    getPageSummary: () => Promise<APIResponse<string>>;
    getScreenAnalysis: () => Promise<APIResponse<ScreenAnalysis>>;
    aiSemanticSearch: (criteria: SemanticSearchCriteria) => Promise<APIResponse<SemanticSearchResponse>>;
    getElementHistory: (elementId: string, options?: ElementHistoryOptions) => Promise<APIResponse<unknown[]>>;
    getPerformanceEntries: () => Promise<APIResponse<unknown>>;
    clearPerformanceEntries: () => Promise<APIResponse<{
        cleared: boolean;
    }>>;
    getBrowserEvents: (params?: {
        type?: string;
        since?: number;
        limit?: number;
    }) => Promise<APIResponse<{
        events: unknown[];
        count: number;
    }>>;
    pageHealth?: () => Promise<APIResponse<PageHealthReport>>;
    query: (request: {
        selector: string;
        limit?: number;
        includeState?: boolean;
    }) => Promise<APIResponse<{
        elements: unknown[];
        count: number;
    }>>;
    waitForElement: (request: {
        selector?: string;
        elementId?: string;
        timeout?: number;
        pollInterval?: number;
    }) => Promise<APIResponse<{
        found: boolean;
        element?: unknown;
        waitedMs: number;
    }>>;
    clickByText: (request: {
        text: string;
        tag?: string;
        exact?: boolean;
    }) => Promise<APIResponse<{
        clicked: boolean;
        element?: unknown;
    }>>;
    clickBySelector: (request: {
        selector: string;
        index?: number;
    }) => Promise<APIResponse<{
        clicked: boolean;
        element?: unknown;
    }>>;
    typeInto: (request: {
        selector?: string;
        label?: string;
        text: string;
        clear?: boolean;
    }) => Promise<APIResponse<{
        typed: boolean;
        element?: unknown;
    }>>;
    readValue: (request: {
        selector: string;
        index?: number;
    }) => Promise<APIResponse<{
        value: string | null;
        length: number;
    }>>;
    findByText: (request: {
        text: string;
        tag?: string;
        exact?: boolean;
    }) => Promise<APIResponse<Array<{
        index: number;
        tag: string;
        text: string;
        rect: {
            x: number;
            y: number;
            width: number;
            height: number;
        };
        disabled: boolean;
        visible: boolean;
    }>>>;
    getDiagnostics: () => Promise<APIResponse<unknown>>;
    /**
     * Diagnostic catalog endpoints (plan Phase 2). Read-only, backed by the
     * single source `diagnostics/codes.json` (via the generated
     * `@qontinui/ui-bridge/diagnostics` catalog). `getDiagnosticsCatalog`
     * returns every code (agent bootstrap); `getDiagnosticCode` returns one
     * code's entry, 404 + canonical `UiBridgeErrorCode` on an unknown code.
     */
    getDiagnosticsCatalog: () => Promise<APIResponse<unknown>>;
    getDiagnosticCode: (code: string) => Promise<APIResponse<unknown>>;
    getRoutes: () => Promise<APIResponse<Array<{
        name: string;
        path: string;
    }>>>;
    navigateByAdapter: (request: {
        page: string;
    }) => Promise<APIResponse<{
        navigated: boolean;
        route: {
            name: string;
            path: string;
        };
    }>>;
}
/**
 * Route definition
 */
export interface RouteDefinition {
    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
    path: string;
    handler: string;
    params?: string[];
    bodyRequired?: boolean;
}
/**
 * All UI Bridge routes
 */
export declare const UI_BRIDGE_ROUTES: RouteDefinition[];
/**
 * WebSocket message types
 */
export type WebSocketMessageType = 'subscribe' | 'unsubscribe' | 'event' | 'snapshot' | 'action' | 'error';
/**
 * WebSocket message
 */
export interface WebSocketMessage<T = unknown> {
    type: WebSocketMessageType;
    channel?: string;
    data?: T;
    error?: string;
    timestamp: number;
}
//# sourceMappingURL=types.d.ts.map