@scoutflo/topology-contracts 0.1.0

package/README.md

@@ -0,0 +1,15 @@
+# @scoutflo/topology-contracts
+
+Pure shared topology vocabulary and Zod boundary schemas for Scoutflo topology workflows.
+
+This package owns:
+
+- topology provider constants and explicit compatibility aliases;
+- AWS, Kubernetes, and integration topology family constants;
+- source-sync capability, intent, scope, completeness, warning, and candidate DTO schemas;
+- topology correlation rule metadata and candidate DTO schemas;
+- small topology resource and relation vocabulary constants useful at contract boundaries.
+
+Gateway remains the runtime authority for provider discovery, credential resolution, dry-run/apply, lifecycle, reconciliation, persistence, audit, provider clients, source-specific payload parsing, and topology correlation rule execution.
+
+`k8s` is the persisted Kubernetes provider key. `kubernetes` is accepted only through the explicit alias normalization helper.

package/dist/src/correlation/candidate.d.ts

@@ -0,0 +1,310 @@
+import { z } from 'zod';
+export declare const topologyCorrelationDecisionSchema: z.ZodEnum<["ready", "warning_only", "ambiguous", "blocked", "degraded", "unresolved"]>;
+export declare const topologyCorrelationCandidateSchema: z.ZodObject<{
+    candidate_key: z.ZodString;
+    rule_key: z.ZodString;
+    rule_version: z.ZodString;
+    from: z.ZodObject<{
+        type: z.ZodEnum<["service", "resource"]>;
+        id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "service" | "resource";
+        id: string;
+    }, {
+        type: "service" | "resource";
+        id: string;
+    }>;
+    to: z.ZodObject<{
+        type: z.ZodEnum<["service", "resource"]>;
+        id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "service" | "resource";
+        id: string;
+    }, {
+        type: "service" | "resource";
+        id: string;
+    }>;
+    relation: z.ZodString;
+    canonical_key: z.ZodString;
+    semantic_key: z.ZodString;
+    confidence: z.ZodObject<{
+        score: z.ZodNumber;
+        source: z.ZodOptional<z.ZodEnum<["source_api", "telemetry", "heuristic", "manual", "ai"]>>;
+    }, "strip", z.ZodTypeAny, {
+        score: number;
+        source?: "source_api" | "telemetry" | "heuristic" | "manual" | "ai" | undefined;
+    }, {
+        score: number;
+        source?: "source_api" | "telemetry" | "heuristic" | "manual" | "ai" | undefined;
+    }>;
+    evidence: z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        ref: z.ZodString;
+        summary: z.ZodOptional<z.ZodString>;
+        sourcePath: z.ZodOptional<z.ZodString>;
+        facts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            value: z.ZodString;
+            sourcePath: z.ZodString;
+            confidence: z.ZodNumber;
+            kind: z.ZodEnum<["label", "tag", "annotation", "provider_identity", "resource_hint", "text_derived", "time", "rule", "query", "trace", "metric", "log"]>;
+        }, "strip", z.ZodTypeAny, {
+            value: string;
+            key: string;
+            sourcePath: string;
+            confidence: number;
+            kind: "label" | "tag" | "annotation" | "provider_identity" | "resource_hint" | "text_derived" | "time" | "rule" | "query" | "trace" | "metric" | "log";
+        }, {
+            value: string;
+            key: string;
+            sourcePath: string;
+            confidence: number;
+            kind: "label" | "tag" | "annotation" | "provider_identity" | "resource_hint" | "text_derived" | "time" | "rule" | "query" | "trace" | "metric" | "log";
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        ref: string;
+        sourcePath?: string | undefined;
+        summary?: string | undefined;
+        facts?: {
+            value: string;
+            key: string;
+            sourcePath: string;
+            confidence: number;
+            kind: "label" | "tag" | "annotation" | "provider_identity" | "resource_hint" | "text_derived" | "time" | "rule" | "query" | "trace" | "metric" | "log";
+        }[] | undefined;
+    }, {
+        type: string;
+        ref: string;
+        sourcePath?: string | undefined;
+        summary?: string | undefined;
+        facts?: {
+            value: string;
+            key: string;
+            sourcePath: string;
+            confidence: number;
+            kind: "label" | "tag" | "annotation" | "provider_identity" | "resource_hint" | "text_derived" | "time" | "rule" | "query" | "trace" | "metric" | "log";
+        }[] | undefined;
+    }>, "many">;
+    decision: z.ZodEnum<["ready", "warning_only", "ambiguous", "blocked", "degraded", "unresolved"]>;
+    diagnostics: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        code: string;
+        message: string;
+        details?: Record<string, unknown> | undefined;
+    }, {
+        code: string;
+        message: string;
+        details?: Record<string, unknown> | undefined;
+    }>, "many">>;
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    source_attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    candidate_key: z.ZodString;
+    rule_key: z.ZodString;
+    rule_version: z.ZodString;
+    from: z.ZodObject<{
+        type: z.ZodEnum<["service", "resource"]>;
+        id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "service" | "resource";
+        id: string;
+    }, {
+        type: "service" | "resource";
+        id: string;
+    }>;
+    to: z.ZodObject<{
+        type: z.ZodEnum<["service", "resource"]>;
+        id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "service" | "resource";
+        id: string;
+    }, {
+        type: "service" | "resource";
+        id: string;
+    }>;
+    relation: z.ZodString;
+    canonical_key: z.ZodString;
+    semantic_key: z.ZodString;
+    confidence: z.ZodObject<{
+        score: z.ZodNumber;
+        source: z.ZodOptional<z.ZodEnum<["source_api", "telemetry", "heuristic", "manual", "ai"]>>;
+    }, "strip", z.ZodTypeAny, {
+        score: number;
+        source?: "source_api" | "telemetry" | "heuristic" | "manual" | "ai" | undefined;
+    }, {
+        score: number;
+        source?: "source_api" | "telemetry" | "heuristic" | "manual" | "ai" | undefined;
+    }>;
+    evidence: z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        ref: z.ZodString;
+        summary: z.ZodOptional<z.ZodString>;
+        sourcePath: z.ZodOptional<z.ZodString>;
+        facts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            value: z.ZodString;
+            sourcePath: z.ZodString;
+            confidence: z.ZodNumber;
+            kind: z.ZodEnum<["label", "tag", "annotation", "provider_identity", "resource_hint", "text_derived", "time", "rule", "query", "trace", "metric", "log"]>;
+        }, "strip", z.ZodTypeAny, {
+            value: string;
+            key: string;
+            sourcePath: string;
+            confidence: number;
+            kind: "label" | "tag" | "annotation" | "provider_identity" | "resource_hint" | "text_derived" | "time" | "rule" | "query" | "trace" | "metric" | "log";
+        }, {
+            value: string;
+            key: string;
+            sourcePath: string;
+            confidence: number;
+            kind: "label" | "tag" | "annotation" | "provider_identity" | "resource_hint" | "text_derived" | "time" | "rule" | "query" | "trace" | "metric" | "log";
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        ref: string;
+        sourcePath?: string | undefined;
+        summary?: string | undefined;
+        facts?: {
+            value: string;
+            key: string;
+            sourcePath: string;
+            confidence: number;
+            kind: "label" | "tag" | "annotation" | "provider_identity" | "resource_hint" | "text_derived" | "time" | "rule" | "query" | "trace" | "metric" | "log";
+        }[] | undefined;
+    }, {
+        type: string;
+        ref: string;
+        sourcePath?: string | undefined;
+        summary?: string | undefined;
+        facts?: {
+            value: string;
+            key: string;
+            sourcePath: string;
+            confidence: number;
+            kind: "label" | "tag" | "annotation" | "provider_identity" | "resource_hint" | "text_derived" | "time" | "rule" | "query" | "trace" | "metric" | "log";
+        }[] | undefined;
+    }>, "many">;
+    decision: z.ZodEnum<["ready", "warning_only", "ambiguous", "blocked", "degraded", "unresolved"]>;
+    diagnostics: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        code: string;
+        message: string;
+        details?: Record<string, unknown> | undefined;
+    }, {
+        code: string;
+        message: string;
+        details?: Record<string, unknown> | undefined;
+    }>, "many">>;
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    source_attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    candidate_key: z.ZodString;
+    rule_key: z.ZodString;
+    rule_version: z.ZodString;
+    from: z.ZodObject<{
+        type: z.ZodEnum<["service", "resource"]>;
+        id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "service" | "resource";
+        id: string;
+    }, {
+        type: "service" | "resource";
+        id: string;
+    }>;
+    to: z.ZodObject<{
+        type: z.ZodEnum<["service", "resource"]>;
+        id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "service" | "resource";
+        id: string;
+    }, {
+        type: "service" | "resource";
+        id: string;
+    }>;
+    relation: z.ZodString;
+    canonical_key: z.ZodString;
+    semantic_key: z.ZodString;
+    confidence: z.ZodObject<{
+        score: z.ZodNumber;
+        source: z.ZodOptional<z.ZodEnum<["source_api", "telemetry", "heuristic", "manual", "ai"]>>;
+    }, "strip", z.ZodTypeAny, {
+        score: number;
+        source?: "source_api" | "telemetry" | "heuristic" | "manual" | "ai" | undefined;
+    }, {
+        score: number;
+        source?: "source_api" | "telemetry" | "heuristic" | "manual" | "ai" | undefined;
+    }>;
+    evidence: z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        ref: z.ZodString;
+        summary: z.ZodOptional<z.ZodString>;
+        sourcePath: z.ZodOptional<z.ZodString>;
+        facts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            value: z.ZodString;
+            sourcePath: z.ZodString;
+            confidence: z.ZodNumber;
+            kind: z.ZodEnum<["label", "tag", "annotation", "provider_identity", "resource_hint", "text_derived", "time", "rule", "query", "trace", "metric", "log"]>;
+        }, "strip", z.ZodTypeAny, {
+            value: string;
+            key: string;
+            sourcePath: string;
+            confidence: number;
+            kind: "label" | "tag" | "annotation" | "provider_identity" | "resource_hint" | "text_derived" | "time" | "rule" | "query" | "trace" | "metric" | "log";
+        }, {
+            value: string;
+            key: string;
+            sourcePath: string;
+            confidence: number;
+            kind: "label" | "tag" | "annotation" | "provider_identity" | "resource_hint" | "text_derived" | "time" | "rule" | "query" | "trace" | "metric" | "log";
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        ref: string;
+        sourcePath?: string | undefined;
+        summary?: string | undefined;
+        facts?: {
+            value: string;
+            key: string;
+            sourcePath: string;
+            confidence: number;
+            kind: "label" | "tag" | "annotation" | "provider_identity" | "resource_hint" | "text_derived" | "time" | "rule" | "query" | "trace" | "metric" | "log";
+        }[] | undefined;
+    }, {
+        type: string;
+        ref: string;
+        sourcePath?: string | undefined;
+        summary?: string | undefined;
+        facts?: {
+            value: string;
+            key: string;
+            sourcePath: string;
+            confidence: number;
+            kind: "label" | "tag" | "annotation" | "provider_identity" | "resource_hint" | "text_derived" | "time" | "rule" | "query" | "trace" | "metric" | "log";
+        }[] | undefined;
+    }>, "many">;
+    decision: z.ZodEnum<["ready", "warning_only", "ambiguous", "blocked", "degraded", "unresolved"]>;
+    diagnostics: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        code: string;
+        message: string;
+        details?: Record<string, unknown> | undefined;
+    }, {
+        code: string;
+        message: string;
+        details?: Record<string, unknown> | undefined;
+    }>, "many">>;
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    source_attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.ZodTypeAny, "passthrough">>;
+export type TopologyCorrelationCandidate = z.infer<typeof topologyCorrelationCandidateSchema>;

