@mindmakr/gs-websdk/dist/services/ai.d.ts

Web SDK for Guru SaaS System - Complete JavaScript/TypeScript SDK for building applications with dynamic schema management

/**
 * AI Enhancement Service Module
 * Provides AI-powered schema generation and field enhancement capabilities
 */
import { GuruSaaSClient } from '../core/client';
import { RequestConfig, AIFieldSuggestion, FieldEnhancement, ValidationRule } from '../types';
export interface AIFieldNameRequest {
    fieldType: string;
    businessContext: string;
    existingFields: string[];
    userIntent?: string;
    templateCategory?: string;
}
export interface AIFieldNameResponse {
    suggestions: AIFieldSuggestion[];
    confidence: number;
    reasoning: string;
}
export interface AIValidationRequest {
    fieldName: string;
    fieldType: string;
    businessDomain: string;
    existingValidation?: ValidationRule[];
    templateCategory?: string;
}
export interface AIValidationSuggestion {
    rules: ValidationRule[];
    patterns: Record<string, string>;
    errorMessages: Record<string, Record<string, string>>;
    confidence: number;
    reasoning: string;
    businessContext: string[];
}
export interface AIValidationResponse {
    suggestions: AIValidationSuggestion;
    confidence: number;
    reasoning: string;
}
export interface AIFieldTypeRequest {
    fieldName: string;
    businessContext: string;
    userIntent?: string;
    existingFields?: string[];
}
export interface AIFieldTypeResponse {
    suggestedType: string;
    alternatives: string[];
    enhancement: FieldEnhancement;
    confidence: number;
    reasoning: string;
}
export interface AISchemaGenerationRequest {
    businessDescription: string;
    industry?: string;
    formType?: 'registration' | 'profile' | 'contact' | 'feedback' | 'order' | 'custom';
    existingFields?: string[];
    requirements?: string[];
    language?: string;
}
export interface AISchemaGenerationResponse {
    schema: Record<string, any>;
    metadata: {
        title: string;
        description: string;
        category: string;
        confidence: number;
        reasoning: string;
    };
    fieldSuggestions: Array<{
        key: string;
        type: string;
        title: string;
        description: string;
        enhancement: FieldEnhancement;
        reasoning: string;
    }>;
}
export interface AIContextAnalysisRequest {
    businessDomain: string;
    existingSchema?: Record<string, any>;
    userGoals?: string[];
    targetAudience?: string;
}
export interface AIContextAnalysisResponse {
    recommendations: Array<{
        type: 'field_addition' | 'field_modification' | 'validation_improvement' | 'ui_enhancement';
        title: string;
        description: string;
        impact: 'low' | 'medium' | 'high';
        implementation: Record<string, any>;
    }>;
    insights: {
        domainSpecificFields: string[];
        suggestedCategories: string[];
        complianceConsiderations: string[];
        userExperienceNotes: string[];
    };
    confidence: number;
}
export interface ConversationMessage {
    role: 'user' | 'assistant' | 'system';
    content: string;
    timestamp: Date;
    metadata?: Record<string, any>;
}
export interface Conversation {
    id: string;
    user_id: string;
    tenant_id: string;
    name: string;
    metadata: Record<string, any>;
    created_at: string;
    updated_at: string;
    messages?: ConversationMessage[];
}
export interface FunctionCall {
    name: string;
    arguments: Record<string, any>;
    description?: string;
}
export interface ConversationResponse {
    type: 'text' | 'action' | 'form' | 'diagram' | 'data';
    content: string;
    responseFormat?: 'text' | 'form' | 'diagram' | 'table' | 'code';
    functionCall?: FunctionCall;
    renderedContent?: any;
    metadata?: {
        tokensUsed?: number;
        model?: string;
        processingTime?: number;
    };
}
export declare class AIService {
    private client;
    constructor(client: GuruSaaSClient);
    /**
     * Get AI service health status (ACTUAL ENDPOINT)
     */
    getHealthStatus(config?: RequestConfig): Promise<{
        status: string;
        message: string;
        service?: string;
        timestamp?: string;
        uptime?: number;
        environment?: string;
    }>;
    /**
     * Get schema knowledge for a business domain and category
     */
    getSchemaKnowledge(businessDomain: string, category: string, config?: RequestConfig): Promise<{
        insights: {
            commonFields: string[];
            bestPractices: string[];
            validationPatterns: Record<string, string>;
        };
        recommendations: Array<{
            type: string;
            title: string;
            description: string;
        }>;
        confidence: number;
    }>;
    /**
     * Edit schema with AI assistance
     */
    editSchema(request: {
        templateId: number;
        currentSchema: Record<string, any>;
        editInstruction: string;
        preserveData?: boolean;
        businessContext?: string;
    }, config?: RequestConfig): Promise<{
        modifiedSchema: Record<string, any>;
        changes: Array<{
            type: string;
            field: string;
            description: string;
            oldValue?: any;
            newValue?: any;
        }>;
        breakingChanges: string[];
        confidence: number;
        recommendations: string[];
        contextUsed?: {
            templatesAnalyzed: number;
            patternsFound: number;
            fieldsExtracted: number;
            filesProcessed: number;
        };
    }>;
    /**
     * Create a new conversation
     */
    createConversation(data: {
        name: string;
        metadata?: Record<string, any>;
    }, config?: RequestConfig): Promise<Conversation>;
    /**
     * Get all conversations
     */
    getConversations(config?: RequestConfig): Promise<Conversation[]>;
    /**
     * Get a specific conversation by ID
     */
    getConversation(conversationId: string, config?: RequestConfig): Promise<Conversation>;
    /**
     * Delete a conversation
     */
    deleteConversation(conversationId: string, config?: RequestConfig): Promise<void>;
    /**
     * Process a conversation message
     */
    processConversation(data: {
        message: string;
        userId: string;
        tenantId: string;
        conversationId?: string;
        context?: {
            businessDomain?: string;
            sessionId?: string;
            contextFiles?: any[];
            schemaTemplates?: any[];
            currentSchema?: any;
            userRole?: string;
        };
    }, config?: RequestConfig): Promise<ConversationResponse>;
    /**
     * Execute AI function
     */
    executeFunction(data: {
        functionName: string;
        parameters: Record<string, any>;
        userId: string;
        tenantId: string;
        conversationId?: string;
        requiresConfirmation?: boolean;
    }, config?: RequestConfig): Promise<{
        success: boolean;
        result?: any;
        error?: string;
        requiresConfirmation?: boolean;
        confirmationMessage?: string;
    }>;
    /**
     * Analyze context for AI suggestions
     */
    analyzeContext(data: {
        context: string;
        type?: string;
    }, config?: RequestConfig): Promise<{
        success: boolean;
        data: any;
    }>;
    /**
     * Suggest field name based on context
     */
    suggestFieldName(data: {
        context: string;
        existing_fields?: string[];
    }, config?: RequestConfig): Promise<{
        success: boolean;
        data: {
            suggested_name: string;
        };
    }>;
    /**
     * Suggest validation rules for a field
     */
    suggestValidation(data: {
        field_type: string;
        context: string;
    }, config?: RequestConfig): Promise<{
        success: boolean;
        data: {
            validation_rules: Record<string, any>;
        };
    }>;
    /**
     * Suggest field type based on context
     */
    suggestFieldType(data: {
        context: string;
        field_name?: string;
    }, config?: RequestConfig): Promise<{
        success: boolean;
        data: {
            suggested_type: string;
            confidence?: number;
        };
    }>;
    /**
     * Suggest field enhancements for schema
     * Note: This endpoint may not be working according to api-status.md
     */
    suggestFields(data: {
        schema_context: string;
        existing_fields?: any[];
        requirements?: string;
    }, config?: RequestConfig): Promise<{
        success: boolean;
        data: {
            suggested_fields: any[];
        };
    }>;
}