import type { HTMLAttributes } from 'svelte/elements';
export type TemplateCategory = 'universal' | 'rest' | 'graphql' | 'webhook' | 'custom';
export type OutputFormat = 'python' | 'javascript' | 'typescript' | 'go' | 'rust';
export type GenerationStatus = 'pending' | 'generating' | 'completed' | 'failed';
export type GenerationStage = 'idle' | 'preparing' | 'generating' | 'validating' | 'complete';
export interface TemplateVariable {
    name: string;
    type: 'string' | 'number' | 'boolean' | 'array' | 'object';
    description: string;
    required: boolean;
    defaultValue?: any;
    validation?: {
        pattern?: string;
        min?: number;
        max?: number;
        options?: string[];
    };
}
export interface MetapTemplate {
    id: string;
    name: string;
    description: string;
    category: TemplateCategory;
    content: string;
    variables: TemplateVariable[];
    instructions: string;
    outputFormat: OutputFormat;
    version: number;
    createdAt: Date;
    updatedAt: Date;
    usage: {
        count: number;
        lastUsed: Date;
        averageExecutionTime?: number;
        successRate?: number;
    };
    config?: {
        modelPreferences?: string[];
        temperatureRange?: {
            min: number;
            max: number;
        };
        maxTokens?: number;
        timeout?: number;
    };
    testCases?: Array<{
        name: string;
        context: Record<string, any>;
        expectedPatterns: string[];
    }>;
}
export interface TemplateContext {
    [key: string]: any;
    service_name?: string;
    class_name?: string;
    base_url?: string;
    endpoints?: Array<{
        path: string;
        method: string;
        operation_id: string;
        description?: string;
        parameters: Array<{
            name: string;
            type: string;
            required: boolean;
            location: 'path' | 'query' | 'header' | 'body';
        }>;
    }>;
    schemas?: Record<string, any>;
    auth_methods?: Array<{
        type: string;
        name: string;
        location?: string;
    }>;
    bms_integrations?: {
        oracle_access: boolean;
        scribe_access: boolean;
        architect_access: boolean;
        loop_diagnostics: boolean;
    };
    generation_config?: {
        include_tests: boolean;
        include_documentation: boolean;
        error_handling: 'basic' | 'comprehensive';
        logging_level: 'minimal' | 'detailed';
    };
}
export interface GenerationRequest {
    id: string;
    templateId: string;
    context: TemplateContext;
    model: string;
    temperature: number;
    maxTokens: number;
    customInstructions?: string;
    status: GenerationStatus;
    startedAt: Date;
    completedAt?: Date;
    error?: string;
    retryCount?: number;
}
export interface GenerationResult {
    requestId: string;
    generatedCode: string;
    metadata: {
        tokensUsed: number;
        executionTime: number;
        model: string;
        templateVersion: number;
        generatedAt: Date;
    };
    validation: {
        syntaxValid: boolean;
        semanticValid: boolean;
        warnings: string[];
        suggestions: string[];
        complexity?: {
            cyclomaticComplexity: number;
            maintainabilityIndex: number;
            linesOfCode: number;
        };
    };
    artifacts?: {
        mainFile: string;
        testFile?: string;
        documentation?: string;
        configFile?: string;
        requirements?: string[];
    };
}
export interface GenerationProgress {
    stage: GenerationStage;
    progress: number;
    message: string;
    estimatedTime: number;
    currentStep?: string;
    totalSteps?: number;
}
export interface TemplateEngineProps extends HTMLAttributes<HTMLDivElement> {
    /**
     * Available templates
     */
    templates?: MetapTemplate[];
    /**
     * Generation history
     */
    generationHistory?: GenerationRequest[];
    /**
     * Available AI models
     */
    availableModels?: string[];
    /**
     * Default template to select
     */
    defaultTemplate?: MetapTemplate;
    /**
     * Show template editor interface
     * @default true
     */
    showTemplateEditor?: boolean;
    /**
     * Show generation logs
     * @default true
     */
    showGenerationLogs?: boolean;
    /**
     * Enable custom template creation
     * @default true
     */
    enableCustomTemplates?: boolean;
    /**
     * Default generation configuration
     */
    generationConfig?: {
        model: string;
        temperature: number;
        maxTokens: number;
        timeout: number;
    };
    /**
     * Callback when template is created
     */
    onTemplateCreate?: (template: MetapTemplate) => void;
    /**
     * Callback when generation starts
     */
    onGenerationStart?: (request: GenerationRequest) => void;
    /**
     * Callback when generation completes
     */
    onGenerationComplete?: (request: GenerationRequest, result: GenerationResult) => void;
    /**
     * Callback when template is updated
     */
    onTemplateUpdate?: (template: MetapTemplate) => void;
    /**
     * Callback when template is deleted
     */
    onTemplateDelete?: (templateId: string) => void;
    /**
     * Callback when validation fails
     */
    onValidationError?: (errors: string[]) => void;
}
export interface MetapEngine {
    /**
     * Generate code using a template and context
     */
    generate: (template: MetapTemplate, context: TemplateContext, config?: GenerationConfig) => Promise<GenerationResult>;
    /**
     * Validate template syntax and structure
     */
    validateTemplate: (template: MetapTemplate) => Promise<TemplateValidationResult>;
    /**
     * Test template with provided test cases
     */
    testTemplate: (template: MetapTemplate, testCases: TemplateTestCase[]) => Promise<TemplateTestResult[]>;
    /**
     * Optimize template for better performance
     */
    optimizeTemplate: (template: MetapTemplate) => Promise<MetapTemplate>;
    /**
     * Get available models and their capabilities
     */
    getAvailableModels: () => Promise<ModelInfo[]>;
}
export interface GenerationConfig {
    model: string;
    temperature: number;
    maxTokens: number;
    timeout: number;
    stopSequences?: string[];
    streaming?: boolean;
    presencePenalty?: number;
    frequencyPenalty?: number;
    topP?: number;
    topK?: number;
    format?: 'text' | 'json' | 'yaml';
    prettify?: boolean;
    includeComments?: boolean;
    contentFilter?: boolean;
    safetyLevel?: 'low' | 'medium' | 'high';
}
export interface TemplateValidationResult {
    valid: boolean;
    errors: Array<{
        type: 'syntax' | 'semantic' | 'variable' | 'instruction';
        message: string;
        line?: number;
        column?: number;
        severity: 'error' | 'warning' | 'info';
    }>;
    warnings: string[];
    suggestions: string[];
    score: number;
}
export interface TemplateTestCase {
    name: string;
    description?: string;
    context: TemplateContext;
    expectedPatterns: string[];
    expectedNotPatterns?: string[];
    expectedMetrics?: {
        minTokens?: number;
        maxTokens?: number;
        minComplexity?: number;
        maxComplexity?: number;
    };
}
export interface TemplateTestResult {
    testCase: string;
    passed: boolean;
    generatedCode: string;
    matchedPatterns: string[];
    failedPatterns: string[];
    metrics: {
        tokens: number;
        complexity: number;
        executionTime: number;
    };
    issues: string[];
}
export interface ModelInfo {
    id: string;
    name: string;
    provider: string;
    capabilities: {
        maxTokens: number;
        supportedFormats: string[];
        streaming: boolean;
        codeGeneration: boolean;
        languageSupport: string[];
    };
    pricing?: {
        inputCostPer1K: number;
        outputCostPer1K: number;
        currency: string;
    };
    limitations?: string[];
}
export interface UniversalIntegrationTemplate extends MetapTemplate {
    category: 'universal';
    variables: [
        {
            name: 'service_name';
            type: 'string';
            required: true;
        },
        {
            name: 'class_name';
            type: 'string';
            required: true;
        },
        {
            name: 'base_url';
            type: 'string';
            required: true;
        },
        {
            name: 'endpoints';
            type: 'array';
            required: true;
        },
        {
            name: 'auth_methods';
            type: 'array';
            required: true;
        },
        ...TemplateVariable[]
    ];
}
export interface RESTAPITemplate extends MetapTemplate {
    category: 'rest';
    restConfig: {
        authTypes: ('apiKey' | 'oauth2' | 'bearer' | 'basic')[];
        dataFormats: ('json' | 'xml' | 'form')[];
        supportedMethods: ('GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH')[];
        paginationSupport: boolean;
        rateLimitingSupport: boolean;
    };
}
export interface GraphQLTemplate extends MetapTemplate {
    category: 'graphql';
    graphqlConfig: {
        schemaIntrospection: boolean;
        subscriptionSupport: boolean;
        fragmentSupport: boolean;
        variableSupport: boolean;
        directiveSupport: boolean;
    };
}
export interface WebhookTemplate extends MetapTemplate {
    category: 'webhook';
    webhookConfig: {
        httpMethods: string[];
        signatureValidation: boolean;
        retryLogic: boolean;
        payloadTransformation: boolean;
        eventFiltering: boolean;
    };
}
export interface TemplateLibrary {
    /**
     * Get all templates
     */
    getTemplates: (category?: TemplateCategory) => Promise<MetapTemplate[]>;
    /**
     * Create new template
     */
    createTemplate: (template: Omit<MetapTemplate, 'id' | 'createdAt' | 'updatedAt'>) => Promise<MetapTemplate>;
    /**
     * Update existing template
     */
    updateTemplate: (id: string, updates: Partial<MetapTemplate>) => Promise<MetapTemplate>;
    /**
     * Delete template
     */
    deleteTemplate: (id: string) => Promise<void>;
    /**
     * Clone template
     */
    cloneTemplate: (id: string, newName: string) => Promise<MetapTemplate>;
    /**
     * Import template from file
     */
    importTemplate: (templateData: string) => Promise<MetapTemplate>;
    /**
     * Export template to file
     */
    exportTemplate: (id: string) => Promise<string>;
    /**
     * Search templates
     */
    searchTemplates: (query: string) => Promise<MetapTemplate[]>;
    /**
     * Get template usage statistics
     */
    getUsageStats: (id: string) => Promise<TemplateUsageStats>;
}
export interface TemplateUsageStats {
    templateId: string;
    totalGenerations: number;
    successfulGenerations: number;
    failedGenerations: number;
    averageExecutionTime: number;
    mostCommonContext: Record<string, any>;
    errorPatterns: Array<{
        error: string;
        frequency: number;
        lastOccurred: Date;
    }>;
    performanceMetrics: {
        avgTokensGenerated: number;
        avgComplexity: number;
        userSatisfactionScore?: number;
    };
}
export interface BMSTemplateIntegration {
    /**
     * Generate agent template for Oracle integrations
     */
    generateOracleAgentTemplate: (serviceName: string, capabilities: string[]) => Promise<MetapTemplate>;
    /**
     * Generate agent template for Scribe data access
     */
    generateScribeAgentTemplate: (serviceName: string, dataTypes: string[]) => Promise<MetapTemplate>;
    /**
     * Generate agent template for Architect workflows
     */
    generateArchitectAgentTemplate: (services: string[], workflowType: string) => Promise<MetapTemplate>;
    /**
     * Get BMS-optimized generation context
     */
    getBMSContext: (integrationRequest: any) => Promise<TemplateContext>;
    /**
     * Validate BMS compatibility
     */
    validateBMSCompatibility: (template: MetapTemplate) => Promise<{
        compatible: boolean;
        requiredModifications: string[];
        compatibilityScore: number;
    }>;
}
export interface CodeQualityAnalyzer {
    /**
     * Analyze generated code quality
     */
    analyzeQuality: (code: string, language: string) => Promise<CodeQualityReport>;
    /**
     * Suggest optimizations
     */
    suggestOptimizations: (code: string, language: string) => Promise<OptimizationSuggestion[]>;
    /**
     * Check security vulnerabilities
     */
    checkSecurity: (code: string, language: string) => Promise<SecurityReport>;
    /**
     * Estimate performance metrics
     */
    estimatePerformance: (code: string, language: string) => Promise<PerformanceEstimate>;
}
export interface CodeQualityReport {
    overallScore: number;
    metrics: {
        cyclomaticComplexity: number;
        maintainabilityIndex: number;
        technicalDebt: number;
        testCoverage?: number;
        documentation: number;
    };
    issues: Array<{
        type: 'bug' | 'vulnerability' | 'code_smell' | 'duplication';
        severity: 'info' | 'minor' | 'major' | 'critical' | 'blocker';
        message: string;
        line?: number;
        suggestion?: string;
    }>;
    recommendations: string[];
}
export interface OptimizationSuggestion {
    type: 'performance' | 'readability' | 'maintainability' | 'security';
    priority: 'low' | 'medium' | 'high';
    description: string;
    originalCode: string;
    optimizedCode: string;
    expectedBenefit: string;
    effort: 'minimal' | 'moderate' | 'significant';
}
export interface SecurityReport {
    riskLevel: 'low' | 'medium' | 'high' | 'critical';
    vulnerabilities: Array<{
        type: string;
        severity: string;
        description: string;
        location: {
            line: number;
            column?: number;
        };
        recommendation: string;
        cwe?: string;
    }>;
    securityScore: number;
    compliance: {
        owasp: boolean;
        gdpr?: boolean;
        hipaa?: boolean;
    };
}
export interface PerformanceEstimate {
    executionTime: {
        best: number;
        average: number;
        worst: number;
        unit: 'ms' | 's' | 'm';
    };
    memoryUsage: {
        estimated: number;
        peak: number;
        unit: 'KB' | 'MB' | 'GB';
    };
    resourceIntensity: 'low' | 'medium' | 'high';
    scalabilityScore: number;
    bottlenecks: Array<{
        location: string;
        description: string;
        impact: 'low' | 'medium' | 'high';
    }>;
}
//# sourceMappingURL=types.d.ts.map