package/dist/src/correlation/candidate.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.topologyCorrelationCandidateSchema = exports.topologyCorrelationDecisionSchema = void 0;
+const zod_1 = require("zod");
+const correlation_core_1 = require("@scoutflo/correlation-core");
+const common_1 = require("../source-sync/common");
+exports.topologyCorrelationDecisionSchema = zod_1.z.enum([
+    'ready',
+    'warning_only',
+    'ambiguous',
+    'blocked',
+    'degraded',
+    'unresolved',
+]);
+exports.topologyCorrelationCandidateSchema = zod_1.z.object({
+    candidate_key: common_1.nonEmptyStringSchema,
+    rule_key: common_1.nonEmptyStringSchema,
+    rule_version: common_1.nonEmptyStringSchema,
+    from: correlation_core_1.correlationEntityRefSchema,
+    to: correlation_core_1.correlationEntityRefSchema,
+    relation: common_1.nonEmptyStringSchema,
+    canonical_key: common_1.nonEmptyStringSchema,
+    semantic_key: common_1.nonEmptyStringSchema,
+    confidence: correlation_core_1.confidenceSchema,
+    evidence: zod_1.z.array(correlation_core_1.correlationEvidenceSchema),
+    decision: exports.topologyCorrelationDecisionSchema,
+    diagnostics: zod_1.z.array(correlation_core_1.correlationDiagnosticSchema).optional(),
+    attributes: common_1.recordSchema.optional(),
+    source_attributes: common_1.recordSchema.optional(),
+}).passthrough();
+//# sourceMappingURL=candidate.js.map

