@rhofkens/mcp-quotes-server-claude-code/dist/utils/validation.d.ts

Model Context Protocol (MCP) server for managing and serving quotes

/**
 * Validation Utilities
 *
 * Input validation helpers and type guards for MCP requests
 */
import type { ZodSchema } from 'zod';
import { z } from 'zod';
import { ValidationError } from './errors.js';
/**
 * Common validation schemas
 */
export declare const CommonSchemas: {
    /**
     * Non-empty string validation
     */
    nonEmptyString: z.ZodString;
    /**
     * Positive integer validation
     */
    positiveInteger: z.ZodNumber;
    /**
     * URL validation
     */
    url: z.ZodString;
    /**
     * Email validation
     */
    email: z.ZodString;
    /**
     * UUID validation
     */
    uuid: z.ZodString;
    /**
     * ISO date string validation
     */
    isoDate: z.ZodString;
};
/**
 * MCP request validation schemas
 */
export declare const MCPSchemas: {
    /**
     * Base MCP request structure
     */
    baseRequest: z.ZodObject<{
        jsonrpc: z.ZodLiteral<"2.0">;
        method: z.ZodString;
        id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
        params: z.ZodOptional<z.ZodUnknown>;
    }, "strip", z.ZodTypeAny, {
        jsonrpc: "2.0";
        method: string;
        id: string | number;
        params?: unknown;
    }, {
        jsonrpc: "2.0";
        method: string;
        id: string | number;
        params?: unknown;
    }>;
    /**
     * Tool call request
     */
    toolCallRequest: z.ZodObject<{
        jsonrpc: z.ZodLiteral<"2.0">;
        method: z.ZodLiteral<"tools/call">;
        id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
        params: z.ZodObject<{
            name: z.ZodString;
            arguments: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        }, "strip", z.ZodTypeAny, {
            name: string;
            arguments?: Record<string, unknown> | undefined;
        }, {
            name: string;
            arguments?: Record<string, unknown> | undefined;
        }>;
    }, "strip", z.ZodTypeAny, {
        params: {
            name: string;
            arguments?: Record<string, unknown> | undefined;
        };
        jsonrpc: "2.0";
        method: "tools/call";
        id: string | number;
    }, {
        params: {
            name: string;
            arguments?: Record<string, unknown> | undefined;
        };
        jsonrpc: "2.0";
        method: "tools/call";
        id: string | number;
    }>;
    /**
     * Resource read request
     */
    resourceReadRequest: z.ZodObject<{
        jsonrpc: z.ZodLiteral<"2.0">;
        method: z.ZodLiteral<"resources/read">;
        id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
        params: z.ZodObject<{
            uri: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            uri: string;
        }, {
            uri: string;
        }>;
    }, "strip", z.ZodTypeAny, {
        params: {
            uri: string;
        };
        jsonrpc: "2.0";
        method: "resources/read";
        id: string | number;
    }, {
        params: {
            uri: string;
        };
        jsonrpc: "2.0";
        method: "resources/read";
        id: string | number;
    }>;
};
/**
 * Quote-specific validation schemas
 */
export declare const QuoteSchemas: {
    /**
     * Get quotes parameters
     */
    getQuotesParams: z.ZodObject<{
        person: z.ZodString;
        numberOfQuotes: z.ZodNumber;
        topic: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        person: string;
        numberOfQuotes: number;
        topic?: string | undefined;
    }, {
        person: string;
        numberOfQuotes: number;
        topic?: string | undefined;
    }>;
    /**
     * Quote object
     */
    quote: z.ZodObject<{
        text: z.ZodString;
        author: z.ZodString;
        source: z.ZodOptional<z.ZodString>;
        date: z.ZodOptional<z.ZodString>;
        context: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        text: string;
        author: string;
        context?: string | undefined;
        date?: string | undefined;
        source?: string | undefined;
    }, {
        text: string;
        author: string;
        context?: string | undefined;
        date?: string | undefined;
        source?: string | undefined;
    }>;
};
/**
 * Validate data against a schema
 * @throws {ValidationError} If validation fails
 */
export declare function validate<T>(schema: ZodSchema<T>, data: unknown, fieldName?: string): T;
/**
 * Safe validation that returns a result object
 */
export declare function safeValidate<T>(schema: ZodSchema<T>, data: unknown): {
    success: true;
    data: T;
} | {
    success: false;
    error: ValidationError;
};
/**
 * Type guard for MCP request
 */
export declare function isMCPRequest(data: unknown): data is z.infer<typeof MCPSchemas.baseRequest>;
/**
 * Type guard for tool call request
 */
export declare function isToolCallRequest(data: unknown): data is z.infer<typeof MCPSchemas.toolCallRequest>;
/**
 * Type guard for resource read request
 */
export declare function isResourceReadRequest(data: unknown): data is z.infer<typeof MCPSchemas.resourceReadRequest>;
/**
 * Validate required environment variable
 */
export declare function validateEnvVar(name: string, value: string | undefined): string;
/**
 * Validate optional environment variable with default
 */
export declare function validateOptionalEnvVar(_name: string, value: string | undefined, defaultValue: string): string;
/**
 * Parse and validate integer environment variable
 */
export declare function parseIntEnvVar(name: string, value: string | undefined, defaultValue: number, min?: number, max?: number): number;
/**
 * Parse and validate boolean environment variable
 */
export declare function parseBooleanEnvVar(name: string, value: string | undefined, defaultValue: boolean): boolean;
/**
 * Create a validation middleware for MCP handlers
 */
export declare function createValidator<T>(schema: ZodSchema<T>): (params: unknown) => T;
/**
 * Validate array bounds
 */
export declare function validateArrayBounds<T>(array: T[], fieldName: string, minLength?: number, maxLength?: number): void;
/**
 * Validate string bounds
 */
export declare function validateStringBounds(value: string, fieldName: string, minLength?: number, maxLength?: number): void;
/**
 * Sanitize string input
 */
export declare function sanitizeString(input: string): string;
/**
 * Validate and sanitize search query
 */
export declare function validateSearchQuery(query: string, fieldName?: string): string;
//# sourceMappingURL=validation.d.ts.map