@grc-claw/integration-marketplace 0.8.0

package/dist/connectors/PowerBIConnector.js

@@ -0,0 +1,95 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "powerbi-workspaces",
+        name: "Workspace Access",
+        description: "Fetch workspace membership and role assignments",
+        evidenceCategories: ["access_control", "configuration"],
+    },
+    {
+        id: "powerbi-datasets",
+        name: "Dataset Governance",
+        description: "Fetch dataset sensitivity labels and certification status",
+        evidenceCategories: ["data_protection", "compliance"],
+    },
+    {
+        id: "powerbi-gateway",
+        name: "On-Premises Gateway",
+        description: "Fetch gateway cluster status and data source credentials",
+        evidenceCategories: ["access_control", "data_protection"],
+    },
+    {
+        id: "powerbi-admin",
+        name: "Admin API",
+        description: "Fetch activity logs and tenant settings",
+        evidenceCategories: ["monitoring", "configuration"],
+    },
+];
+export class PowerBIConnector {
+    id = "powerbi";
+    name = "Microsoft Power BI";
+    category = "data_warehouse";
+    authType = "oauth2";
+    capabilities = capabilities;
+    frameworks = [
+        "SOC2",
+        "ISO27001",
+        "NIST_CSF",
+        "HIPAA",
+        "GDPR",
+    ];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://api.powerbi.com/v1.0/myorg";
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`Power BI API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/groups");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const groups = await this.fetchApi(config, "/groups").catch(() => ({ value: [] }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "powerbi-workspaces",
+            timestamp: now,
+            hash: hashEvidence(groups),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: "powerbi/groups",
+            status: groups.value?.length > 0 ? "compliant" : "unknown",
+            data: { workspaceCount: groups.value?.length || 0 },
+            metadata: {},
+        });
+        const datasets = await this.fetchApi(config, "/datasets").catch(() => ({ value: [] }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "powerbi-datasets",
+            timestamp: now,
+            hash: hashEvidence(datasets),
+            framework: "ISO27001",
+            controlId: "A.8.3.1",
+            source: "powerbi/datasets",
+            status: datasets.value?.length > 0 ? "compliant" : "non_compliant",
+            data: { datasetCount: datasets.value?.length || 0 },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/PrismaCloudConnector.d.ts

@@ -0,0 +1,12 @@
+import type { IntegrationConnector, ConnectorConfig, EvidenceArtifact, IntegrationCapability, ComplianceFramework } from "../types.js";
+export declare class PrismaCloudConnector implements IntegrationConnector {
+    readonly id = "prisma_cloud";
+    readonly name = "Prisma Cloud";
+    readonly category: "cloud_provider";
+    readonly authType: "api_key";
+    readonly capabilities: IntegrationCapability[];
+    readonly frameworks: ComplianceFramework[];
+    private getToken;
+    testConnection(config: ConnectorConfig): Promise<boolean>;
+    collectEvidence(config: ConnectorConfig): Promise<EvidenceArtifact[]>;
+}

package/dist/connectors/PrismaCloudConnector.js

@@ -0,0 +1,147 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "prisma-alerts",
+        name: "Security Alerts",
+        description: "Fetch Prisma Cloud security alerts and policy violations",
+        evidenceCategories: ["vulnerability_management", "threat_detection"],
+    },
+    {
+        id: "prisma-compliance",
+        name: "Compliance Reports",
+        description: "Fetch compliance posture across cloud accounts and frameworks",
+        evidenceCategories: ["compliance", "configuration"],
+    },
+    {
+        id: "prisma-cloud-assets",
+        name: "Cloud Asset Inventory",
+        description: "Fetch discovered cloud assets and misconfigurations",
+        evidenceCategories: ["asset_management", "configuration"],
+    },
+    {
+        id: "prisma-network",
+        name: "Network Security",
+        description: "Fetch network exposure and security group findings",
+        evidenceCategories: ["network_security", "configuration"],
+    },
+];
+export class PrismaCloudConnector {
+    id = "prisma_cloud";
+    name = "Prisma Cloud";
+    category = "cloud_provider";
+    authType = "api_key";
+    capabilities = capabilities;
+    frameworks = [
+        "SOC2",
+        "ISO27001",
+        "NIST_CSF",
+        "PCI_DSS",
+        "HIPAA",
+        "CIS",
+    ];
+    async getToken(config) {
+        const base = config.baseUrl || "https://api.prismacloud.io";
+        const resp = await fetch(`${base}/login`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                username: config.clientId,
+                password: config.clientSecret,
+            }),
+        });
+        const data = (await resp.json());
+        return data.token;
+    }
+    async testConnection(config) {
+        try {
+            const token = await this.getToken(config);
+            const base = config.baseUrl || "https://api.prismacloud.io";
+            const resp = await fetch(`${base}/api/v1/policy`, {
+                headers: { Authorization: `Bearer ${token}` },
+            });
+            return resp.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const token = await this.getToken(config);
+        const base = config.baseUrl || "https://api.prismacloud.io";
+        const headers = { Authorization: `Bearer ${token}` };
+        const cloudAccount = config.extra?.cloudAccount || "default";
+        const alerts = await fetch(`${base}/api/v1/alert?timeRange.amount=7&timeRange.unit=day&status=open`, { headers })
+            .then((r) => r.json())
+            .catch(() => ({ items: [] }));
+        const alertItems = Array.isArray(alerts.items) ? alerts.items : [];
+        const criticalAlerts = alertItems.filter((a) => a.severity === "high" || a.severity === "critical");
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "prisma-alerts",
+            timestamp: now,
+            hash: hashEvidence({ count: alertItems.length }),
+            framework: "SOC2",
+            controlId: "CC7.2",
+            source: `prisma/${cloudAccount}/alerts`,
+            status: criticalAlerts.length === 0 ? "compliant" : "non_compliant",
+            data: { totalAlerts: alertItems.length, criticalHigh: criticalAlerts.length },
+            metadata: { cloudAccount },
+        });
+        const compliance = await fetch(`${base}/api/v1/compliance/posture?cloudType=aws,azure,gcp`, { headers })
+            .then((r) => r.json())
+            .catch(() => ({ items: [] }));
+        const compItems = Array.isArray(compliance.items) ? compliance.items : [];
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "prisma-compliance",
+            timestamp: now,
+            hash: hashEvidence({ count: compItems.length }),
+            framework: "ISO27001",
+            controlId: "A.12.1.1",
+            source: `prisma/${cloudAccount}/compliance`,
+            status: compItems.length > 0 ? "compliant" : "partial",
+            data: { complianceStandards: compItems.length },
+            metadata: { cloudAccount },
+        });
+        const assets = await fetch(`${base}/api/v1/resource?cloudType=aws,azure,gcp&limit=100`, { headers })
+            .then((r) => r.json())
+            .catch(() => ({ items: [] }));
+        const assetItems = Array.isArray(assets.items) ? assets.items : [];
+        const misconfigured = assetItems.filter((a) => a.hasMisconfig === true);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "prisma-cloud-assets",
+            timestamp: now,
+            hash: hashEvidence({ count: assetItems.length }),
+            framework: "NIST_CSF",
+            controlId: "ID.AM",
+            source: `prisma/${cloudAccount}/assets`,
+            status: misconfigured.length === 0 ? "compliant" : "non_compliant",
+            data: { totalAssets: assetItems.length, misconfigured: misconfigured.length },
+            metadata: { cloudAccount },
+        });
+        const network = await fetch(`${base}/api/v1/network/vpc?limit=50`, { headers })
+            .then((r) => r.json())
+            .catch(() => ({ items: [] }));
+        const networkItems = Array.isArray(network.items) ? network.items : [];
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "prisma-network",
+            timestamp: now,
+            hash: hashEvidence({ count: networkItems.length }),
+            framework: "PCI_DSS",
+            controlId: "1.2.1",
+            source: `prisma/${cloudAccount}/network`,
+            status: "compliant",
+            data: { vpcCount: networkItems.length },
+            metadata: { cloudAccount },
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/QualysConnector.d.ts

@@ -0,0 +1,12 @@
+import type { IntegrationConnector, ConnectorConfig, EvidenceArtifact, IntegrationCapability, ComplianceFramework } from "../types.js";
+export declare class QualysConnector implements IntegrationConnector {
+    readonly id = "qualys";
+    readonly name = "Qualys";
+    readonly category: "vulnerability";
+    readonly authType: "basic_auth";
+    readonly capabilities: IntegrationCapability[];
+    readonly frameworks: ComplianceFramework[];
+    private fetchApi;
+    testConnection(config: ConnectorConfig): Promise<boolean>;
+    collectEvidence(config: ConnectorConfig): Promise<EvidenceArtifact[]>;
+}

package/dist/connectors/QualysConnector.js

@@ -0,0 +1,96 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "qualys-vuln-scans",
+        name: "Vulnerability Scans",
+        description: "Fetch Qualys vulnerability scan results and host detections",
+        evidenceCategories: ["vulnerability_management"],
+    },
+    {
+        id: "qualys-compliance-scans",
+        name: "Compliance Scans",
+        description: "Fetch Qualys policy compliance scan results",
+        evidenceCategories: ["compliance", "configuration"],
+    },
+];
+export class QualysConnector {
+    id = "qualys";
+    name = "Qualys";
+    category = "vulnerability";
+    authType = "basic_auth";
+    capabilities = capabilities;
+    frameworks = ["SOC2", "ISO27001", "PCI_DSS", "NIST_CSF"];
+    async fetchApi(config, endpoint, body) {
+        const base = config.baseUrl || "https://qualysapi.qualys.com";
+        const resp = await fetch(`${base}${endpoint}`, {
+            method: body ? "POST" : "GET",
+            headers: {
+                Authorization: `Basic ${Buffer.from(`${config.clientId}:${config.apiToken}`).toString("base64")}`,
+                "Content-Type": body ? "application/x-www-form-urlencoded" : "text/xml",
+                Accept: "application/json",
+            },
+            body,
+        });
+        if (!resp.ok)
+            throw new Error(`Qualys API ${resp.status}: ${resp.statusText}`);
+        return resp.text();
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/api/2.0/fo/user/?action=list");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const vulnScan = await this.fetchApi(config, "/api/2.0/fo/scan/?action=list&output_format=JSON&truncate_limit=100").catch(() => '{"response":{"scan_list":[]}}');
+        let vulnData = {};
+        try {
+            vulnData = JSON.parse(vulnScan);
+        }
+        catch {
+            vulnData = { raw: vulnScan.substring(0, 500) };
+        }
+        const scanList = vulnData.response?.scan_list || [];
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "qualys-vuln-scans",
+            timestamp: now,
+            hash: hashEvidence({ scanCount: Array.isArray(scanList) ? scanList.length : 0 }),
+            framework: "SOC2",
+            controlId: "CC7.1",
+            source: "qualys/scans",
+            status: "unknown",
+            data: { scanCount: Array.isArray(scanList) ? scanList.length : 0 },
+            metadata: {},
+        });
+        const compScan = await this.fetchApi(config, "/api/2.0/compliance_policy/?action=list&output_format=JSON").catch(() => '{"response":{"policy_list":[]}}');
+        let compData = {};
+        try {
+            compData = JSON.parse(compScan);
+        }
+        catch {
+            compData = { raw: compScan.substring(0, 500) };
+        }
+        const policyList = compData.response?.policy_list || [];
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "qualys-compliance-scans",
+            timestamp: now,
+            hash: hashEvidence({ policyCount: Array.isArray(policyList) ? policyList.length : 0 }),
+            framework: "ISO27001",
+            controlId: "A.12.6.1",
+            source: "qualys/compliance",
+            status: "unknown",
+            data: { policyCount: Array.isArray(policyList) ? policyList.length : 0 },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/QualysScannerConnector.d.ts

@@ -0,0 +1,12 @@
+import type { IntegrationConnector, ConnectorConfig, EvidenceArtifact, IntegrationCapability, ComplianceFramework } from "../types.js";
+export declare class QualysScannerConnector implements IntegrationConnector {
+    readonly id = "qualys_scanner";
+    readonly name = "Qualys Scanner";
+    readonly category: "vulnerability";
+    readonly authType: "basic_auth";
+    readonly capabilities: IntegrationCapability[];
+    readonly frameworks: ComplianceFramework[];
+    private fetchApi;
+    testConnection(config: ConnectorConfig): Promise<boolean>;
+    collectEvidence(config: ConnectorConfig): Promise<EvidenceArtifact[]>;
+}

package/dist/connectors/QualysScannerConnector.js

@@ -0,0 +1,131 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "qualys-scan-results",
+        name: "Vulnerability Scan Results",
+        description: "Fetch Qualys vulnerability scan results and QID findings",
+        evidenceCategories: ["vulnerability_management", "asset_management"],
+    },
+    {
+        id: "qualys-compliance",
+        name: "Policy Compliance",
+        description: "Fetch Qualys policy compliance scan results and benchmarks",
+        evidenceCategories: ["compliance", "configuration"],
+    },
+    {
+        id: "qualys-host-detection",
+        name: "Host Detection Results",
+        description: "Fetch host-based vulnerability detection results",
+        evidenceCategories: ["vulnerability_management", "asset_management"],
+    },
+    {
+        id: "qualys-scan-schedule",
+        name: "Scan Schedule Status",
+        description: "Fetch scheduled scan status and completion verification",
+        evidenceCategories: ["monitoring", "change_management"],
+    },
+];
+export class QualysScannerConnector {
+    id = "qualys_scanner";
+    name = "Qualys Scanner";
+    category = "vulnerability";
+    authType = "basic_auth";
+    capabilities = capabilities;
+    frameworks = [
+        "SOC2",
+        "ISO27001",
+        "NIST_CSF",
+        "PCI_DSS",
+        "HIPAA",
+    ];
+    async fetchApi(config, endpoint, body) {
+        const base = config.baseUrl || "https://qualysapi.qualys.com";
+        const resp = await fetch(`${base}${endpoint}`, {
+            method: body ? "POST" : "GET",
+            headers: {
+                Authorization: `Basic ${Buffer.from(`${config.clientId}:${config.clientSecret}`).toString("base64")}`,
+                "Content-Type": body ? "application/x-www-form-urlencoded" : "application/json",
+                Accept: "application/json",
+            },
+            body,
+        });
+        if (!resp.ok)
+            throw new Error(`Qualys API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/api/2.0/fo/asset/?action=list&output_format=JSON&limit=1");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const scanRef = config.extra?.scanRef || "";
+        const scanResults = await this.fetchApi(config, `/api/2.0/fo/scan/?action=list&output_format=JSON&limit=10`).catch(() => ({ scan_list: [] }));
+        const scans = Array.isArray(scanResults.scan_list) ? scanResults.scan_list : [];
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "qualys-scan-results",
+            timestamp: now,
+            hash: hashEvidence(scanResults),
+            framework: "SOC2",
+            controlId: "CC6.6",
+            source: "qualys/scan-results",
+            status: scans.length > 0 ? "compliant" : "partial",
+            data: { recentScans: scans.length },
+            metadata: { scanRef },
+        });
+        const compliance = await this.fetchApi(config, `/api/2.0/fo/compliance/policy/?action=list&output_format=JSON`).catch(() => ({ policy_list: [] }));
+        const policies = Array.isArray(compliance.policy_list) ? compliance.policy_list : [];
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "qualys-compliance",
+            timestamp: now,
+            hash: hashEvidence(compliance),
+            framework: "ISO27001",
+            controlId: "A.12.1.1",
+            source: "qualys/compliance-policies",
+            status: policies.length > 0 ? "compliant" : "partial",
+            data: { compliancePolicies: policies.length },
+            metadata: { scanRef },
+        });
+        const hosts = await this.fetchApi(config, `/api/2.0/fo/asset/?action=list&output_format=JSON&vm_scan_timestamp_after=${new Date(Date.now() - 7 * 86400000).toISOString().split("T")[0]}`).catch(() => ({ asset_list: [] }));
+        const hostList = Array.isArray(hosts.asset_list) ? hosts.asset_list : [];
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "qualys-host-detection",
+            timestamp: now,
+            hash: hashEvidence(hosts),
+            framework: "NIST_CSF",
+            controlId: "DE.CM",
+            source: "qualys/host-detections",
+            status: hostList.length > 0 ? "compliant" : "partial",
+            data: { scannedHosts: hostList.length },
+            metadata: { scanRef },
+        });
+        const schedule = await this.fetchApi(config, `/api/2.0/fo/scan/?action=list&output_format=JSON&state=Completed&limit=5`).catch(() => ({ scan_list: [] }));
+        const completedScans = Array.isArray(schedule.scan_list) ? schedule.scan_list : [];
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "qualys-scan-schedule",
+            timestamp: now,
+            hash: hashEvidence(schedule),
+            framework: "PCI_DSS",
+            controlId: "11.2",
+            source: "qualys/scan-schedule",
+            status: completedScans.length > 0 ? "compliant" : "non_compliant",
+            data: { completedRecentScans: completedScans.length },
+            metadata: { scanRef },
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/QuickBooksConnector.d.ts

