@grc-claw/integration-marketplace 0.8.0

package/dist/connectors/McAfeeConnector.js

@@ -0,0 +1,85 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "mcafee-endpoints",
+        name: "Endpoint Protection",
+        description: "Fetch McAfee/Trellix endpoint agent status and protection health",
+        evidenceCategories: ["endpoint_security", "monitoring"],
+    },
+    {
+        id: "mcafee-detections",
+        name: "Threat Detections",
+        description: "Fetch threat detection and remediation event history",
+        evidenceCategories: ["vulnerability_management", "monitoring"],
+    },
+    {
+        id: "mcafee-policies",
+        name: "Security Policies",
+        description: "Fetch McAfee ePO policy assignments and compliance reports",
+        evidenceCategories: ["policy_compliance", "configuration"],
+    },
+];
+export class McAfeeConnector {
+    id = "mcafee";
+    name = "McAfee (Trellix)";
+    category = "endpoint";
+    authType = "api_key";
+    capabilities = capabilities;
+    frameworks = ["SOC2", "ISO27001", "NIST_CSF", "HIPAA"];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://api.trellix.com/v1";
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`McAfee API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/devices?pageSize=1");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const devices = await this.fetchApi(config, "/devices?pageSize=100").catch(() => ({ data: [] }));
+        const deviceList = (devices.data || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "mcafee-endpoints",
+            timestamp: now,
+            hash: hashEvidence({ deviceCount: deviceList.length }),
+            framework: "SOC2",
+            controlId: "CC6.8",
+            source: "mcafee/devices",
+            status: deviceList.length > 0 ? "compliant" : "unknown",
+            data: { endpointCount: deviceList.length },
+            metadata: {},
+        });
+        const threats = await this.fetchApi(config, "/events?pageSize=10").catch(() => ({ data: [] }));
+        const threatList = (threats.data || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "mcafee-detections",
+            timestamp: now,
+            hash: hashEvidence({ threatCount: threatList.length }),
+            framework: "ISO27001",
+            controlId: "A.12.2.1",
+            source: "mcafee/events",
+            status: threatList.length === 0 ? "compliant" : "non_compliant",
+            data: { recentThreats: threatList.length },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/Microsoft365Connector.d.ts

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

package/dist/connectors/Microsoft365Connector.js

@@ -0,0 +1,139 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "m365-users",
+        name: "Users & Groups",
+        description: "Fetch Microsoft 365 user accounts, licenses, and group memberships",
+        evidenceCategories: ["identity_management", "access_control"],
+    },
+    {
+        id: "m365-sharepoint",
+        name: "SharePoint Sites",
+        description: "Fetch SharePoint site inventory and sharing configurations",
+        evidenceCategories: ["document_management", "data_protection"],
+    },
+    {
+        id: "m365-teams",
+        name: "Teams Settings",
+        description: "Fetch Microsoft Teams policies and external access configurations",
+        evidenceCategories: ["communication", "data_protection"],
+    },
+    {
+        id: "m365-exchange",
+        name: "Exchange Online",
+        description: "Fetch Exchange Online mail flow and security configurations",
+        evidenceCategories: ["email_security", "configuration"],
+    },
+    {
+        id: "m365-audit",
+        name: "Unified Audit Log",
+        description: "Fetch Microsoft 365 unified audit log entries",
+        evidenceCategories: ["audit_logging", "compliance"],
+    },
+];
+export class Microsoft365Connector {
+    id = "microsoft-365";
+    name = "Microsoft 365";
+    category = "workspace";
+    authType = "oauth2";
+    capabilities = capabilities;
+    frameworks = ["SOC2", "ISO27001", "NIST_CSF", "HIPAA", "PCI_DSS"];
+    async fetchGraph(config, endpoint) {
+        const base = config.baseUrl || "https://graph.microsoft.com/v1.0";
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: { Authorization: `Bearer ${config.apiToken}` },
+        });
+        if (!resp.ok)
+            throw new Error(`Microsoft Graph ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchGraph(config, "/me");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const users = await this.fetchGraph(config, "/users?$top=100&$select=id,displayName,accountEnabled,assignedLicenses").catch(() => ({ value: [] }));
+        const userList = (users.value || []);
+        const disabled = userList.filter((u) => u.accountEnabled === false);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "m365-users",
+            timestamp: now,
+            hash: hashEvidence({ total: userList.length, disabled: disabled.length }),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: "microsoft365/users",
+            status: "unknown",
+            data: { userCount: userList.length, disabledCount: disabled.length },
+            metadata: { tenantId: config.tenantId || "" },
+        });
+        const sites = await this.fetchGraph(config, "/sites?$top=50").catch(() => ({ value: [] }));
+        const siteList = (sites.value || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "m365-sharepoint",
+            timestamp: now,
+            hash: hashEvidence({ siteCount: siteList.length }),
+            framework: "ISO27001",
+            controlId: "A.8.3.2",
+            source: "microsoft365/sites",
+            status: "unknown",
+            data: { siteCount: siteList.length },
+            metadata: { tenantId: config.tenantId || "" },
+        });
+        const teams = await this.fetchGraph(config, "/teams?$top=50").catch(() => ({ value: [] }));
+        const teamList = (teams.value || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "m365-teams",
+            timestamp: now,
+            hash: hashEvidence({ teamCount: teamList.length }),
+            framework: "SOC2",
+            controlId: "CC6.4",
+            source: "microsoft365/teams",
+            status: "unknown",
+            data: { teamCount: teamList.length },
+            metadata: { tenantId: config.tenantId || "" },
+        });
+        const mailConfig = await this.fetchGraph(config, "/admin.exchange/settings?%24select=mailFlowConfiguration").catch(() => ({}));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "m365-exchange",
+            timestamp: now,
+            hash: hashEvidence(mailConfig),
+            framework: "SOC2",
+            controlId: "CC6.7",
+            source: "microsoft365/exchange",
+            status: "unknown",
+            data: { mailConfig },
+            metadata: { tenantId: config.tenantId || "" },
+        });
+        const audit = await this.fetchGraph(config, "/audit/dimensions/logs/activities?%24top=100&%24orderby=activityDateTime%20desc").catch(() => ({ value: [] }));
+        const auditItems = (audit.value || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "m365-audit",
+            timestamp: now,
+            hash: hashEvidence({ logCount: auditItems.length }),
+            framework: "SOC2",
+            controlId: "CC7.2",
+            source: "microsoft365/audit",
+            status: "unknown",
+            data: { auditLogCount: auditItems.length },
+            metadata: { tenantId: config.tenantId || "" },
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/MongoDBConnector.d.ts

@@ -0,0 +1,12 @@
+import type { IntegrationConnector, ConnectorConfig, EvidenceArtifact, IntegrationCapability, ComplianceFramework } from "../types.js";
+export declare class MongoDBConnector implements IntegrationConnector {
+    readonly id = "mongodb";
+    readonly name = "MongoDB Atlas";
+    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[]>;
+}

package/dist/connectors/MongoDBConnector.js

@@ -0,0 +1,86 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "mongodb-clusters",
+        name: "Atlas Clusters",
+        description: "Fetch MongoDB Atlas cluster configurations and backup status",
+        evidenceCategories: ["data_protection", "cloud_configuration"],
+    },
+    {
+        id: "mongodb-access",
+        name: "Database Access",
+        description: "Fetch MongoDB Atlas database user roles and IP whitelist entries",
+        evidenceCategories: ["access_control", "data_protection"],
+    },
+    {
+        id: "mongodb-audit",
+        name: "Audit Logs",
+        description: "Fetch MongoDB Atlas audit log events and authentication attempts",
+        evidenceCategories: ["monitoring", "audit"],
+    },
+];
+export class MongoDBConnector {
+    id = "mongodb";
+    name = "MongoDB Atlas";
+    category = "data_warehouse";
+    authType = "api_key";
+    capabilities = capabilities;
+    frameworks = ["SOC2", "ISO27001", "NIST_CSF", "HIPAA", "PCI_DSS"];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://cloud.mongodb.com/api/public/v1.0";
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`MongoDB 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 groupId = config.extra?.groupId || "default";
+        const clusters = await this.fetchApi(config, `/groups/${groupId}/clusters`).catch(() => ({ results: [] }));
+        const clusterList = (clusters.results || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "mongodb-clusters",
+            timestamp: now,
+            hash: hashEvidence({ clusterCount: clusterList.length }),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: "mongodb/clusters",
+            status: clusterList.length > 0 ? "compliant" : "unknown",
+            data: { clusterCount: clusterList.length },
+            metadata: { groupId },
+        });
+        const users = await this.fetchApi(config, `/groups/${groupId}/databaseUsers`).catch(() => ({ results: [] }));
+        const userList = (users.results || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "mongodb-access",
+            timestamp: now,
+            hash: hashEvidence({ userCount: userList.length }),
+            framework: "ISO27001",
+            controlId: "A.9.2.1",
+            source: "mongodb/databaseUsers",
+            status: "unknown",
+            data: { databaseUserCount: userList.length },
+            metadata: { groupId },
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/NamelyConnector.d.ts

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

package/dist/connectors/NamelyConnector.js

@@ -0,0 +1,97 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "namely-employees",
+        name: "Employee Profiles",
+        description: "Fetch employee directory and employment data",
+        evidenceCategories: ["access_control", "data_protection"],
+    },
+    {
+        id: "namely-pto",
+        name: "Time Off Management",
+        description: "Fetch PTO policies and approval workflows",
+        evidenceCategories: ["compliance", "configuration"],
+    },
+    {
+        id: "namely-performance",
+        name: "Performance Reviews",
+        description: "Fetch review cycle status and goal completion",
+        evidenceCategories: ["compliance", "monitoring"],
+    },
+    {
+        id: "namely-audit",
+        name: "Audit Logs",
+        description: "Fetch employee data change and access logs",
+        evidenceCategories: ["monitoring", "access_control"],
+    },
+];
+export class NamelyConnector {
+    id = "namely";
+    name = "Namely";
+    category = "hr";
+    authType = "api_key";
+    capabilities = capabilities;
+    frameworks = [
+        "SOC2",
+        "ISO27001",
+        "NIST_CSF",
+    ];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://api.namely.com";
+        const resp = await fetch(`${base}/api/v1${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`Namely API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/employees?limit=1");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const employees = await this.fetchApi(config, "/employees?limit=100").catch(() => ({
+            employees: [],
+        }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "namely-employees",
+            timestamp: now,
+            hash: hashEvidence(employees),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: "namely/employees",
+            status: employees.employees?.length > 0 ? "compliant" : "unknown",
+            data: { employeeCount: employees.employees?.length || 0 },
+            metadata: {},
+        });
+        const pto = await this.fetchApi(config, "/time_off/policies").catch(() => ({
+            time_off_policies: [],
+        }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "namely-pto",
+            timestamp: now,
+            hash: hashEvidence(pto),
+            framework: "ISO27001",
+            controlId: "A.6.2.1",
+            source: "namely/pto-policies",
+            status: pto.time_off_policies?.length > 0 ? "compliant" : "non_compliant",
+            data: { ptoPolicies: pto.time_off_policies?.length || 0 },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/Neo4jConnector.d.ts

@@ -0,0 +1,12 @@
+import type { IntegrationConnector, ConnectorConfig, EvidenceArtifact, IntegrationCapability, ComplianceFramework } from "../types.js";
+export declare class Neo4jConnector implements IntegrationConnector {
+    readonly id = "neo4j";
+    readonly name = "Neo4j";
+    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[]>;
+}

package/dist/connectors/Neo4jConnector.js

@@ -0,0 +1,70 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "neo4j-databases",
+        name: "Neo4j Databases",
+        description: "Fetch Neo4j database configurations and graph statistics",
+        evidenceCategories: ["data_protection", "cloud_configuration"],
+    },
+    {
+        id: "neo4j-security",
+        name: "Security Configurations",
+        description: "Fetch Neo4j authentication, role-based access, and TLS settings",
+        evidenceCategories: ["access_control", "encryption"],
+    },
+    {
+        id: "neo4j-queries",
+        name: "Query Audit",
+        description: "Fetch Neo4j query logs and slow query monitoring",
+        evidenceCategories: ["monitoring", "audit"],
+    },
+];
+export class Neo4jConnector {
+    id = "neo4j";
+    name = "Neo4j";
+    category = "data_warehouse";
+    authType = "api_key";
+    capabilities = capabilities;
+    frameworks = ["SOC2", "ISO27001", "NIST_CSF"];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://api.neo4j.example.com/v1";
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`Neo4j API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/instances?limit=1");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const instances = await this.fetchApi(config, "/instances?limit=100").catch(() => ({ items: [] }));
+        const instanceList = (instances.items || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "neo4j-databases",
+            timestamp: now,
+            hash: hashEvidence({ instanceCount: instanceList.length }),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: "neo4j/instances",
+            status: instanceList.length > 0 ? "compliant" : "unknown",
+            data: { instanceCount: instanceList.length },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/NetSuiteConnector.d.ts

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

package/dist/connectors/NetSuiteConnector.js

@@ -0,0 +1,94 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "netsuite-financial",
+        name: "Financial Controls",
+        description: "Fetch financial reporting access and approval workflows",
+        evidenceCategories: ["access_control", "compliance"],
+    },
+    {
+        id: "netsuite-roles",
+        name: "Role-Based Access",
+        description: "Fetch NetSuite roles and permission configurations",
+        evidenceCategories: ["access_control", "configuration"],
+    },
+    {
+        id: "netsuite-audit",
+        name: "System Notes",
+        description: "Fetch data change audit trails and system notes",
+        evidenceCategories: ["monitoring", "access_control"],
+    },
+    {
+        id: "netsuite-approvals",
+        name: "Approval Policies",
+        description: "Fetch purchase order and expense approval rules",
+        evidenceCategories: ["change_management", "compliance"],
+    },
+];
+export class NetSuiteConnector {
+    id = "netsuite";
+    name = "NetSuite";
+    category = "finance";
+    authType = "api_key";
+    capabilities = capabilities;
+    frameworks = [
+        "SOC2",
+        "ISO27001",
+        "NIST_CSF",
+        "PCI_DSS",
+    ];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://rest.netsuite.com";
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`NetSuite API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/app/site/hosting/restlet.nl");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const roles = await this.fetchApi(config, "/app/site/hosting/restlet.nl?script=roles").catch(() => ({ roles: [] }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "netsuite-roles",
+            timestamp: now,
+            hash: hashEvidence(roles),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: "netsuite/roles",
+            status: roles.roles?.length > 0 ? "compliant" : "unknown",
+            data: { roleCount: roles.roles?.length || 0 },
+            metadata: {},
+        });
+        const audit = await this.fetchApi(config, "/app/site/hosting/restlet.nl?script=audit").catch(() => ({ records: [] }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "netsuite-audit",
+            timestamp: now,
+            hash: hashEvidence(audit),
+            framework: "ISO27001",
+            controlId: "A.12.4.1",
+            source: "netsuite/audit",
+            status: "partial",
+            data: { auditRecords: audit.records?.length || 0 },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/NetskopeConnector.d.ts

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