import { ToolDefinition } from '@conveniencepro/ctp-core';

/**
 * ConveniencePro Tool Protocol (CTP) - OpenAPI Generator
 *
 * Generate OpenAPI 3.1 specifications from CTP tool definitions.
 *
 * @module @conveniencepro/ctp-discovery/openapi
 */

/**
 * OpenAPI 3.1 Schema object
 */
interface OpenAPISchema {
    type?: string;
    format?: string;
    description?: string;
    enum?: string[];
    default?: unknown;
    minimum?: number;
    maximum?: number;
    minLength?: number;
    maxLength?: number;
    pattern?: string;
    items?: OpenAPISchema;
    properties?: Record<string, OpenAPISchema>;
    required?: string[];
    oneOf?: OpenAPISchema[];
}
/**
 * OpenAPI 3.1 Parameter object
 */
interface OpenAPIParameter {
    name: string;
    in: 'query' | 'path' | 'header' | 'cookie';
    description?: string;
    required?: boolean;
    schema: OpenAPISchema;
    example?: unknown;
}
/**
 * OpenAPI 3.1 Request Body object
 */
interface OpenAPIRequestBody {
    description?: string;
    required?: boolean;
    content: {
        [mediaType: string]: {
            schema: OpenAPISchema;
            example?: unknown;
        };
    };
}
/**
 * OpenAPI 3.1 Response object
 */
interface OpenAPIResponse {
    description: string;
    content?: {
        [mediaType: string]: {
            schema: OpenAPISchema;
            example?: unknown;
        };
    };
}
/**
 * OpenAPI 3.1 Operation object
 */
interface OpenAPIOperation {
    operationId: string;
    summary: string;
    description?: string;
    tags?: string[];
    parameters?: OpenAPIParameter[];
    requestBody?: OpenAPIRequestBody;
    responses: Record<string, OpenAPIResponse>;
}
/**
 * OpenAPI 3.1 Path Item object
 */
interface OpenAPIPathItem {
    get?: OpenAPIOperation;
    post?: OpenAPIOperation;
    summary?: string;
    description?: string;
}
/**
 * OpenAPI 3.1 Document
 */
interface OpenAPIDocument {
    openapi: '3.1.0';
    info: {
        title: string;
        description?: string;
        version: string;
        termsOfService?: string;
        contact?: {
            name?: string;
            url?: string;
            email?: string;
        };
        license?: {
            name: string;
            url?: string;
        };
    };
    servers?: Array<{
        url: string;
        description?: string;
    }>;
    paths: Record<string, OpenAPIPathItem>;
    tags?: Array<{
        name: string;
        description?: string;
    }>;
    components?: {
        schemas?: Record<string, OpenAPISchema>;
        responses?: Record<string, OpenAPIResponse>;
    };
    externalDocs?: {
        description?: string;
        url: string;
    };
}
/**
 * Options for OpenAPI generation
 */
interface OpenAPIGeneratorOptions {
    /** API title */
    title?: string;
    /** API description */
    description?: string;
    /** API version */
    version?: string;
    /** Base URL for the API */
    baseUrl?: string;
    /** Contact information */
    contact?: {
        name?: string;
        url?: string;
        email?: string;
    };
    /** License information */
    license?: {
        name: string;
        url?: string;
    };
    /** Terms of service URL */
    termsOfService?: string;
    /** External documentation URL */
    docsUrl?: string;
    /** Path prefix for tool endpoints */
    pathPrefix?: string;
    /** Include example requests/responses */
    includeExamples?: boolean;
    /** Group tools by category as tags */
    groupByCategory?: boolean;
}
/**
 * Generate OpenAPI specification from tool definitions
 */
declare function generateOpenAPI(tools: ToolDefinition[], options?: OpenAPIGeneratorOptions): OpenAPIDocument;
/**
 * Generate OpenAPI spec as YAML string
 */
declare function generateOpenAPIYAML(tools: ToolDefinition[], options?: OpenAPIGeneratorOptions): string;

export { type OpenAPIDocument, type OpenAPIGeneratorOptions, type OpenAPIOperation, type OpenAPIParameter, type OpenAPIPathItem, type OpenAPIRequestBody, type OpenAPIResponse, type OpenAPISchema, generateOpenAPI, generateOpenAPIYAML };