@@ -0,0 +1,12 @@
+import type { IntegrationConnector, ConnectorConfig, EvidenceArtifact, IntegrationCapability, ComplianceFramework } from "../types.js";
+export declare class QuickBooksConnector implements IntegrationConnector {
+    readonly id = "quickbooks";
+    readonly name = "QuickBooks";
+    readonly category: "finance";
+    readonly authType: "oauth2";
+    readonly capabilities: IntegrationCapability[];
+    readonly frameworks: ComplianceFramework[];
+    private fetchApi;
+    testConnection(config: ConnectorConfig): Promise<boolean>;
+    collectEvidence(config: ConnectorConfig): Promise<EvidenceArtifact[]>;
+}

package/dist/connectors/QuickBooksConnector.js

@@ -0,0 +1,97 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "quickbooks-users",
+        name: "User Access",
+        description: "Fetch QuickBooks user roles and access permissions",
+        evidenceCategories: ["access_control", "configuration"],
+    },
+    {
+        id: "quickbooks-transactions",
+        name: "Transaction Audit",
+        description: "Fetch financial transaction logs and change history",
+        evidenceCategories: ["monitoring", "access_control"],
+    },
+    {
+        id: "quickbooks-classes",
+        name: "Class Tracking",
+        description: "Fetch class and department tracking configurations",
+        evidenceCategories: ["configuration", "compliance"],
+    },
+    {
+        id: "quickbooks-backup",
+        name: "Backup Status",
+        description: "Fetch automatic backup configurations and status",
+        evidenceCategories: ["data_protection", "configuration"],
+    },
+];
+export class QuickBooksConnector {
+    id = "quickbooks";
+    name = "QuickBooks";
+    category = "finance";
+    authType = "oauth2";
+    capabilities = capabilities;
+    frameworks = [
+        "SOC2",
+        "ISO27001",
+        "NIST_CSF",
+    ];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://quickbooks.api.intuit.com/v3";
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                Accept: "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`QuickBooks API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/companyinfo/1?minorversion=65");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const companyId = config.extra?.companyId || "1";
+        const users = await this.fetchApi(config, `/company/${companyId}/users`).catch(() => ({ QueryResponse: { User: [] } }));
+        const userList = users;
+        const qr = userList.QueryResponse || {};
+        const userListArr = qr.User || [];
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "quickbooks-users",
+            timestamp: now,
+            hash: hashEvidence(users),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: `quickbooks/${companyId}/users`,
+            status: userListArr.length > 0 ? "compliant" : "unknown",
+            data: { userCount: userListArr.length },
+            metadata: { companyId },
+        });
+        const company = await this.fetchApi(config, `/company/${companyId}/companyinfo/${companyId}`).catch(() => ({}));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "quickbooks-classes",
+            timestamp: now,
+            hash: hashEvidence(company),
+            framework: "ISO27001",
+            controlId: "A.6.2.1",
+            source: `quickbooks/${companyId}/companyinfo`,
+            status: "partial",
+            data: company,
+            metadata: { companyId },
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/RabbitMQConnector.d.ts

@@ -0,0 +1,12 @@
+import type { IntegrationConnector, ConnectorConfig, EvidenceArtifact, IntegrationCapability, ComplianceFramework } from "../types.js";
+export declare class RabbitMQConnector implements IntegrationConnector {
+    readonly id = "rabbitmq";
+    readonly name = "RabbitMQ";
+    readonly category: "data_warehouse";
+    readonly authType: "api_key";
+    readonly capabilities: IntegrationCapability[];
+    readonly frameworks: ComplianceFramework[];
+    private fetchApi;
+    testConnection(config: ConnectorConfig): Promise<boolean>;
+    collectEvidence(config: ConnectorConfig): Promise<EvidenceArtifact[]>;
+}