doopal/doopal-client.d.ts

JavaScript/TypeScript SDK for Doopal AI Governance Platform

/**
 * TypeScript definitions for Doopal AI Governance JavaScript SDK
 */

export interface DoopalConfig {
    apiKey: string;
    baseUrl?: string;
    timeout?: number;
    maxRetries?: number;
    organizationId?: string;
}

export interface ChatMessage {
    role: string;
    content: string;
}

export interface ChatCompletionParams {
    provider: string;
    model: string;
    messages: ChatMessage[];
    temperature?: number;
    maxTokens?: number;
    stream?: boolean;
    metadata?: Record<string, any>;
}

export interface CompletionParams {
    provider: string;
    model: string;
    prompt: string;
    temperature?: number;
    maxTokens?: number;
    metadata?: Record<string, any>;
}

export interface EmbeddingsParams {
    provider: string;
    model: string;
    inputText: string | string[];
    metadata?: Record<string, any>;
}

export interface DoopalResponse {
    response: string;
    provider: string;
    model: string;
    usage?: {
        prompt_tokens?: number;
        completion_tokens?: number;
        total_tokens?: number;
    };
    metadata?: Record<string, any>;
    redacted_content?: string[];
}

export interface UsageStats {
    total_requests: number;
    total_cost: number;
    requests_by_provider: Record<string, number>;
    cost_by_provider: Record<string, number>;
    redacted_requests: number;
    blocked_requests: number;
}

export interface HealthStatus {
    status: string;
    version: string;
    uptime: number;
    checks: Record<string, boolean>;
}

export interface DetailedHealthStatus {
    status: string;
    version: string;
    uptime: number;
    database: {
        status: string;
        responseTime: number;
        connections: number;
    };
    redis: {
        status: string;
        responseTime: number;
        memory: number;
    };
    aiProviders: Record<string, {
        status: string;
        responseTime: number;
    }>;
    timestamp: string;
}

export interface OrganizationInfo {
    id: string;
    name: string;
    settings: Record<string, any>;
    createdAt: string;
    updatedAt: string;
}

export interface UserRoles {
    role: string;
    permissions: string[];
    organizationId: string;
}

export interface OrganizationMember {
    id: string;
    email: string;
    role: string;
    status: string;
    joinedAt: string;
}

export interface InvitationRequest {
    email: string;
    role: string;
    message?: string;
}

export interface SsoConfig {
    provider: string;
    domain: string;
    clientId: string;
    clientSecret: string;
    enabled?: boolean;
}

export interface AuditLogEntry {
    id: string;
    action: string;
    userId: string;
    organizationId: string;
    timestamp: string;
    details: Record<string, any>;
}

export interface AnalyticsFilters {
    startDate?: string;
    endDate?: string;
    framework?: string;
    severity?: string;
    timeframe?: string;
    metric?: string;
    aggregation?: string;
    provider?: string;
    groupBy?: string;
}

export interface ComplianceStatus {
    framework: string;
    score: number;
    violations: number;
    lastAssessment: string;
    recommendations: string[];
}

export interface ComplianceReportConfig {
    framework: string;
    format: string;
    period: string;
    includeViolations?: boolean;
    includeRemediation?: boolean;
}

export interface ComplianceViolation {
    id: string;
    framework: string;
    severity: string;
    description: string;
    status: string;
    createdAt: string;
    resolvedAt?: string;
}

export interface Policy {
    id: string;
    name: string;
    description: string;
    policyType: string;
    policyContent: string;
    enabled: boolean;
    priority: number;
    createdAt: string;
    updatedAt: string;
}

export interface PolicyTestConfig {
    policyId: string;
    testInput: Record<string, any>;
}

export interface Provider {
    id: string;
    name: string;
    providerType: string;
    apiKey: string;
    modelConfigs: Record<string, any>;
    rateLimits: Record<string, number>;
    enabled: boolean;
}

export interface SecurityThreat {
    id: string;
    type: string;
    severity: string;
    description: string;
    source: string;
    timestamp: string;
    status: string;
}

export interface ObservabilityMetrics {
    metric: string;
    value: number;
    timestamp: string;
    labels: Record<string, string>;
}

export interface SystemAlert {
    id: string;
    name: string;
    severity: string;
    status: string;
    description: string;
    triggeredAt: string;
    resolvedAt?: string;
}

export interface Integration {
    id: string;
    type: string;
    name: string;
    config: Record<string, any>;
    enabled: boolean;
    status: string;
}

export interface ValidationConfig {
    schema: Record<string, any>;
    data: Record<string, any>;
}

export interface ValidationResult {
    valid: boolean;
    errors: string[];
    warnings: string[];
}

export interface PIIValidationResult {
    piiDetected: boolean;
    entities: Array<{
        type: string;
        value: string;
        confidence: number;
        start: number;
        end: number;
    }>;
    redactedContent: string;
}

