@ayurak/sdk 1.0.0

package/dist/index.d.mts

@@ -0,0 +1,547 @@
+interface HttpClientOptions {
+    apiKey: string;
+    baseUrl?: string;
+    timeout?: number;
+}
+declare class HttpClient {
+    private apiKey;
+    private baseUrl;
+    private timeout;
+    constructor(options: HttpClientOptions);
+    private handleResponse;
+    private request;
+    get(path: string, params?: Record<string, string | number | boolean>): Promise<unknown>;
+    post(path: string, body?: Record<string, unknown>, formData?: FormData): Promise<unknown>;
+    put(path: string, body?: Record<string, unknown>): Promise<unknown>;
+    patch(path: string, body?: Record<string, unknown>): Promise<unknown>;
+    delete(path: string): Promise<unknown>;
+}
+
+interface AnalyzeDiagramOptions {
+    filename?: string;
+    analysisDepth?: 'basic' | 'comprehensive' | 'detailed';
+    wait?: boolean;
+    timeout?: number;
+}
+interface ListDiagramsOptions {
+    page?: number;
+    limit?: number;
+    status?: string;
+    search?: string;
+}
+interface Diagram {
+    diagram_id: string;
+    name: string;
+    status: string;
+    threat_count?: number;
+    component_count?: number;
+    created_at: string;
+    updated_at: string;
+    [key: string]: unknown;
+}
+interface Threat {
+    threat_id: string;
+    title: string;
+    description: string;
+    severity: string;
+    cvss_score?: number;
+    mitigations?: string[];
+    [key: string]: unknown;
+}
+interface Component {
+    component_id: string;
+    name: string;
+    type: string;
+    connections?: string[];
+    [key: string]: unknown;
+}
+/**
+ * Threat modeling operations
+ */
+declare class ThreatModelingAPI {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * Upload and analyze a diagram for threats
+     */
+    analyzeDiagram(file: File | Blob, options?: AnalyzeDiagramOptions): Promise<Diagram>;
+    private waitForAnalysis;
+    /**
+     * List diagrams
+     */
+    list(options?: ListDiagramsOptions): Promise<{
+        results: Diagram[];
+        count: number;
+        next?: string;
+        previous?: string;
+    }>;
+    /**
+     * Get diagram details
+     */
+    get(diagramId: string): Promise<Diagram>;
+    /**
+     * Get threats for a diagram
+     */
+    getThreats(diagramId: string): Promise<Threat[]>;
+    /**
+     * Get components detected in diagram
+     */
+    getComponents(diagramId: string): Promise<Component[]>;
+    /**
+     * Run AI-powered analysis on diagram
+     */
+    analyzeWithAI(diagramId: string, analysisTypes?: string[]): Promise<Record<string, unknown>>;
+    /**
+     * Delete a diagram
+     */
+    delete(diagramId: string): Promise<void>;
+    /**
+     * Get threat modeling dashboard
+     */
+    dashboard(period?: 'day' | 'week' | 'month' | 'quarter', includeTrends?: boolean): Promise<Record<string, unknown>>;
+}
+
+interface ScanOptions$1 {
+    standards?: string[];
+    includeRecommendations?: boolean;
+}
+interface ComplianceResult {
+    scan_id: string;
+    overall_score: number;
+    standards: {
+        standard: string;
+        score: number;
+        gaps_count: number;
+    }[];
+    gaps: ComplianceGap[];
+    [key: string]: unknown;
+}
+interface ComplianceGap {
+    gap_id: string;
+    standard: string;
+    control_id: string;
+    severity: string;
+    description: string;
+    recommendation?: string;
+    [key: string]: unknown;
+}
+interface ComplianceStandard {
+    id: string;
+    name: string;
+    description: string;
+    controls_count: number;
+    [key: string]: unknown;
+}
+interface Control {
+    id: string;
+    name: string;
+    description: string;
+    category?: string;
+    severity?: string;
+    [key: string]: unknown;
+}
+/**
+ * Compliance scanning and reporting
+ */
+declare class ComplianceAPI {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * Run compliance scan on a diagram
+     */
+    scan(diagramId: string, options?: ScanOptions$1): Promise<ComplianceResult>;
+    /**
+     * Get compliance report for a diagram
+     */
+    getReport(diagramId: string, format?: 'json' | 'pdf' | 'html'): Promise<Record<string, unknown>>;
+    /**
+     * List available compliance standards
+     */
+    listStandards(): Promise<ComplianceStandard[]>;
+    /**
+     * Get details of a compliance standard
+     */
+    getStandard(standardId: string): Promise<ComplianceStandard>;
+    /**
+     * List controls for a compliance standard
+     */
+    listControls(standardId: string, category?: string): Promise<Control[]>;
+    /**
+     * Get compliance gaps for a diagram
+     */
+    getGaps(diagramId: string, standardId?: string): Promise<ComplianceGap[]>;
+    /**
+     * Create a custom compliance standard
+     */
+    addCustomStandard(name: string, description: string, controls: {
+        id: string;
+        name: string;
+        description: string;
+        severity?: string;
+    }[]): Promise<ComplianceStandard>;
+    /**
+     * Get compliance dashboard metrics
+     */
+    dashboard(period?: 'day' | 'week' | 'month' | 'quarter'): Promise<Record<string, unknown>>;
+}
+
+interface CloudScanOptions {
+    provider?: 'aws' | 'azure' | 'gcp';
+    regions?: string[];
+    services?: string[];
+    complianceStandards?: string[];
+}
+interface CloudScan {
+    scan_id: string;
+    project_id: string;
+    provider: string;
+    status: string;
+    findings_count?: number;
+    critical_count?: number;
+    high_count?: number;
+    created_at: string;
+    [key: string]: unknown;
+}
+interface CloudFinding {
+    finding_id: string;
+    title: string;
+    description: string;
+    severity: string;
+    service: string;
+    resource_id?: string;
+    status: string;
+    remediation?: string;
+    [key: string]: unknown;
+}
+interface CloudAccount {
+    account_id: string;
+    name: string;
+    provider: string;
+    status: string;
+    regions?: string[];
+    created_at: string;
+    [key: string]: unknown;
+}
+interface ListScansOptions {
+    projectId?: string;
+    provider?: string;
+    status?: string;
+    page?: number;
+    limit?: number;
+}
+interface GetFindingsOptions {
+    severity?: string;
+    service?: string;
+    status?: string;
+}
+/**
+ * Cloud security scanning for AWS, Azure, and GCP
+ */
+declare class CloudSecurityAPI {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * Run cloud security scan
+     */
+    scan(projectId: string, options?: CloudScanOptions): Promise<CloudScan>;
+    /**
+     * Get scan details and results
+     */
+    getScan(scanId: string): Promise<CloudScan>;
+    /**
+     * List cloud security scans
+     */
+    listScans(options?: ListScansOptions): Promise<{
+        results: CloudScan[];
+        count: number;
+    }>;
+    /**
+     * Get findings from a scan
+     */
+    getFindings(scanId: string, options?: GetFindingsOptions): Promise<CloudFinding[]>;
+    /**
+     * Connect a cloud account for scanning
+     */
+    connectAccount(provider: 'aws' | 'azure' | 'gcp', credentials: Record<string, string>, options?: {
+        name?: string;
+        regions?: string[];
+    }): Promise<CloudAccount>;
+    /**
+     * List connected cloud accounts
+     */
+    listAccounts(provider?: string): Promise<CloudAccount[]>;
+    /**
+     * Disconnect a cloud account
+     */
+    deleteAccount(accountId: string): Promise<void>;
+    /**
+     * Mark a finding as resolved
+     */
+    resolveFinding(findingId: string, resolution: 'fixed' | 'accepted' | 'false_positive', notes?: string): Promise<CloudFinding>;
+    /**
+     * Suppress a finding
+     */
+    suppressFinding(findingId: string, reason: string, durationDays?: number): Promise<CloudFinding>;
+    /**
+     * Get remediation steps for a finding
+     */
+    getRemediation(findingId: string): Promise<{
+        steps: string[];
+        code_examples?: Record<string, string>;
+    }>;
+    /**
+     * Get cloud security dashboard
+     */
+    dashboard(projectId?: string, period?: 'day' | 'week' | 'month' | 'quarter'): Promise<Record<string, unknown>>;
+}
+
+interface CreateProjectOptions {
+    repositoryUrl?: string;
+    defaultBranch?: string;
+    scanTypes?: ('sast' | 'sca' | 'secrets' | 'iac')[];
+}
+interface ScanOptions {
+    commitSha?: string;
+    branch?: string;
+    scanTypes?: ('sast' | 'sca' | 'secrets' | 'iac')[];
+    failOnSeverity?: 'critical' | 'high' | 'medium' | 'low';
+    wait?: boolean;
+    timeout?: number;
+}
+interface Project {
+    project_id: string;
+    name: string;
+    repository_url?: string;
+    default_branch: string;
+    scan_types: string[];
+    created_at: string;
+    [key: string]: unknown;
+}
+interface PipelineScan {
+    scan_id: string;
+    project_id: string;
+    commit_sha?: string;
+    branch?: string;
+    status: string;
+    findings_count?: number;
+    blocking_findings?: Finding[];
+    summary?: string;
+    created_at: string;
+    [key: string]: unknown;
+}
+interface Finding {
+    finding_id: string;
+    type: string;
+    title: string;
+    description: string;
+    severity: string;
+    file_path?: string;
+    line_number?: number;
+    [key: string]: unknown;
+}
+interface GatesConfig {
+    fail_on_critical?: boolean;
+    fail_on_high?: boolean;
+    max_high_findings?: number;
+    block_secrets?: boolean;
+    required_scan_types?: string[];
+    [key: string]: unknown;
+}
+/**
+ * CI/CD pipeline security scanning
+ */
+declare class PipelineAPI {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * Create a pipeline project
+     */
+    createProject(name: string, options?: CreateProjectOptions): Promise<Project>;
+    /**
+     * List pipeline projects
+     */
+    listProjects(page?: number, limit?: number): Promise<{
+        results: Project[];
+        count: number;
+    }>;
+    /**
+     * Get project details
+     */
+    getProject(projectId: string): Promise<Project>;
+    /**
+     * Delete a pipeline project
+     */
+    deleteProject(projectId: string): Promise<void>;
+    /**
+     * Run pipeline security scan
+     */
+    scan(projectId: string, options?: ScanOptions): Promise<PipelineScan>;
+    private waitForScan;
+    /**
+     * Get scan details and results
+     */
+    getScan(scanId: string): Promise<PipelineScan>;
+    /**
+     * List pipeline scans
+     */
+    listScans(options?: {
+        projectId?: string;
+        status?: string;
+        branch?: string;
+        page?: number;
+        limit?: number;
+    }): Promise<{
+        results: PipelineScan[];
+        count: number;
+    }>;
+    /**
+     * Get findings from a scan
+     */
+    getFindings(scanId: string, options?: {
+        scanType?: string;
+        severity?: string;
+    }): Promise<Finding[]>;
+    /**
+     * Get SAST (static analysis) findings
+     */
+    getSastFindings(scanId: string): Promise<Finding[]>;
+    /**
+     * Get SCA (dependency) findings
+     */
+    getScaFindings(scanId: string): Promise<Finding[]>;
+    /**
+     * Get secrets detection findings
+     */
+    getSecretsFindings(scanId: string): Promise<Finding[]>;
+    /**
+     * Configure security gates for a project
+     */
+    configureGates(projectId: string, gates: GatesConfig): Promise<Project>;
+    /**
+     * Set scan as baseline (suppress existing findings)
+     */
+    addBaseline(projectId: string, scanId: string): Promise<Project>;
+    /**
+     * Suppress a finding
+     */
+    suppressFinding(findingId: string, reason: string, expiresAt?: string): Promise<Finding>;
+    /**
+     * Get pipeline security dashboard
+     */
+    dashboard(projectId?: string, period?: 'day' | 'week' | 'month' | 'quarter'): Promise<Record<string, unknown>>;
+}
+
+interface AribotOptions {
+    baseUrl?: string;
+    timeout?: number;
+}
+/**
+ * Aribot Security Platform client by Aristiun & Ayurak
+ *
+ * Provides access to threat modeling, compliance scanning,
+ * cloud security, and pipeline security APIs.
+ *
+ * @example
+ * ```typescript
+ * import { Aribot } from 'aribot-sdk';
+ *
+ * const client = new Aribot('your_api_key');
+ *
+ * // Threat modeling
+ * const result = await client.threatModeling.analyzeDiagram(file);
+ * const threats = await client.threatModeling.getThreats(result.diagram_id);
+ *
+ * // Compliance scanning
+ * const compliance = await client.compliance.scan(diagramId, {
+ *   standards: ['ISO27001']
+ * });
+ *
+ * // Cloud security
+ * const scan = await client.cloud.scan('aws-123456');
+ *
+ * // Pipeline security
+ * const result = await client.pipeline.scan(projectId, {
+ *   commitSha: 'abc123'
+ * });
+ * ```
+ */
+declare class Aribot {
+    private http;
+    /** Threat modeling operations */
+    threatModeling: ThreatModelingAPI;
+    /** Compliance scanning and reporting */
+    compliance: ComplianceAPI;
+    /** Cloud security scanning */
+    cloud: CloudSecurityAPI;
+    /** Pipeline security scanning */
+    pipeline: PipelineAPI;
+    /**
+     * Create Aribot client
+     *
+     * @param apiKey - Your Aribot API key
+     * @param options - Client configuration options
+     */
+    constructor(apiKey: string, options?: AribotOptions);
+    /**
+     * Check API health status
+     */
+    health(): Promise<{
+        status: string;
+        version: string;
+    }>;
+    /**
+     * Get current user/organization info
+     */
+    me(): Promise<Record<string, unknown>>;
+    /**
+     * Get API usage statistics
+     */
+    usage(period?: 'day' | 'week' | 'month'): Promise<{
+        calls_used: number;
+        calls_limit: number;
+        period: string;
+    }>;
+}
+
+/**
+ * Base error for Aribot SDK
+ */
+declare class AribotError extends Error {
+    statusCode?: number;
+    response?: Record<string, unknown>;
+    constructor(message: string, statusCode?: number, response?: Record<string, unknown>);
+}
+/**
+ * Invalid or missing API key
+ */
+declare class AuthenticationError extends AribotError {
+    constructor(message: string, statusCode?: number, response?: Record<string, unknown>);
+}
+/**
+ * API rate limit exceeded
+ */
+declare class RateLimitError extends AribotError {
+    retryAfter?: number;
+    constructor(message: string, retryAfter?: number, statusCode?: number, response?: Record<string, unknown>);
+}
+/**
+ * Invalid request parameters
+ */
+declare class ValidationError extends AribotError {
+    errors: unknown[];
+    constructor(message: string, errors?: unknown[], statusCode?: number, response?: Record<string, unknown>);
+}
+/**
+ * Resource not found
+ */
+declare class NotFoundError extends AribotError {
+    constructor(message: string, statusCode?: number, response?: Record<string, unknown>);
+}
+/**
+ * Server-side error
+ */
+declare class ServerError extends AribotError {
+    constructor(message: string, statusCode?: number, response?: Record<string, unknown>);
+}
+
+export { type AnalyzeDiagramOptions, Aribot, AribotError, type AribotOptions, AuthenticationError, type CloudAccount, type CloudFinding, type CloudScan, type CloudScanOptions, CloudSecurityAPI, ComplianceAPI, type ComplianceGap, type ComplianceResult, type ScanOptions$1 as ComplianceScanOptions, type ComplianceStandard, type Component, type Control, type CreateProjectOptions, type Diagram, type Finding, type GatesConfig, type GetFindingsOptions, type ListDiagramsOptions, type ListScansOptions, NotFoundError, PipelineAPI, type PipelineScan, type ScanOptions as PipelineScanOptions, type Project, RateLimitError, ServerError, type Threat, ThreatModelingAPI, ValidationError };