package/dist/src/correlation/candidate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"candidate.js","sourceRoot":"","sources":["../../../src/correlation/candidate.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AACxB,iEAKoC;AACpC,kDAG+B;AAElB,QAAA,iCAAiC,GAAG,OAAC,CAAC,IAAI,CAAC;IACtD,OAAO;IACP,cAAc;IACd,WAAW;IACX,SAAS;IACT,UAAU;IACV,YAAY;CACb,CAAC,CAAC;AAEU,QAAA,kCAAkC,GAAG,OAAC,CAAC,MAAM,CAAC;IACzD,aAAa,EAAE,6BAAoB;IACnC,QAAQ,EAAE,6BAAoB;IAC9B,YAAY,EAAE,6BAAoB;IAClC,IAAI,EAAE,6CAA0B;IAChC,EAAE,EAAE,6CAA0B;IAC9B,QAAQ,EAAE,6BAAoB;IAC9B,aAAa,EAAE,6BAAoB;IACnC,YAAY,EAAE,6BAAoB;IAClC,UAAU,EAAE,mCAAgB;IAC5B,QAAQ,EAAE,OAAC,CAAC,KAAK,CAAC,4CAAyB,CAAC;IAC5C,QAAQ,EAAE,yCAAiC;IAC3C,WAAW,EAAE,OAAC,CAAC,KAAK,CAAC,8CAA2B,CAAC,CAAC,QAAQ,EAAE;IAC5D,UAAU,EAAE,qBAAY,CAAC,QAAQ,EAAE;IACnC,iBAAiB,EAAE,qBAAY,CAAC,QAAQ,EAAE;CAC3C,CAAC,CAAC,WAAW,EAAE,CAAC"}

