/**
 * Model Context Protocol (MCP) Types
 *
 * TypeScript definitions for MCP tools, requests, and responses
 */
import type { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
export interface MCPToolSchema {
    type: "object";
    properties: Record<string, JSONSchemaProperty>;
    required?: string[];
    additionalProperties?: boolean;
}
export interface JSONSchemaProperty {
    type: "string" | "number" | "boolean" | "array" | "object";
    description?: string;
    enum?: (string | number)[];
    items?: JSONSchemaProperty;
    properties?: Record<string, JSONSchemaProperty>;
    minimum?: number;
    maximum?: number;
    minLength?: number;
    maxLength?: number;
    pattern?: string;
    format?: string;
    default?: unknown;
}
export interface MCPTool {
    name: string;
    description: string;
    inputSchema: MCPToolSchema;
}
export interface MCPTextContent {
    type: "text";
    text: string;
}
export interface MCPImageContent {
    type: "image";
    data: string;
    mimeType: string;
}
export interface MCPResourceContent {
    type: "resource";
    resource: {
        uri: string;
        mimeType?: string;
        text?: string;
    };
}
export type MCPContent = MCPTextContent | MCPImageContent | MCPResourceContent;
export interface MCPToolResponse {
    content: MCPContent[];
    isError?: boolean;
}
export interface MCPSuccessResponse extends MCPToolResponse {
    isError?: false;
}
export interface MCPErrorResponse extends MCPToolResponse {
    isError: true;
}
export type MCPToolHandler<TArgs = unknown, TResponse = MCPToolResponse> = (args: TArgs) => Promise<TResponse>;
export type MCPToolHandlerWithClient<TClient, TArgs = unknown, TResponse = MCPToolResponse> = (client: TClient, args: TArgs) => Promise<TResponse>;
export type MCPListToolsRequest = typeof ListToolsRequestSchema;
export type MCPCallToolRequest = typeof CallToolRequestSchema;
export type MCPToolCategory = "authentication" | "posts" | "pages" | "media" | "users" | "comments" | "taxonomies" | "site";
export interface CategorizedMCPTool extends MCPTool {
    category: MCPToolCategory;
}
export type MCPToolRegistry = Record<string, CategorizedMCPTool>;
export type MCPHandlerRegistry<TClient> = Record<string, MCPToolHandlerWithClient<TClient>>;
export interface ToolValidationResult {
    valid: boolean;
    errors: string[];
    warnings: string[];
}
export type CreateSuccessResponse = (text: string, additionalContent?: MCPContent[]) => MCPSuccessResponse;
export type CreateErrorResponse = (error: string | Error, additionalContent?: MCPContent[]) => MCPErrorResponse;
export interface AuthenticationResult {
    success: boolean;
    method: string;
    message: string;
    details?: Record<string, unknown>;
}
export interface MCPToolContext {
    toolName: string;
    category: MCPToolCategory;
    startTime: number;
    userId?: string;
    sessionId?: string;
}
export interface MCPToolMetrics {
    executionTime: number;
    success: boolean;
    errorType?: string;
    inputSize?: number;
    outputSize?: number;
}
export interface MCPToolError extends Error {
    toolName: string;
    category: MCPToolCategory;
    code?: string;
    statusCode?: number;
    details?: Record<string, unknown>;
}
export interface MCPToolConfig {
    timeout?: number;
    retries?: number;
    rateLimit?: {
        requests: number;
        window: number;
    };
    validation?: {
        strict: boolean;
        allowAdditionalProperties: boolean;
    };
}
export interface MCPServerConfig {
    name: string;
    version: string;
    tools: MCPToolRegistry;
    handlers: MCPHandlerRegistry<unknown>;
    middleware?: MCPMiddleware[];
    config?: MCPToolConfig;
}
export type MCPMiddleware<_TClient = unknown> = (context: MCPToolContext, next: () => Promise<MCPToolResponse>) => Promise<MCPToolResponse>;
export interface MCPExecutionPipeline<TClient> {
    validate: (toolName: string, args: unknown) => Promise<ToolValidationResult>;
    authenticate: (client: TClient) => Promise<boolean>;
    execute: (toolName: string, client: TClient, args: unknown) => Promise<MCPToolResponse>;
    postProcess: (response: MCPToolResponse, context: MCPToolContext) => Promise<MCPToolResponse>;
}
export interface MCPToolDocumentation {
    name: string;
    category: MCPToolCategory;
    description: string;
    usage: string;
    examples: Array<{
        title: string;
        description: string;
        input: Record<string, unknown>;
        output: string;
    }>;
    parameters: Array<{
        name: string;
        type: string;
        required: boolean;
        description: string;
        example?: unknown;
    }>;
    errors: Array<{
        code: string;
        description: string;
        resolution: string;
    }>;
}
export interface MCPBatchRequest {
    operations: Array<{
        toolName: string;
        args: Record<string, unknown>;
        id?: string;
    }>;
    parallel?: boolean;
    stopOnError?: boolean;
}
export interface MCPBatchResponse {
    results: Array<{
        id?: string;
        success: boolean;
        response?: MCPToolResponse;
        error?: MCPToolError;
    }>;
    summary: {
        total: number;
        successful: number;
        failed: number;
        executionTime: number;
    };
}
//# sourceMappingURL=mcp.d.ts.map