export function validateSchema(
  data: unknown,
  schema: JSONSchema,
  path: string = ''
): ValidationResult {
  // Validates: type, required, properties, enum, pattern,
  // minLength, maxLength, minimum, maximum, items, additionalProperties
}

export function formatValidationErrors(errors: ValidationError[]): string;
export function createValidator(schema: JSONSchema): (data: unknown) => ValidationResult;

// Validate input against schema (security feature)
if (metadata.tool.inputSchema) {
  const validation = validateSchema(input, metadata.tool.inputSchema);
  if (!validation.valid) {
    return {
      content: [{ type: 'text', text: `Invalid input: ${formatValidationErrors(validation.errors)}` }],
      isError: true,
    };
  }
}

export interface LLMProvider {
  name: string;
  createMessage(request: CreateMessageRequest): Promise<CreateMessageResult>;
  isAvailable(): Promise<boolean>;
}

export class SamplingManager extends EventEmitter {
  registerProvider(provider: LLMProvider, isDefault?: boolean): void;
  async createMessage(request: CreateMessageRequest, context?: SamplingContext): Promise<CreateMessageResult>;
  async isAvailable(): Promise<boolean>;
  getProviders(): string[];
  getStats(): { requestCount: number; totalTokens: number; providerCount: number };
}

// Pre-built providers
export function createMockProvider(name?: string): LLMProvider;
export function createAnthropicProvider(apiKey: string): LLMProvider;

export interface RateLimitConfig {
  requestsPerSecond: number;  // Default: 100
  burstSize: number;          // Default: 200
  perSessionLimit?: number;   // Default: 50
  cleanupInterval?: number;   // Default: 60000ms
}

export class RateLimiter extends EventEmitter {
  checkGlobal(): RateLimitResult;
  checkSession(sessionId: string): RateLimitResult;
  check(sessionId?: string): RateLimitResult;
  consume(sessionId?: string): void;
  resetSession(sessionId: string): void;
  getStats(): { globalTokens: number; sessionCount: number; config: RateLimitConfig };
  destroy(): void;
}

// Express/Connect middleware
export function rateLimitMiddleware(rateLimiter: RateLimiter);

// Rate limiting check (skip for initialize)
if (request.method !== 'initialize') {
  const sessionId = this.currentSession?.id;
  const rateLimitResult = this.rateLimiter.check(sessionId);
  if (!rateLimitResult.allowed) {
    return {
      jsonrpc: '2.0',
      id: request.id,
      error: {
        code: -32000,
        message: 'Rate limit exceeded',
        data: { retryAfter: rateLimitResult.retryAfter },
      },
    };
  }
  this.rateLimiter.consume(sessionId);
}

export interface OAuthConfig {
  clientId: string;
  clientSecret?: string;
  authorizationEndpoint: string;
  tokenEndpoint: string;
  redirectUri: string;
  scopes?: string[];
  tokenStorage?: TokenStorage;
  usePKCE?: boolean;  // Default: true
}

export class OAuthManager extends EventEmitter {
  createAuthorizationRequest(): AuthorizationRequest;
  async exchangeCode(code: string, state: string): Promise<OAuthTokens>;
  async refreshTokens(storageKey?: string): Promise<OAuthTokens>;
  async getAccessToken(storageKey?: string): Promise<string | null>;
  async revokeTokens(storageKey?: string): Promise<void>;
  async isAuthenticated(storageKey?: string): Promise<boolean>;
  destroy(): void;
}

// Pre-configured providers
export function createGitHubOAuthConfig(clientId, clientSecret, redirectUri, scopes?): OAuthConfig;
export function createGoogleOAuthConfig(clientId, clientSecret, redirectUri, scopes?): OAuthConfig;

// Express/Connect middleware
export function oauthMiddleware(oauthManager: OAuthManager, storageKey?: string);

Test Files:  2 passed (2)
Tests:       65 passed (65)
Duration:    854ms

Coverage:
- schema-validator.ts: Unit tests for all validation types
- rate-limiter.ts: Token bucket algorithm tests
- sampling.ts: Provider registration and message creation
- oauth.ts: PKCE flow and token management
- integration.test.ts: Full server flow tests

import { validateSchema, formatValidationErrors } from '@claude-flow/mcp';

const schema = {
  type: 'object',
  properties: { name: { type: 'string', minLength: 1 } },
  required: ['name']
};

const result = validateSchema({ name: '' }, schema);
// result.valid = false
// result.errors[0].message = 'String length must be >= 1'

import { createRateLimiter, rateLimitMiddleware } from '@claude-flow/mcp';

const limiter = createRateLimiter(logger, {
  requestsPerSecond: 100,
  burstSize: 200
});

// Use with Express
app.use(rateLimitMiddleware(limiter));

import { createSamplingManager, createAnthropicProvider } from '@claude-flow/mcp';

const sampling = createSamplingManager(logger);
sampling.registerProvider(createAnthropicProvider(process.env.ANTHROPIC_API_KEY), true);

const response = await sampling.createMessage({
  messages: [{ role: 'user', content: { type: 'text', text: 'Hello' } }],
  maxTokens: 100
});

import { createOAuthManager, createGitHubOAuthConfig } from '@claude-flow/mcp';

const oauth = createOAuthManager(logger, createGitHubOAuthConfig(
  'client-id',
  'client-secret',
  'https://myapp.com/callback'
));

const { url, state } = oauth.createAuthorizationRequest();
// Redirect user to `url`, then on callback:
const tokens = await oauth.exchangeCode(code, state);