package/dist/src/correlation/index.d.ts

@@ -0,0 +1,2 @@
+export * from './rule';
+export * from './candidate';

package/dist/src/correlation/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./rule"), exports);
+__exportStar(require("./candidate"), exports);
+//# sourceMappingURL=index.js.map

package/dist/src/correlation/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/correlation/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,yCAAuB;AACvB,8CAA4B"}

package/dist/src/correlation/rule.d.ts

@@ -0,0 +1,80 @@
+import { z } from 'zod';
+export declare const topologyCorrelationApplyPolicySchema: z.ZodEnum<["auto_apply", "selected_apply", "review_only"]>;
+export declare const topologyCorrelationRequiredEndpointSchema: z.ZodObject<{
+    entity_type: z.ZodEnum<["service", "resource"]>;
+    resource_type: z.ZodOptional<z.ZodString>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    entity_type: z.ZodEnum<["service", "resource"]>;
+    resource_type: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    entity_type: z.ZodEnum<["service", "resource"]>;
+    resource_type: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">>;
+export declare const topologyCorrelationRuleMetadataSchema: z.ZodObject<{
+    rule_key: z.ZodString;
+    rule_version: z.ZodString;
+    profile_key: z.ZodOptional<z.ZodString>;
+    relationship_lane: z.ZodString;
+    relationship_kind: z.ZodString;
+    relation: z.ZodString;
+    apply_policy: z.ZodEnum<["auto_apply", "selected_apply", "review_only"]>;
+    default_min_confidence: z.ZodOptional<z.ZodNumber>;
+    required_endpoints: z.ZodArray<z.ZodObject<{
+        entity_type: z.ZodEnum<["service", "resource"]>;
+        resource_type: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        entity_type: z.ZodEnum<["service", "resource"]>;
+        resource_type: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        entity_type: z.ZodEnum<["service", "resource"]>;
+        resource_type: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>, "many">;
+    evidence_policy: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    confidence_policy: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    ambiguity_policy: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    rule_key: z.ZodString;
+    rule_version: z.ZodString;
+    profile_key: z.ZodOptional<z.ZodString>;
+    relationship_lane: z.ZodString;
+    relationship_kind: z.ZodString;
+    relation: z.ZodString;
+    apply_policy: z.ZodEnum<["auto_apply", "selected_apply", "review_only"]>;
+    default_min_confidence: z.ZodOptional<z.ZodNumber>;
+    required_endpoints: z.ZodArray<z.ZodObject<{
+        entity_type: z.ZodEnum<["service", "resource"]>;
+        resource_type: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        entity_type: z.ZodEnum<["service", "resource"]>;
+        resource_type: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        entity_type: z.ZodEnum<["service", "resource"]>;
+        resource_type: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>, "many">;
+    evidence_policy: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    confidence_policy: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    ambiguity_policy: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    rule_key: z.ZodString;
+    rule_version: z.ZodString;
+    profile_key: z.ZodOptional<z.ZodString>;
+    relationship_lane: z.ZodString;
+    relationship_kind: z.ZodString;
+    relation: z.ZodString;
+    apply_policy: z.ZodEnum<["auto_apply", "selected_apply", "review_only"]>;
+    default_min_confidence: z.ZodOptional<z.ZodNumber>;
+    required_endpoints: z.ZodArray<z.ZodObject<{
+        entity_type: z.ZodEnum<["service", "resource"]>;
+        resource_type: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        entity_type: z.ZodEnum<["service", "resource"]>;
+        resource_type: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        entity_type: z.ZodEnum<["service", "resource"]>;
+        resource_type: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>, "many">;
+    evidence_policy: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    confidence_policy: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    ambiguity_policy: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.ZodTypeAny, "passthrough">>;
+export type TopologyCorrelationRuleMetadata = z.infer<typeof topologyCorrelationRuleMetadataSchema>;

package/dist/src/correlation/rule.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.topologyCorrelationRuleMetadataSchema = exports.topologyCorrelationRequiredEndpointSchema = exports.topologyCorrelationApplyPolicySchema = void 0;
+const zod_1 = require("zod");
+const common_1 = require("../source-sync/common");
+exports.topologyCorrelationApplyPolicySchema = zod_1.z.enum([
+    'auto_apply',
+    'selected_apply',
+    'review_only',
+]);
+exports.topologyCorrelationRequiredEndpointSchema = zod_1.z.object({
+    entity_type: common_1.entityKindSchema,
+    resource_type: common_1.nonEmptyStringSchema.optional(),
+}).passthrough();
+exports.topologyCorrelationRuleMetadataSchema = zod_1.z.object({
+    rule_key: common_1.nonEmptyStringSchema,
+    rule_version: common_1.nonEmptyStringSchema,
+    profile_key: common_1.nonEmptyStringSchema.optional(),
+    relationship_lane: common_1.nonEmptyStringSchema,
+    relationship_kind: common_1.nonEmptyStringSchema,
+    relation: common_1.nonEmptyStringSchema,
+    apply_policy: exports.topologyCorrelationApplyPolicySchema,
+    default_min_confidence: zod_1.z.number().min(0).optional(),
+    required_endpoints: zod_1.z.array(exports.topologyCorrelationRequiredEndpointSchema),
+    evidence_policy: common_1.recordSchema.optional(),
+    confidence_policy: common_1.recordSchema.optional(),
+    ambiguity_policy: common_1.recordSchema.optional(),
+}).passthrough();
+//# sourceMappingURL=rule.js.map

package/dist/src/correlation/rule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule.js","sourceRoot":"","sources":["../../../src/correlation/rule.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AACxB,kDAI+B;AAElB,QAAA,oCAAoC,GAAG,OAAC,CAAC,IAAI,CAAC;IACzD,YAAY;IACZ,gBAAgB;IAChB,aAAa;CACd,CAAC,CAAC;AAEU,QAAA,yCAAyC,GAAG,OAAC,CAAC,MAAM,CAAC;IAChE,WAAW,EAAE,yBAAgB;IAC7B,aAAa,EAAE,6BAAoB,CAAC,QAAQ,EAAE;CAC/C,CAAC,CAAC,WAAW,EAAE,CAAC;AAEJ,QAAA,qCAAqC,GAAG,OAAC,CAAC,MAAM,CAAC;IAC5D,QAAQ,EAAE,6BAAoB;IAC9B,YAAY,EAAE,6BAAoB;IAClC,WAAW,EAAE,6BAAoB,CAAC,QAAQ,EAAE;IAC5C,iBAAiB,EAAE,6BAAoB;IACvC,iBAAiB,EAAE,6BAAoB;IACvC,QAAQ,EAAE,6BAAoB;IAC9B,YAAY,EAAE,4CAAoC;IAClD,sBAAsB,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;IACpD,kBAAkB,EAAE,OAAC,CAAC,KAAK,CAAC,iDAAyC,CAAC;IACtE,eAAe,EAAE,qBAAY,CAAC,QAAQ,EAAE;IACxC,iBAAiB,EAAE,qBAAY,CAAC,QAAQ,EAAE;IAC1C,gBAAgB,EAAE,qBAAY,CAAC,QAAQ,EAAE;CAC1C,CAAC,CAAC,WAAW,EAAE,CAAC"}

package/dist/src/families/aws.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+export declare const AWS_TOPOLOGY_FAMILY: {
+    readonly ACCOUNT: "account";
+    readonly VPC: "vpc";
+    readonly SUBNET: "subnet";
+    readonly EC2_INSTANCE: "ec2_instance";
+    readonly RDS_INSTANCE: "rds_instance";
+    readonly S3_BUCKET: "s3_bucket";
+    readonly EKS_CLUSTER: "eks_cluster";
+};
+export declare const AWS_TOPOLOGY_FAMILY_VALUES: readonly ["account", "vpc", "subnet", "ec2_instance", "rds_instance", "s3_bucket", "eks_cluster"];
+export declare const awsTopologyFamilySchema: z.ZodEnum<["account", "vpc", "subnet", "ec2_instance", "rds_instance", "s3_bucket", "eks_cluster"]>;
+export type AwsTopologyFamily = z.infer<typeof awsTopologyFamilySchema>;

package/dist/src/families/aws.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.awsTopologyFamilySchema = exports.AWS_TOPOLOGY_FAMILY_VALUES = exports.AWS_TOPOLOGY_FAMILY = void 0;
+const zod_1 = require("zod");
+exports.AWS_TOPOLOGY_FAMILY = {
+    ACCOUNT: 'account',
+    VPC: 'vpc',
+    SUBNET: 'subnet',
+    EC2_INSTANCE: 'ec2_instance',
+    RDS_INSTANCE: 'rds_instance',
+    S3_BUCKET: 's3_bucket',
+    EKS_CLUSTER: 'eks_cluster',
+};
+exports.AWS_TOPOLOGY_FAMILY_VALUES = [
+    exports.AWS_TOPOLOGY_FAMILY.ACCOUNT,
+    exports.AWS_TOPOLOGY_FAMILY.VPC,
+    exports.AWS_TOPOLOGY_FAMILY.SUBNET,
+    exports.AWS_TOPOLOGY_FAMILY.EC2_INSTANCE,
+    exports.AWS_TOPOLOGY_FAMILY.RDS_INSTANCE,
+    exports.AWS_TOPOLOGY_FAMILY.S3_BUCKET,
+    exports.AWS_TOPOLOGY_FAMILY.EKS_CLUSTER,
+];
+exports.awsTopologyFamilySchema = zod_1.z.enum(exports.AWS_TOPOLOGY_FAMILY_VALUES);
+//# sourceMappingURL=aws.js.map

package/dist/src/families/aws.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aws.js","sourceRoot":"","sources":["../../../src/families/aws.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AAEX,QAAA,mBAAmB,GAAG;IACjC,OAAO,EAAE,SAAS;IAClB,GAAG,EAAE,KAAK;IACV,MAAM,EAAE,QAAQ;IAChB,YAAY,EAAE,cAAc;IAC5B,YAAY,EAAE,cAAc;IAC5B,SAAS,EAAE,WAAW;IACtB,WAAW,EAAE,aAAa;CAClB,CAAC;AAEE,QAAA,0BAA0B,GAAG;IACxC,2BAAmB,CAAC,OAAO;IAC3B,2BAAmB,CAAC,GAAG;IACvB,2BAAmB,CAAC,MAAM;IAC1B,2BAAmB,CAAC,YAAY;IAChC,2BAAmB,CAAC,YAAY;IAChC,2BAAmB,CAAC,SAAS;IAC7B,2BAAmB,CAAC,WAAW;CACvB,CAAC;AAEE,QAAA,uBAAuB,GAAG,OAAC,CAAC,IAAI,CAAC,kCAA0B,CAAC,CAAC"}

package/dist/src/families/index.d.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+export * from './aws';
+export * from './kubernetes';
+export * from './integrations';
+export declare const topologyFamilySchema: z.ZodUnion<[z.ZodEnum<["account", "vpc", "subnet", "ec2_instance", "rds_instance", "s3_bucket", "eks_cluster"]>, z.ZodEnum<["cluster", "namespace", "deployment", "statefulset", "daemonset", "job", "cronjob", "service"]>, z.ZodEnum<["integration_resource"]>]>;
+export type TopologyFamily = z.infer<typeof topologyFamilySchema>;

package/dist/src/families/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.topologyFamilySchema = void 0;
+const zod_1 = require("zod");
+const aws_1 = require("./aws");
+const integrations_1 = require("./integrations");
+const kubernetes_1 = require("./kubernetes");
+__exportStar(require("./aws"), exports);
+__exportStar(require("./kubernetes"), exports);
+__exportStar(require("./integrations"), exports);
+exports.topologyFamilySchema = zod_1.z.union([
+    aws_1.awsTopologyFamilySchema,
+    kubernetes_1.kubernetesTopologyFamilySchema,
+    integrations_1.integrationTopologyFamilySchema,
+]);
+//# sourceMappingURL=index.js.map

package/dist/src/families/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/families/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,6BAAwB;AACxB,+BAAgD;AAChD,iDAAiE;AACjE,6CAA8D;AAE9D,wCAAsB;AACtB,+CAA6B;AAC7B,iDAA+B;AAElB,QAAA,oBAAoB,GAAG,OAAC,CAAC,KAAK,CAAC;IAC1C,6BAAuB;IACvB,2CAA8B;IAC9B,8CAA+B;CAChC,CAAC,CAAC"}

package/dist/src/families/integrations.d.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+export declare const INTEGRATION_TOPOLOGY_FAMILY: {
+    readonly INTEGRATION_RESOURCE: "integration_resource";
+};
+export declare const INTEGRATION_TOPOLOGY_FAMILY_VALUES: readonly ["integration_resource"];
+export declare const integrationTopologyFamilySchema: z.ZodEnum<["integration_resource"]>;
+export type IntegrationTopologyFamily = z.infer<typeof integrationTopologyFamilySchema>;

package/dist/src/families/integrations.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.integrationTopologyFamilySchema = exports.INTEGRATION_TOPOLOGY_FAMILY_VALUES = exports.INTEGRATION_TOPOLOGY_FAMILY = void 0;
+const zod_1 = require("zod");
+exports.INTEGRATION_TOPOLOGY_FAMILY = {
+    INTEGRATION_RESOURCE: 'integration_resource',
+};
+exports.INTEGRATION_TOPOLOGY_FAMILY_VALUES = [
+    exports.INTEGRATION_TOPOLOGY_FAMILY.INTEGRATION_RESOURCE,
+];
+exports.integrationTopologyFamilySchema = zod_1.z.enum(exports.INTEGRATION_TOPOLOGY_FAMILY_VALUES);
+//# sourceMappingURL=integrations.js.map

package/dist/src/families/integrations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"integrations.js","sourceRoot":"","sources":["../../../src/families/integrations.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AAEX,QAAA,2BAA2B,GAAG;IACzC,oBAAoB,EAAE,sBAAsB;CACpC,CAAC;AAEE,QAAA,kCAAkC,GAAG;IAChD,mCAA2B,CAAC,oBAAoB;CACxC,CAAC;AAEE,QAAA,+BAA+B,GAAG,OAAC,CAAC,IAAI,CAAC,0CAAkC,CAAC,CAAC"}

package/dist/src/families/kubernetes.d.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+export declare const KUBERNETES_TOPOLOGY_FAMILY: {
+    readonly CLUSTER: "cluster";
+    readonly NAMESPACE: "namespace";
+    readonly DEPLOYMENT: "deployment";
+    readonly STATEFUL_SET: "statefulset";
+    readonly DAEMON_SET: "daemonset";
+    readonly JOB: "job";
+    readonly CRON_JOB: "cronjob";
+    readonly SERVICE: "service";
+};
+export declare const KUBERNETES_TOPOLOGY_FAMILY_VALUES: readonly ["cluster", "namespace", "deployment", "statefulset", "daemonset", "job", "cronjob", "service"];
+export declare const kubernetesTopologyFamilySchema: z.ZodEnum<["cluster", "namespace", "deployment", "statefulset", "daemonset", "job", "cronjob", "service"]>;
+export type KubernetesTopologyFamily = z.infer<typeof kubernetesTopologyFamilySchema>;