@grc-claw/integration-marketplace 0.8.0

package/dist/connectors/DocuSignConnector.js

@@ -0,0 +1,96 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "docusign-templates",
+        name: "Envelope Templates",
+        description: "Fetch document templates and signing configurations",
+        evidenceCategories: ["access_control", "configuration"],
+    },
+    {
+        id: "docusign-security",
+        name: "Security Policies",
+        description: "Fetch access codes, identity verification, and authentication settings",
+        evidenceCategories: ["access_control", "data_protection"],
+    },
+    {
+        id: "docusign-audit",
+        name: "Envelope History",
+        description: "Fetch signing ceremony audit trails and completion logs",
+        evidenceCategories: ["monitoring", "access_control"],
+    },
+    {
+        id: "docusign-admin",
+        name: "Admin Users",
+        description: "Fetch admin user permissions and group memberships",
+        evidenceCategories: ["access_control", "configuration"],
+    },
+];
+export class DocuSignConnector {
+    id = "docusign";
+    name = "DocuSign";
+    category = "finance";
+    authType = "api_key";
+    capabilities = capabilities;
+    frameworks = [
+        "SOC2",
+        "ISO27001",
+        "NIST_CSF",
+        "HIPAA",
+        "PCI_DSS",
+    ];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://demo.docusign.net";
+        const resp = await fetch(`${base}/restapi/v2.1${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`DocuSign API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/accounts");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const accountId = config.extra?.accountId || "";
+        const templates = await this.fetchApi(config, `/accounts/${accountId}/templates`).catch(() => ({ envelopeTemplates: [] }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "docusign-templates",
+            timestamp: now,
+            hash: hashEvidence(templates),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: `docusign/${accountId}/templates`,
+            status: templates.envelopeTemplates?.length > 0 ? "compliant" : "unknown",
+            data: { templateCount: templates.envelopeTemplates?.length || 0 },
+            metadata: { accountId },
+        });
+        const envelopes = await this.fetchApi(config, `/accounts/${accountId}/envelopes?from_date=2024-01-01&count=10`).catch(() => ({ envelopes: [] }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "docusign-audit",
+            timestamp: now,
+            hash: hashEvidence(envelopes),
+            framework: "ISO27001",
+            controlId: "A.12.4.1",
+            source: `docusign/${accountId}/envelopes`,
+            status: "partial",
+            data: { recentEnvelopes: envelopes.envelopes?.length || 0 },
+            metadata: { accountId },
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/DriftConnector.d.ts

@@ -0,0 +1,12 @@
+import type { IntegrationConnector, ConnectorConfig, EvidenceArtifact, IntegrationCapability, ComplianceFramework } from "../types.js";
+export declare class DriftConnector implements IntegrationConnector {
+    readonly id = "drift";
+    readonly name = "Drift";
+    readonly category: "communication";
+    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/DriftConnector.js

@@ -0,0 +1,69 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "drift-conversations",
+        name: "Conversations",
+        description: "Fetch Drift chatbot conversation logs and lead capture metrics",
+        evidenceCategories: ["communication", "monitoring"],
+    },
+    {
+        id: "drift-security",
+        name: "Security Settings",
+        description: "Fetch Drift SSO, API access controls, and data retention settings",
+        evidenceCategories: ["access_control", "data_protection"],
+    },
+    {
+        id: "drift-playbooks",
+        name: "Playbook Configurations",
+        description: "Fetch Drift playbook definitions, routing rules, and approval workflows",
+        evidenceCategories: ["configuration", "change_management"],
+    },
+];
+export class DriftConnector {
+    id = "drift";
+    name = "Drift";
+    category = "communication";
+    authType = "api_key";
+    capabilities = capabilities;
+    frameworks = ["SOC2", "ISO27001"];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://api.drift.com/v1";
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`Drift API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/account");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const account = await this.fetchApi(config, "/account").catch(() => ({}));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "drift-conversations",
+            timestamp: now,
+            hash: hashEvidence(account),
+            framework: "SOC2",
+            controlId: "CC7.3",
+            source: "drift/account",
+            status: "unknown",
+            data: { connected: true },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/DropboxConnector.d.ts

@@ -0,0 +1,12 @@
+import type { IntegrationConnector, ConnectorConfig, EvidenceArtifact, IntegrationCapability, ComplianceFramework } from "../types.js";
+export declare class DropboxConnector implements IntegrationConnector {
+    readonly id = "dropbox";
+    readonly name = "Dropbox";
+    readonly category: "file_storage";
+    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/DropboxConnector.js

@@ -0,0 +1,127 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "dropbox-files",
+        name: "File Inventory",
+        description: "Fetch Dropbox file and folder inventory with sharing status",
+        evidenceCategories: ["file_storage", "data_protection"],
+    },
+    {
+        id: "dropbox-sharing",
+        name: "Shared Links",
+        description: "Fetch shared links and external access configurations",
+        evidenceCategories: ["access_control", "data_protection"],
+    },
+    {
+        id: "dropbox-members",
+        name: "Team Members",
+        description: "Fetch Dropbox team members and role assignments",
+        evidenceCategories: ["identity_management", "access_control"],
+    },
+    {
+        id: "dropbox-events",
+        name: "File Events",
+        description: "Fetch recent file activity and access audit events",
+        evidenceCategories: ["audit_logging", "data_protection"],
+    },
+];
+export class DropboxConnector {
+    id = "dropbox";
+    name = "Dropbox";
+    category = "file_storage";
+    authType = "bearer_token";
+    capabilities = capabilities;
+    frameworks = ["SOC2", "ISO27001", "HIPAA"];
+    async fetchApi(config, endpoint, body) {
+        const base = config.baseUrl || "https://api.dropboxapi.com/2";
+        const resp = await fetch(`${base}${endpoint}`, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+            body: body ? JSON.stringify(body) : "{}",
+        });
+        if (!resp.ok)
+            throw new Error(`Dropbox API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/users/get_current_account");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const files = await this.fetchApi(config, "/files/list_folder", { path: "", recursive: false }).catch(() => ({ entries: [] }));
+        const fileList = (files.entries || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "dropbox-files",
+            timestamp: now,
+            hash: hashEvidence({ fileCount: fileList.length }),
+            framework: "SOC2",
+            controlId: "CC6.4",
+            source: "dropbox/files",
+            status: fileList.length > 0 ? "compliant" : "non_compliant",
+            data: { fileCount: fileList.length },
+            metadata: {},
+        });
+        const sharedLinks = await this.fetchApi(config, "/sharing/list_shared_links", { limit: 100 }).catch(() => ({ links: [] }));
+        const linkList = (sharedLinks.links || []);
+        const publicLinks = linkList.filter((l) => {
+            const policy = (l.link_permissions || {});
+            return policy.resolved_visibility === "public";
+        });
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "dropbox-sharing",
+            timestamp: now,
+            hash: hashEvidence({ total: linkList.length, public: publicLinks.length }),
+            framework: "ISO27001",
+            controlId: "A.9.2.5",
+            source: "dropbox/sharing",
+            status: publicLinks.length === 0 ? "compliant" : "non_compliant",
+            data: { totalLinks: linkList.length, publicLinks: publicLinks.length },
+            metadata: {},
+        });
+        const members = await this.fetchApi(config, "/team/members/list", { limit: 100 }).catch(() => ({ members: [] }));
+        const memberList = (members.members || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "dropbox-members",
+            timestamp: now,
+            hash: hashEvidence({ memberCount: memberList.length }),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: "dropbox/members",
+            status: "unknown",
+            data: { memberCount: memberList.length },
+            metadata: {},
+        });
+        const events = await this.fetchApi(config, "https://api.dropboxapi.com/2/team_log/get_events", { limit: 100 }).catch(() => ({ events: [] }));
+        const eventList = (events.events || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "dropbox-events",
+            timestamp: now,
+            hash: hashEvidence({ eventCount: eventList.length }),
+            framework: "SOC2",
+            controlId: "CC7.2",
+            source: "dropbox/events",
+            status: "unknown",
+            data: { eventCount: eventList.length },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/ESETConnector.d.ts

@@ -0,0 +1,12 @@
+import type { IntegrationConnector, ConnectorConfig, EvidenceArtifact, IntegrationCapability, ComplianceFramework } from "../types.js";
+export declare class ESETConnector implements IntegrationConnector {
+    readonly id = "eset";
+    readonly name = "ESET";
+    readonly category: "endpoint";
+    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/ESETConnector.js

@@ -0,0 +1,70 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "eset-endpoints",
+        name: "Endpoint Security",
+        description: "Fetch ESET endpoint agent status and detection statistics",
+        evidenceCategories: ["endpoint_security", "monitoring"],
+    },
+    {
+        id: "eset-policies",
+        name: "Security Policies",
+        description: "Fetch ESET policy configurations and compliance status",
+        evidenceCategories: ["policy_compliance", "configuration"],
+    },
+    {
+        id: "eset-threats",
+        name: "Threat Events",
+        description: "Fetch threat detection events and quarantine history",
+        evidenceCategories: ["vulnerability_management", "monitoring"],
+    },
+];
+export class ESETConnector {
+    id = "eset";
+    name = "ESET";
+    category = "endpoint";
+    authType = "api_key";
+    capabilities = capabilities;
+    frameworks = ["SOC2", "ISO27001", "NIST_CSF", "HIPAA"];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://protect.eset.com/api/v1";
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`ESET API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/computers?limit=1");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const computers = await this.fetchApi(config, "/computers?limit=100").catch(() => ({ items: [] }));
+        const computerList = (computers.items || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "eset-endpoints",
+            timestamp: now,
+            hash: hashEvidence({ computerCount: computerList.length }),
+            framework: "SOC2",
+            controlId: "CC6.8",
+            source: "eset/computers",
+            status: computerList.length > 0 ? "compliant" : "unknown",
+            data: { endpointCount: computerList.length },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/ElasticsearchCloudConnector.d.ts

@@ -0,0 +1,12 @@
+import type { IntegrationConnector, ConnectorConfig, EvidenceArtifact, IntegrationCapability, ComplianceFramework } from "../types.js";
+export declare class ElasticsearchCloudConnector implements IntegrationConnector {
+    readonly id = "elasticsearch-cloud";
+    readonly name = "Elasticsearch Cloud";
+    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/ElasticsearchCloudConnector.js

@@ -0,0 +1,70 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "elasticsearch-clusters",
+        name: "Elasticsearch Clusters",
+        description: "Fetch Elasticsearch Cloud cluster configurations and index health",
+        evidenceCategories: ["data_protection", "cloud_configuration"],
+    },
+    {
+        id: "elasticsearch-security",
+        name: "Security Configurations",
+        description: "Fetch Elasticsearch security realms, TLS settings, and API key management",
+        evidenceCategories: ["access_control", "encryption"],
+    },
+    {
+        id: "elasticsearch-audit",
+        name: "Audit Logging",
+        description: "Fetch Elasticsearch audit log configurations and access events",
+        evidenceCategories: ["monitoring", "audit"],
+    },
+];
+export class ElasticsearchCloudConnector {
+    id = "elasticsearch-cloud";
+    name = "Elasticsearch Cloud";
+    category = "data_warehouse";
+    authType = "api_key";
+    capabilities = capabilities;
+    frameworks = ["SOC2", "ISO27001", "NIST_CSF"];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://api.elastic-cloud.com/v1";
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: {
+                Authorization: `ApiKey ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`Elasticsearch Cloud API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/deployments?limit=1");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const deployments = await this.fetchApi(config, "/deployments?limit=100").catch(() => ({ deployments: [] }));
+        const deployList = (deployments.deployments || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "elasticsearch-clusters",
+            timestamp: now,
+            hash: hashEvidence({ deploymentCount: deployList.length }),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: "elasticsearch-cloud/deployments",
+            status: deployList.length > 0 ? "compliant" : "unknown",
+            data: { deploymentCount: deployList.length },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/FSecureConnector.d.ts

@@ -0,0 +1,12 @@
+import type { IntegrationConnector, ConnectorConfig, EvidenceArtifact, IntegrationCapability, ComplianceFramework } from "../types.js";
+export declare class FSecureConnector implements IntegrationConnector {
+    readonly id = "fsecure";
+    readonly name = "F-Secure";
+    readonly category: "endpoint";
+    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/FSecureConnector.js

@@ -0,0 +1,70 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "fsecure-endpoints",
+        name: "Endpoint Protection",
+        description: "Fetch F-Secure endpoint agent deployment and protection status",
+        evidenceCategories: ["endpoint_security", "monitoring"],
+    },
+    {
+        id: "fsecure-detections",
+        name: "Threat Detections",
+        description: "Fetch F-Secure threat detection and malware quarantine events",
+        evidenceCategories: ["vulnerability_management", "monitoring"],
+    },
+    {
+        id: "fsecure-policies",
+        name: "Security Policies",
+        description: "Fetch policy configurations and scan schedule compliance",
+        evidenceCategories: ["policy_compliance", "configuration"],
+    },
+];
+export class FSecureConnector {
+    id = "fsecure";
+    name = "F-Secure";
+    category = "endpoint";
+    authType = "api_key";
+    capabilities = capabilities;
+    frameworks = ["SOC2", "ISO27001", "NIST_CSF"];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://cloud.f-secure.com/api/v1";
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`F-Secure API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/computers?limit=1");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const computers = await this.fetchApi(config, "/computers?limit=100").catch(() => ({ items: [] }));
+        const computerList = (computers.items || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "fsecure-endpoints",
+            timestamp: now,
+            hash: hashEvidence({ computerCount: computerList.length }),
+            framework: "SOC2",
+            controlId: "CC6.8",
+            source: "fsecure/computers",
+            status: computerList.length > 0 ? "compliant" : "unknown",
+            data: { endpointCount: computerList.length },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/FeatureFlagConnector.d.ts

@@ -0,0 +1,12 @@
+import type { IntegrationConnector, ConnectorConfig, EvidenceArtifact, IntegrationCapability, ComplianceFramework } from "../types.js";
+export declare class FeatureFlagConnector implements IntegrationConnector {
+    readonly id = "featureflag";
+    readonly name = "Feature Flag Service";
+    readonly category: "ci_cd";
+    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/FeatureFlagConnector.js

@@ -0,0 +1,70 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "featureflag-flags",
+        name: "Feature Flags",
+        description: "Fetch feature flag definitions, targeting rules, and percentage rollouts",
+        evidenceCategories: ["configuration", "change_management"],
+    },
+    {
+        id: "featureflag-audit",
+        name: "Change Audit Trail",
+        description: "Fetch flag change history and approval workflows",
+        evidenceCategories: ["audit", "change_management"],
+    },
+    {
+        id: "featureflag-environments",
+        name: "Environment Segmentation",
+        description: "Fetch environment-specific flag configurations and overrides",
+        evidenceCategories: ["access_control", "configuration"],
+    },
+];
+export class FeatureFlagConnector {
+    id = "featureflag";
+    name = "Feature Flag Service";
+    category = "ci_cd";
+    authType = "api_key";
+    capabilities = capabilities;
+    frameworks = ["SOC2", "ISO27001"];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://api.featureflags.example.com/v1";
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`Feature Flag API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/flags?limit=1");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const flags = await this.fetchApi(config, "/flags?limit=100").catch(() => ({ items: [] }));
+        const flagList = (flags.items || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "featureflag-flags",
+            timestamp: now,
+            hash: hashEvidence({ flagCount: flagList.length }),
+            framework: "SOC2",
+            controlId: "CC8.1",
+            source: "featureflag/flags",
+            status: "unknown",
+            data: { flagCount: flagList.length },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/FluxCDConnector.d.ts

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