types.d.ts

export interface TrustLoopOptions {
  apiKey: string;
  baseUrl?: string;
}

export interface InterceptResult {
  allowed: boolean;
  status?: 'ALLOWED' | 'BLOCKED' | 'PENDING';
  message?: string;
  approval_id?: string;
  rule_matched?: string;
}

export interface ToolCall {
  id: string;
  tenant_id: string;
  tool_name: string;
  arguments: Record<string, unknown>;
  status: 'ALLOWED' | 'BLOCKED' | 'PENDING' | 'APPROVED' | 'DENIED' | 'ERROR';
  result?: unknown;
  rule_matched?: string;
  created_at: string;
}

export interface Stats {
  total: number;
  allowed: number;
  blocked: number;
  pending: number;
  errors: number;
  tenant: {
    name: string | null;
  };
  usage: {
    plan: string;
    used: number;
    limit: number | null;
  };
}

export interface Rule {
  id: string;
  tenant_id: string;
  rule_text: string;
  action: 'approve' | 'block';
  approver_email: string | null;
  enabled: boolean;
  created_at: string;
}

export interface CreateRuleOptions {
  rule_text: string;
  action?: 'approve' | 'block';
  approver_email?: string;
}

export interface BlockedTool {
  id: string;
  tenant_id: string;
  tool_name: string;
  reason: string | null;
  created_at: string;
}

export interface PendingApproval {
  id: string;
  tenant_id: string;
  tool_name: string;
  arguments: Record<string, unknown>;
  rule_matched: string | null;
  approver_email: string | null;
  status: 'pending' | 'approved' | 'denied' | 'expired';
  decided_by: string | null;
  expires_at: string;
  created_at: string;
}

export interface NotificationSettings {
  notify_email: string | null;
  slack_webhook_url: string | null;
  teams_webhook_url: string | null;
  discord_webhook_url: string | null;
}

export interface GetLogsOptions {
  limit?: number;
  offset?: number;
  status?: 'ALLOWED' | 'BLOCKED' | 'PENDING' | 'APPROVED' | 'DENIED' | 'ERROR';
  toolName?: string;
}

export interface OpenAIConfig {
  apiKey: string;
  baseURL: string;
  defaultHeaders: Record<string, string>;
}

export interface OpenAIHelperOptions {
  baseUrl?: string;
}

export interface McpUrlOptions {
  baseUrl?: string;
}

export declare class TrustLoopError extends Error {
  name: 'TrustLoopError';
  status: number;
  constructor(message: string, status: number);
}

export declare class TrustLoop {
  constructor(options: TrustLoopOptions);

  // Core governance
  intercept(toolName: string, args?: Record<string, unknown>): Promise<InterceptResult>;

  // Audit
  getLogs(options?: GetLogsOptions): Promise<ToolCall[]>;
  exportLogs(): Promise<string>;
  getStats(): Promise<Stats>;

  // Rules
  getRules(): Promise<Rule[]>;
  createRule(rule: CreateRuleOptions): Promise<Rule>;
  deleteRule(ruleId: string): Promise<{ success: boolean }>;

  // Kill switch
  getBlockedTools(): Promise<BlockedTool[]>;
  blockTool(toolName: string, reason?: string): Promise<BlockedTool>;
  unblockTool(toolName: string): Promise<{ success: boolean }>;

  // Human approvals
  getPendingApprovals(): Promise<PendingApproval[]>;
  decide(approvalId: string, action: 'approved' | 'denied'): Promise<PendingApproval>;

  // Notifications
  getNotifications(): Promise<NotificationSettings>;
  updateNotifications(settings: Partial<NotificationSettings>): Promise<NotificationSettings>;

  // Static helpers
  static openai(openaiApiKey: string, trustLoopApiKey: string, options?: OpenAIHelperOptions): OpenAIConfig;
  static mcpUrl(trustLoopApiKey: string, options?: McpUrlOptions): string;
}

export default TrustLoop;