export class DoopalError extends Error {
    statusCode?: number;
    constructor(message: string, statusCode?: number);
}

export class PolicyViolationError extends DoopalError {
    constructor(message: string);
}

export class RedactionError extends DoopalError {
    constructor(message: string);
}

export class DoopalClient {
    constructor(config: DoopalConfig);
    
    // Core AI Gateway Methods
    chatCompletion(params: ChatCompletionParams): Promise<DoopalResponse | AsyncGenerator<string>>;
    completion(params: CompletionParams): Promise<DoopalResponse>;
    embeddings(params: EmbeddingsParams): Promise<DoopalResponse>;
    getUsageStats(): Promise<UsageStats>;
    
    // Health Check Methods
    healthCheck(): Promise<HealthStatus>;
    getDetailedHealth(): Promise<DetailedHealthStatus>;
    getReadinessStatus(): Promise<HealthStatus>;
    getLivenessStatus(): Promise<HealthStatus>;
    
    // Enterprise Organization Management
    getOrganization(): Promise<OrganizationInfo>;
    updateOrganization(settings: Partial<OrganizationInfo>): Promise<OrganizationInfo>;
    getUserRoles(): Promise<UserRoles>;
    getOrganizationMembers(): Promise<OrganizationMember[]>;
    inviteUser(invitation: InvitationRequest): Promise<{ success: boolean; invitationId: string }>;
    configureSso(ssoConfig: SsoConfig): Promise<{ success: boolean; configId: string }>;
    getAuditLogs(filters?: Record<string, any>): Promise<AuditLogEntry[]>;
    
    // Advanced Analytics
    getComplianceAnalytics(filters?: AnalyticsFilters): Promise<Record<string, any>>;
    getThreatAnalytics(filters?: AnalyticsFilters): Promise<Record<string, any>>;
    getPerformanceAnalytics(filters?: AnalyticsFilters): Promise<Record<string, any>>;
    getCostAnalytics(filters?: AnalyticsFilters): Promise<Record<string, any>>;
    
    // Compliance Reporting
    getComplianceStatus(framework?: string): Promise<ComplianceStatus>;
    generateComplianceReport(reportConfig: ComplianceReportConfig): Promise<{ reportId: string; downloadUrl: string }>;
    getComplianceViolations(filters?: Record<string, any>): Promise<ComplianceViolation[]>;
    
    // Policy Management
    getPolicies(): Promise<Policy[]>;
    createPolicy(policy: Omit<Policy, 'id' | 'createdAt' | 'updatedAt'>): Promise<Policy>;
    updatePolicy(policyId: string, updates: Partial<Policy>): Promise<Policy>;
    deletePolicy(policyId: string): Promise<{ success: boolean }>;
    testPolicy(testConfig: PolicyTestConfig): Promise<{ allowed: boolean; reason?: string }>;
    
    // Provider Management
    getProviders(): Promise<Provider[]>;
    addProvider(provider: Omit<Provider, 'id'>): Promise<Provider>;
    updateProvider(providerId: string, updates: Partial<Provider>): Promise<Provider>;
    
    // Security & Monitoring
    getSecurityThreats(filters?: Record<string, any>): Promise<SecurityThreat[]>;
    getObservabilityMetrics(filters?: Record<string, any>): Promise<ObservabilityMetrics[]>;
    getAlerts(filters?: Record<string, any>): Promise<SystemAlert[]>;
    
    // Integrations
    getIntegrations(): Promise<Integration[]>;
    configureIntegration(integration: Omit<Integration, 'id' | 'status'>): Promise<Integration>;
    
    // Data Validation
    validateStructuredData(validationConfig: ValidationConfig): Promise<ValidationResult>;
    validatePII(content: { content: string }): Promise<PIIValidationResult>;
    
    // OpenAI-Compatible Methods
    openaiChatCompletions(params: {
        model: string;
        messages: ChatMessage[];
        temperature?: number;
        maxTokens?: number;
        stream?: boolean;
    }): Promise<any>;
    openaiEmbeddings(params: { model: string; inputs: string | string[] }): Promise<any>;
    openaiListModels(): Promise<any>;
}

export default DoopalClient;

// Re-export all types for convenience
export {
    DoopalConfig,
    ChatMessage,
    ChatCompletionParams,
    CompletionParams,
    EmbeddingsParams,
    DoopalResponse,
    UsageStats,
    HealthStatus,
    DetailedHealthStatus,
    OrganizationInfo,
    UserRoles,
    OrganizationMember,
    InvitationRequest,
    SsoConfig,
    AuditLogEntry,
    AnalyticsFilters,
    ComplianceStatus,
    ComplianceReportConfig,
    ComplianceViolation,
    Policy,
    PolicyTestConfig,
    Provider,
    SecurityThreat,
    ObservabilityMetrics,
    SystemAlert,
    Integration,
    ValidationConfig,
    ValidationResult,
    PIIValidationResult
};