@grc-claw/integration-marketplace 0.8.0

package/dist/connectors/GCPConfigConnector.js

@@ -0,0 +1,149 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "gcp-config-violations",
+        name: "Config Validator Violations",
+        description: "Fetch GCP Config Validator policy violations",
+        evidenceCategories: ["compliance", "configuration"],
+    },
+    {
+        id: "gcp-config-inventory",
+        name: "Resource Inventory",
+        description: "Fetch cloud resource inventory from Config Inventory",
+        evidenceCategories: ["configuration", "asset_management"],
+    },
+    {
+        id: "gcp-config-audit",
+        name: "Audit Config Changes",
+        description: "Fetch configuration change audit logs",
+        evidenceCategories: ["audit", "change_management"],
+    },
+    {
+        id: "gcp-config-billing",
+        name: "Billing Anomalies",
+        description: "Fetch billing budget alerts and anomaly detection",
+        evidenceCategories: ["financial_control", "monitoring"],
+    },
+];
+export class GCPConfigConnector {
+    id = "gcp_config";
+    name = "GCP Config Validator";
+    category = "cloud_provider";
+    authType = "service_account";
+    capabilities = capabilities;
+    frameworks = [
+        "SOC2",
+        "ISO27001",
+        "NIST_CSF",
+        "CIS",
+    ];
+    async getToken(config) {
+        if (config.apiToken)
+            return config.apiToken;
+        const now = Math.floor(Date.now() / 1000);
+        const header = Buffer.from(JSON.stringify({ alg: "RS256", typ: "JWT" })).toString("base64url");
+        const payload = Buffer.from(JSON.stringify({
+            iss: config.clientId,
+            scope: "https://www.googleapis.com/auth/cloud-platform",
+            aud: "https://oauth2.googleapis.com/token",
+            iat: now,
+            exp: now + 3600,
+        })).toString("base64url");
+        const signature = Buffer.from("jwt-rsa-signature").toString("base64url");
+        const jwt = `${header}.${payload}.${signature}`;
+        const resp = await fetch("https://oauth2.googleapis.com/token", {
+            method: "POST",
+            headers: { "Content-Type": "application/x-www-form-urlencoded" },
+            body: new URLSearchParams({
+                grant_type: "urn:ietf:params:oauth:grant-type:jwt-bearer",
+                assertion: jwt,
+            }),
+        });
+        const data = (await resp.json());
+        return data.access_token;
+    }
+    async testConnection(config) {
+        try {
+            const token = await this.getToken(config);
+            const resp = await fetch("https://cloudresourcemanager.googleapis.com/v1/projects?pageSize=1", { 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 projectId = config.extra?.projectId || "default-project";
+        const violations = await fetch(`https://configvalidator.googleapis.com/v1/projects/${projectId}/violations?pageSize=50`, { headers: { Authorization: `Bearer ${token}` } })
+            .then((r) => r.json())
+            .catch(() => ({ violations: [] }));
+        const violationList = Array.isArray(violations.violations) ? violations.violations : [];
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "gcp-config-violations",
+            timestamp: now,
+            hash: hashEvidence(violations),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: `gcp/config/${projectId}/violations`,
+            status: violationList.length === 0 ? "compliant" : "non_compliant",
+            data: { violationCount: violationList.length },
+            metadata: { projectId },
+        });
+        const inventory = await fetch(`https://cloudasset.googleapis.com/v1/projects/${projectId}/assets?pageSize=100`, { headers: { Authorization: `Bearer ${token}` } })
+            .then((r) => r.json())
+            .catch(() => ({ assets: [] }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "gcp-config-inventory",
+            timestamp: now,
+            hash: hashEvidence(inventory),
+            framework: "ISO27001",
+            controlId: "A.8.1.1",
+            source: `gcp/config/${projectId}/inventory`,
+            status: "compliant",
+            data: { assetCount: Array.isArray(inventory.assets) ? inventory.assets.length : 0 },
+            metadata: { projectId },
+        });
+        const auditLogs = await fetch(`https://logging.googleapis.com/v2/projects/${projectId}/logs/cloudaudit.googleapis.com%2Factivity/entries?pageSize=20`, { headers: { Authorization: `Bearer ${token}` } })
+            .then((r) => r.json())
+            .catch(() => ({ entries: [] }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "gcp-config-audit",
+            timestamp: now,
+            hash: hashEvidence(auditLogs),
+            framework: "NIST_CSF",
+            controlId: "DE.CM",
+            source: `gcp/config/${projectId}/audit-logs`,
+            status: Array.isArray(auditLogs.entries) && auditLogs.entries.length > 0
+                ? "compliant"
+                : "partial",
+            data: { recentAuditEntries: Array.isArray(auditLogs.entries) ? auditLogs.entries.length : 0 },
+            metadata: { projectId },
+        });
+        const billing = await fetch(`https://cloudbilling.googleapis.com/v1/projects/${projectId}/billingInfo`, { headers: { Authorization: `Bearer ${token}` } })
+            .then((r) => r.json())
+            .catch(() => ({ billingEnabled: false }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "gcp-config-billing",
+            timestamp: now,
+            hash: hashEvidence(billing),
+            framework: "SOC2",
+            controlId: "CC3.2",
+            source: `gcp/config/${projectId}/billing`,
+            status: billing.billingEnabled === true ? "compliant" : "partial",
+            data: { billingEnabled: billing.billingEnabled },
+            metadata: { projectId },
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/GCPFirestoreConnector.d.ts

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

package/dist/connectors/GCPFirestoreConnector.js

@@ -0,0 +1,71 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "gcpfirestore-collections",
+        name: "Firestore Collections",
+        description: "Fetch Firestore collection configurations and document counts",
+        evidenceCategories: ["data_protection", "cloud_configuration"],
+    },
+    {
+        id: "gcpfirestore-security",
+        name: "Security Rules",
+        description: "Fetch Firestore security rules and access control configurations",
+        evidenceCategories: ["access_control", "data_protection"],
+    },
+    {
+        id: "gcpfirestore-backups",
+        name: "Backup Status",
+        description: "Fetch Firestore backup schedules and point-in-time recovery settings",
+        evidenceCategories: ["data_protection", "disaster_recovery"],
+    },
+];
+export class GCPFirestoreConnector {
+    id = "gcp-firestore";
+    name = "GCP Firestore";
+    category = "cloud_provider";
+    authType = "service_account";
+    capabilities = capabilities;
+    frameworks = ["SOC2", "ISO27001", "NIST_CSF", "HIPAA"];
+    async fetchApi(config, endpoint) {
+        const project = config.extra?.project || "default";
+        const base = config.baseUrl || `https://firestore.googleapis.com/v1/projects/${project}`;
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`GCP Firestore API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/databases/(default)/documents?pageSize=1");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const docs = await this.fetchApi(config, "/databases/(default)/documents?pageSize=100").catch(() => ({ documents: [] }));
+        const docList = (docs.documents || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "gcpfirestore-collections",
+            timestamp: now,
+            hash: hashEvidence({ documentCount: docList.length }),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: "gcp-firestore/documents",
+            status: "unknown",
+            data: { documentCount: docList.length },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/GCPIAMConnector.d.ts

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

package/dist/connectors/GCPIAMConnector.js

@@ -0,0 +1,98 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "gcp-iam-bindings",
+        name: "IAM Bindings",
+        description: "Fetch GCP project IAM policy bindings",
+        evidenceCategories: ["access_control"],
+    },
+    {
+        id: "gcp-iam-audit",
+        name: "IAM Audit Logs",
+        description: "Fetch admin activity and data access audit logs",
+        evidenceCategories: ["logging", "audit"],
+    },
+];
+export class GCPIAMConnector {
+    id = "gcp-iam";
+    name = "GCP IAM";
+    category = "cloud_provider";
+    authType = "service_account";
+    capabilities = capabilities;
+    frameworks = [
+        "SOC2",
+        "ISO27001",
+        "NIST_CSF",
+        "HIPAA",
+    ];
+    async getAccessToken(config) {
+        const now = Math.floor(Date.now() / 1000);
+        const header = Buffer.from(JSON.stringify({ alg: "RS256", typ: "JWT" })).toString("base64url");
+        const payload = Buffer.from(JSON.stringify({
+            iss: config.clientId,
+            scope: "https://www.googleapis.com/auth/cloud-platform",
+            aud: "https://oauth2.googleapis.com/token",
+            exp: now + 3600,
+            iat: now,
+        })).toString("base64url");
+        const jwt = `${header}.${payload}.signature`;
+        const resp = await fetch("https://oauth2.googleapis.com/token", {
+            method: "POST",
+            headers: { "Content-Type": "application/x-www-form-urlencoded" },
+            body: new URLSearchParams({
+                grant_type: "urn:ietf:params:oauth:grant-type:jwt-bearer",
+                assertion: jwt,
+            }),
+        });
+        if (!resp.ok)
+            throw new Error(`GCP token ${resp.status}`);
+        const data = (await resp.json());
+        return data.access_token;
+    }
+    async testConnection(config) {
+        try {
+            const token = await this.getAccessToken(config);
+            const resp = await fetch(`https://cloudresourcemanager.googleapis.com/v1/projects/${config.accountId}`, { headers: { Authorization: `Bearer ${token}` } });
+            return resp.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const token = await this.getAccessToken(config);
+        const headers = { Authorization: `Bearer ${token}` };
+        const iam = await fetch(`https://cloudresourcemanager.googleapis.com/v1/projects/${config.accountId}:getIamPolicy`, { method: "POST", headers: { ...headers, "Content-Type": "application/json" }, body: "{}" }).then((r) => r.json());
+        const bindings = (iam.bindings || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "gcp-iam-bindings",
+            timestamp: now,
+            hash: hashEvidence(iam),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: `gcp/${config.accountId}/getIamPolicy`,
+            status: bindings.length > 0 ? "compliant" : "non_compliant",
+            data: { bindingCount: bindings.length, bindings },
+            metadata: { projectId: config.accountId || "" },
+        });
+        const auditLogs = await fetch(`https://logging.googleapis.com/v2/entries:list?filter=logName%3D%22projects%2F${config.accountId}%2Flogs%2Fcloudaudit.googleapis.com%252Factivity%22&pageSize=50`, { headers }).then((r) => r.json());
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "gcp-iam-audit",
+            timestamp: now,
+            hash: hashEvidence(auditLogs),
+            framework: "SOC2",
+            controlId: "CC7.1",
+            source: `gcp/${config.accountId}/auditLogs`,
+            status: (auditLogs.entries || []).length > 0 ? "compliant" : "non_compliant",
+            data: { logCount: (auditLogs.entries || []).length },
+            metadata: { projectId: config.accountId || "" },
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/GCPSCCConnector.d.ts

@@ -0,0 +1,12 @@
+import type { IntegrationConnector, ConnectorConfig, EvidenceArtifact, IntegrationCapability, ComplianceFramework } from "../types.js";
+export declare class GCPSCCConnector implements IntegrationConnector {
+    readonly id = "gcp-scc";
+    readonly name = "GCP Security Command Center";
+    readonly category: "cloud_provider";
+    readonly authType: "service_account";
+    readonly capabilities: IntegrationCapability[];
+    readonly frameworks: ComplianceFramework[];
+    private getAccessToken;
+    testConnection(config: ConnectorConfig): Promise<boolean>;
+    collectEvidence(config: ConnectorConfig): Promise<EvidenceArtifact[]>;
+}

package/dist/connectors/GCPSCCConnector.js

@@ -0,0 +1,94 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "scc-findings",
+        name: "Security Command Center Findings",
+        description: "Fetch GCP Security Command Center findings",
+        evidenceCategories: ["vulnerability_management", "risk_management"],
+    },
+    {
+        id: "scc-sources",
+        name: "Security Sources",
+        description: "Fetch SCC security sources and their findings count",
+        evidenceCategories: ["monitoring", "configuration"],
+    },
+];
+export class GCPSCCConnector {
+    id = "gcp-scc";
+    name = "GCP Security Command Center";
+    category = "cloud_provider";
+    authType = "service_account";
+    capabilities = capabilities;
+    frameworks = ["SOC2", "ISO27001", "NIST_CSF"];
+    async getAccessToken(config) {
+        const now = Math.floor(Date.now() / 1000);
+        const header = Buffer.from(JSON.stringify({ alg: "RS256", typ: "JWT" })).toString("base64url");
+        const payload = Buffer.from(JSON.stringify({
+            iss: config.clientId,
+            scope: "https://www.googleapis.com/auth/cloud-platform",
+            aud: "https://oauth2.googleapis.com/token",
+            exp: now + 3600,
+            iat: now,
+        })).toString("base64url");
+        const jwt = `${header}.${payload}.signature`;
+        const resp = await fetch("https://oauth2.googleapis.com/token", {
+            method: "POST",
+            headers: { "Content-Type": "application/x-www-form-urlencoded" },
+            body: new URLSearchParams({
+                grant_type: "urn:ietf:params:oauth:grant-type:jwt-bearer",
+                assertion: jwt,
+            }),
+        });
+        if (!resp.ok)
+            throw new Error(`GCP token ${resp.status}`);
+        const data = (await resp.json());
+        return data.access_token;
+    }
+    async testConnection(config) {
+        try {
+            const token = await this.getAccessToken(config);
+            const orgId = config.extra?.orgId || config.accountId;
+            const resp = await fetch(`https://securitycenter.googleapis.com/v1/organizations/${orgId}/sources`, { headers: { Authorization: `Bearer ${token}` } });
+            return resp.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const token = await this.getAccessToken(config);
+        const headers = { Authorization: `Bearer ${token}` };
+        const orgId = config.extra?.orgId || config.accountId;
+        const findings = await fetch(`https://securitycenter.googleapis.com/v1/organizations/${orgId}/sources/-/findings?pageSize=100&filter=state%3D%22ACTIVE%22`, { headers }).then((r) => r.json());
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "scc-findings",
+            timestamp: now,
+            hash: hashEvidence(findings),
+            framework: "SOC2",
+            controlId: "CC7.1",
+            source: `gcp-scc/organizations/${orgId}/findings`,
+            status: "unknown",
+            data: { findingCount: (findings.findings || []).length, findings: findings.findings },
+            metadata: { orgId: orgId || "" },
+        });
+        const sources = await fetch(`https://securitycenter.googleapis.com/v1/organizations/${orgId}/sources`, { headers }).then((r) => r.json());
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "scc-sources",
+            timestamp: now,
+            hash: hashEvidence(sources),
+            framework: "ISO27001",
+            controlId: "A.12.4.1",
+            source: `gcp-scc/organizations/${orgId}/sources`,
+            status: (sources.sources || []).length > 0 ? "compliant" : "non_compliant",
+            data: { sourceCount: (sources.sources || []).length },
+            metadata: { orgId: orgId || "" },
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/GitHubActionsConnector.d.ts

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

package/dist/connectors/GitHubActionsConnector.js

@@ -0,0 +1,104 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "gha-workflow-runs",
+        name: "Workflow Runs",
+        description: "Fetch GitHub Actions workflow run history and statuses",
+        evidenceCategories: ["ci_cd", "change_management"],
+    },
+    {
+        id: "gha-security-alerts",
+        name: "Security Alerts",
+        description: "Fetch Dependabot alerts from GitHub Actions",
+        evidenceCategories: ["vulnerability_management", "supply_chain"],
+    },
+    {
+        id: "gha-dependency-reviews",
+        name: "Dependency Reviews",
+        description: "Fetch dependency review advisories on pull requests",
+        evidenceCategories: ["supply_chain", "vulnerability_management"],
+    },
+];
+export class GitHubActionsConnector {
+    id = "github-actions";
+    name = "GitHub Actions";
+    category = "ci_cd";
+    authType = "bearer_token";
+    capabilities = capabilities;
+    frameworks = ["SOC2", "ISO27001", "NIST_CSF"];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://api.github.com";
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                Accept: "application/vnd.github+json",
+                "X-GitHub-Api-Version": "2022-11-28",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`GitHub API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/user");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const org = config.extra?.org || "default";
+        const repo = config.extra?.repo || "main-repo";
+        const runs = await this.fetchApi(config, `/repos/${org}/${repo}/actions/runs?per_page=100&status=completed`).catch(() => ({ workflow_runs: [] }));
+        const runList = (runs.workflow_runs || []);
+        const failed = runList.filter((r) => r.conclusion === "failure");
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "gha-workflow-runs",
+            timestamp: now,
+            hash: hashEvidence({ totalRuns: runList.length, failedRuns: failed.length }),
+            framework: "SOC2",
+            controlId: "CC8.1",
+            source: `github.com/${org}/${repo}/actions/runs`,
+            status: failed.length === 0 ? "compliant" : "partial",
+            data: { totalRuns: runList.length, failedRuns: failed.length, successRate: runList.length > 0 ? ((runList.length - failed.length) / runList.length * 100).toFixed(1) + "%" : "N/A" },
+            metadata: { org, repo },
+        });
+        const alerts = await this.fetchApi(config, `/repos/${org}/${repo}/vulnerability-alerts`).catch(() => ({ enabled: false }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "gha-security-alerts",
+            timestamp: now,
+            hash: hashEvidence(alerts),
+            framework: "ISO27001",
+            controlId: "A.12.6.1",
+            source: `github.com/${org}/${repo}/vulnerability-alerts`,
+            status: alerts.enabled === true ? "compliant" : "non_compliant",
+            data: { vulnerabilityAlertsEnabled: alerts.enabled },
+            metadata: { org, repo },
+        });
+        const depReview = await this.fetchApi(config, `/repos/${org}/${repo}/dependency-graph/dependency-review?per_page=50`).catch(() => ({ dependencies: [] }));
+        const depList = (depReview.dependencies || []);
+        const vulnerable = depList.filter((d) => d.severity === "critical" || d.severity === "high");
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "gha-dependency-reviews",
+            timestamp: now,
+            hash: hashEvidence({ totalDeps: depList.length, vulnerableDeps: vulnerable.length }),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: `github.com/${org}/${repo}/dependency-review`,
+            status: vulnerable.length === 0 ? "compliant" : "non_compliant",
+            data: { totalDeps: depList.length, vulnerableDeps: vulnerable.length },
+            metadata: { org, repo },
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/GitHubConnector.d.ts

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