@native-knowledge/knowledge-sdk 0.0.0-stage → 0.1.0-rc.2

package/dist/internal/contracts/signal.d.ts

@@ -0,0 +1,113 @@
+import { z } from 'zod';
+export declare const signalProfileNameSchema: z.ZodEnum<{
+    trends: "trends";
+    hn: "hn";
+    github: "github";
+    autocomplete: "autocomplete";
+    youtube: "youtube";
+    tiktok: "tiktok";
+    douyin: "douyin";
+    meta: "meta";
+    "deep-social": "deep-social";
+}>;
+export declare const signalSourceHealthSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    items: z.ZodOptional<z.ZodNumber>;
+    state: z.ZodOptional<z.ZodString>;
+    note: z.ZodOptional<z.ZodString>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$catchall<z.ZodUnknown>>;
+export declare const signalSourceSnapshotSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    projectKey: z.ZodString;
+    projectRef: z.ZodOptional<z.ZodString>;
+    sourceRef: z.ZodOptional<z.ZodString>;
+    sourceRevisionRef: z.ZodOptional<z.ZodString>;
+    sourceKey: z.ZodString;
+    profile: z.ZodEnum<{
+        trends: "trends";
+        hn: "hn";
+        github: "github";
+        autocomplete: "autocomplete";
+        youtube: "youtube";
+        tiktok: "tiktok";
+        douyin: "douyin";
+        meta: "meta";
+        "deep-social": "deep-social";
+    }>;
+    collectedAt: z.ZodISODateTime;
+    contentHash: z.ZodString;
+    evidenceId: z.ZodString;
+    signalCount: z.ZodNumber;
+    health: z.ZodObject<{
+        ok: z.ZodBoolean;
+        items: z.ZodOptional<z.ZodNumber>;
+        state: z.ZodOptional<z.ZodString>;
+        note: z.ZodOptional<z.ZodString>;
+        error: z.ZodOptional<z.ZodString>;
+    }, z.core.$catchall<z.ZodUnknown>>;
+}, z.core.$strict>;
+export declare const signalSourceAttemptSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    projectKey: z.ZodString;
+    projectRef: z.ZodOptional<z.ZodString>;
+    sourceRef: z.ZodOptional<z.ZodString>;
+    sourceRevisionRef: z.ZodOptional<z.ZodString>;
+    sourceKey: z.ZodString;
+    profile: z.ZodEnum<{
+        trends: "trends";
+        hn: "hn";
+        github: "github";
+        autocomplete: "autocomplete";
+        youtube: "youtube";
+        tiktok: "tiktok";
+        douyin: "douyin";
+        meta: "meta";
+        "deep-social": "deep-social";
+    }>;
+    lastAttemptAt: z.ZodISODateTime;
+    lastSuccessAt: z.ZodNullable<z.ZodISODateTime>;
+    success: z.ZodBoolean;
+    durationMs: z.ZodNumber;
+    state: z.ZodNullable<z.ZodString>;
+    error: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const signalGenerationSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    projectKey: z.ZodString;
+    projectRef: z.ZodOptional<z.ZodString>;
+    generationKey: z.ZodString;
+    scoringProfile: z.ZodString;
+    generatedAt: z.ZodISODateTime;
+    snapshotManifest: z.ZodRecord<z.ZodString, z.ZodString>;
+    historyBasis: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    contentHash: z.ZodString;
+    candidateCount: z.ZodNumber;
+    observationCount: z.ZodNumber;
+}, z.core.$strict>;
+export type SignalProfileName = z.infer<typeof signalProfileNameSchema>;
+export type SignalSourceHealth = z.infer<typeof signalSourceHealthSchema>;
+export type SignalSourceSnapshot = z.infer<typeof signalSourceSnapshotSchema>;
+export type SignalSourceAttempt = z.infer<typeof signalSourceAttemptSchema>;
+export type SignalGeneration = z.infer<typeof signalGenerationSchema>;
+export declare const signalHistoryCandidateSchema: z.ZodObject<{
+    query: z.ZodString;
+    score: z.ZodNumber;
+    sources: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const signalHistorySeedSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    projectKey: z.ZodString;
+    projectRef: z.ZodOptional<z.ZodString>;
+    historyKey: z.ZodString;
+    generatedAt: z.ZodISODateTime;
+    scoringVersion: z.ZodNumber;
+    origin: z.ZodString;
+    candidates: z.ZodArray<z.ZodObject<{
+        query: z.ZodString;
+        score: z.ZodNumber;
+        sources: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type SignalHistoryCandidate = z.infer<typeof signalHistoryCandidateSchema>;
+export type SignalHistorySeed = z.infer<typeof signalHistorySeedSchema>;

package/dist/internal/contracts/signal.js

@@ -0,0 +1,77 @@
+import { z } from 'zod';
+import { idSchema, isoDateTimeSchema, projectKeySchema, schemaVersionSchema, sha256Schema, stableUriSchema, } from './common.js';
+export const signalProfileNameSchema = z.enum([
+    'trends',
+    'hn',
+    'github',
+    'autocomplete',
+    'youtube',
+    'tiktok',
+    'douyin',
+    'meta',
+    'deep-social',
+]);
+export const signalSourceHealthSchema = z.object({
+    ok: z.boolean(),
+    items: z.number().int().nonnegative().optional(),
+    state: z.string().trim().min(1).max(128).optional(),
+    note: z.string().trim().max(2000).optional(),
+    error: z.string().trim().max(2000).optional(),
+}).catchall(z.unknown());
+export const signalSourceSnapshotSchema = z.object({
+    schemaVersion: schemaVersionSchema,
+    projectKey: projectKeySchema,
+    projectRef: stableUriSchema.optional(),
+    sourceRef: stableUriSchema.optional(),
+    sourceRevisionRef: stableUriSchema.optional(),
+    sourceKey: idSchema,
+    profile: signalProfileNameSchema,
+    collectedAt: isoDateTimeSchema,
+    contentHash: sha256Schema,
+    evidenceId: idSchema,
+    signalCount: z.number().int().nonnegative(),
+    health: signalSourceHealthSchema,
+}).strict();
+export const signalSourceAttemptSchema = z.object({
+    schemaVersion: schemaVersionSchema,
+    projectKey: projectKeySchema,
+    projectRef: stableUriSchema.optional(),
+    sourceRef: stableUriSchema.optional(),
+    sourceRevisionRef: stableUriSchema.optional(),
+    sourceKey: idSchema,
+    profile: signalProfileNameSchema,
+    lastAttemptAt: isoDateTimeSchema,
+    lastSuccessAt: isoDateTimeSchema.nullable(),
+    success: z.boolean(),
+    durationMs: z.number().int().nonnegative(),
+    state: z.string().trim().min(1).max(128).nullable(),
+    error: z.string().trim().max(2000).nullable(),
+}).strict();
+export const signalGenerationSchema = z.object({
+    schemaVersion: schemaVersionSchema,
+    projectKey: projectKeySchema,
+    projectRef: stableUriSchema.optional(),
+    generationKey: sha256Schema,
+    scoringProfile: z.string().trim().min(1).max(128),
+    generatedAt: isoDateTimeSchema,
+    snapshotManifest: z.record(idSchema, sha256Schema),
+    historyBasis: z.array(sha256Schema).max(512).default([]),
+    contentHash: sha256Schema,
+    candidateCount: z.number().int().nonnegative(),
+    observationCount: z.number().int().nonnegative(),
+}).strict();
+export const signalHistoryCandidateSchema = z.object({
+    query: z.string().trim().min(1).max(1000),
+    score: z.number().finite(),
+    sources: z.array(idSchema).max(64),
+}).strict();
+export const signalHistorySeedSchema = z.object({
+    schemaVersion: schemaVersionSchema,
+    projectKey: projectKeySchema,
+    projectRef: stableUriSchema.optional(),
+    historyKey: sha256Schema,
+    generatedAt: isoDateTimeSchema,
+    scoringVersion: z.number().int().positive(),
+    origin: z.string().trim().min(1).max(128),
+    candidates: z.array(signalHistoryCandidateSchema).max(120),
+}).strict();

package/dist/internal/contracts/source-governance.d.ts

@@ -0,0 +1,375 @@
+import { z } from 'zod';
+export declare const sourceExpectationSchema: z.ZodEnum<{
+    REQUIRED: "REQUIRED";
+    OPTIONAL: "OPTIONAL";
+    CONDITIONAL: "CONDITIONAL";
+}>;
+export declare const sourceDeclaredStateSchema: z.ZodEnum<{
+    ACCESS_CONTROLLED: "ACCESS_CONTROLLED";
+    CONFIGURED: "CONFIGURED";
+    PENDING_DISCOVERY: "PENDING_DISCOVERY";
+    KNOWN_MISSING: "KNOWN_MISSING";
+    NEED_AUTHORIZED_SOURCE: "NEED_AUTHORIZED_SOURCE";
+    DEFERRED: "DEFERRED";
+    RETIRED: "RETIRED";
+}>;
+export declare const sourceCoverageStateSchema: z.ZodEnum<{
+    ACCESS_CONTROLLED: "ACCESS_CONTROLLED";
+    PARTIAL: "PARTIAL";
+    ACQUIRED: "ACQUIRED";
+    BLOCKED: "BLOCKED";
+    PENDING_DISCOVERY: "PENDING_DISCOVERY";
+    KNOWN_MISSING: "KNOWN_MISSING";
+    NEED_AUTHORIZED_SOURCE: "NEED_AUTHORIZED_SOURCE";
+    DEFERRED: "DEFERRED";
+    RETIRED: "RETIRED";
+    CONFIGURED_UNOBSERVED: "CONFIGURED_UNOBSERVED";
+}>;
+export declare const sourceDiscoveryPolicySchema: z.ZodObject<{
+    hostMode: z.ZodDefault<z.ZodEnum<{
+        ALLOWLIST: "ALLOWLIST";
+        EVIDENCE_OBSERVED: "EVIDENCE_OBSERVED";
+    }>>;
+    allowedHosts: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    forbiddenHostSuffixes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    allowedPathPrefixes: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const sourceUniverseEntrySchema: z.ZodObject<{
+    sourceId: z.ZodString;
+    familyId: z.ZodString;
+    acquisitionSourceIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    expectation: z.ZodEnum<{
+        REQUIRED: "REQUIRED";
+        OPTIONAL: "OPTIONAL";
+        CONDITIONAL: "CONDITIONAL";
+    }>;
+    authority: z.ZodString;
+    access: z.ZodEnum<{
+        PUBLIC: "PUBLIC";
+        PUBLIC_METADATA: "PUBLIC_METADATA";
+        TENANT: "TENANT";
+        INTERNAL: "INTERNAL";
+        FDE_INTERNAL: "FDE_INTERNAL";
+        ACCESS_CONTROLLED: "ACCESS_CONTROLLED";
+        UNKNOWN: "UNKNOWN";
+    }>;
+    freshness: z.ZodString;
+    semanticRoles: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    locator: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    declaredState: z.ZodEnum<{
+        ACCESS_CONTROLLED: "ACCESS_CONTROLLED";
+        CONFIGURED: "CONFIGURED";
+        PENDING_DISCOVERY: "PENDING_DISCOVERY";
+        KNOWN_MISSING: "KNOWN_MISSING";
+        NEED_AUTHORIZED_SOURCE: "NEED_AUTHORIZED_SOURCE";
+        DEFERRED: "DEFERRED";
+        RETIRED: "RETIRED";
+    }>;
+    expectedOwner: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    requiredFor: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    discoveryPolicy: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        hostMode: z.ZodDefault<z.ZodEnum<{
+            ALLOWLIST: "ALLOWLIST";
+            EVIDENCE_OBSERVED: "EVIDENCE_OBSERVED";
+        }>>;
+        allowedHosts: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        forbiddenHostSuffixes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        allowedPathPrefixes: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>>;
+    notes: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
+export declare const sourceUniverseSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    projectKey: z.ZodString;
+    asOf: z.ZodISODateTime;
+    sources: z.ZodArray<z.ZodObject<{
+        sourceId: z.ZodString;
+        familyId: z.ZodString;
+        acquisitionSourceIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        expectation: z.ZodEnum<{
+            REQUIRED: "REQUIRED";
+            OPTIONAL: "OPTIONAL";
+            CONDITIONAL: "CONDITIONAL";
+        }>;
+        authority: z.ZodString;
+        access: z.ZodEnum<{
+            PUBLIC: "PUBLIC";
+            PUBLIC_METADATA: "PUBLIC_METADATA";
+            TENANT: "TENANT";
+            INTERNAL: "INTERNAL";
+            FDE_INTERNAL: "FDE_INTERNAL";
+            ACCESS_CONTROLLED: "ACCESS_CONTROLLED";
+            UNKNOWN: "UNKNOWN";
+        }>;
+        freshness: z.ZodString;
+        semanticRoles: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        locator: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        declaredState: z.ZodEnum<{
+            ACCESS_CONTROLLED: "ACCESS_CONTROLLED";
+            CONFIGURED: "CONFIGURED";
+            PENDING_DISCOVERY: "PENDING_DISCOVERY";
+            KNOWN_MISSING: "KNOWN_MISSING";
+            NEED_AUTHORIZED_SOURCE: "NEED_AUTHORIZED_SOURCE";
+            DEFERRED: "DEFERRED";
+            RETIRED: "RETIRED";
+        }>;
+        expectedOwner: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        requiredFor: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        discoveryPolicy: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            hostMode: z.ZodDefault<z.ZodEnum<{
+                ALLOWLIST: "ALLOWLIST";
+                EVIDENCE_OBSERVED: "EVIDENCE_OBSERVED";
+            }>>;
+            allowedHosts: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            forbiddenHostSuffixes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            allowedPathPrefixes: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>>;
+        notes: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const sourceCoverageEntrySchema: z.ZodObject<{
+    sourceId: z.ZodString;
+    familyId: z.ZodString;
+    expectation: z.ZodEnum<{
+        REQUIRED: "REQUIRED";
+        OPTIONAL: "OPTIONAL";
+        CONDITIONAL: "CONDITIONAL";
+    }>;
+    declaredState: z.ZodEnum<{
+        ACCESS_CONTROLLED: "ACCESS_CONTROLLED";
+        CONFIGURED: "CONFIGURED";
+        PENDING_DISCOVERY: "PENDING_DISCOVERY";
+        KNOWN_MISSING: "KNOWN_MISSING";
+        NEED_AUTHORIZED_SOURCE: "NEED_AUTHORIZED_SOURCE";
+        DEFERRED: "DEFERRED";
+        RETIRED: "RETIRED";
+    }>;
+    coverageState: z.ZodEnum<{
+        ACCESS_CONTROLLED: "ACCESS_CONTROLLED";
+        PARTIAL: "PARTIAL";
+        ACQUIRED: "ACQUIRED";
+        BLOCKED: "BLOCKED";
+        PENDING_DISCOVERY: "PENDING_DISCOVERY";
+        KNOWN_MISSING: "KNOWN_MISSING";
+        NEED_AUTHORIZED_SOURCE: "NEED_AUTHORIZED_SOURCE";
+        DEFERRED: "DEFERRED";
+        RETIRED: "RETIRED";
+        CONFIGURED_UNOBSERVED: "CONFIGURED_UNOBSERVED";
+    }>;
+    configuredItemCount: z.ZodNumber;
+    observedItemCount: z.ZodNumber;
+    acquiredItemCount: z.ZodNumber;
+    blockedItemCount: z.ZodNumber;
+    accessControlledItemCount: z.ZodNumber;
+    evidenceRefs: z.ZodArray<z.ZodString>;
+    blockers: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const sourceCoverageAssessmentSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    projectKey: z.ZodString;
+    assessedAt: z.ZodISODateTime;
+    complete: z.ZodBoolean;
+    requiredSourceCount: z.ZodNumber;
+    coveredRequiredSourceCount: z.ZodNumber;
+    entries: z.ZodArray<z.ZodObject<{
+        sourceId: z.ZodString;
+        familyId: z.ZodString;
+        expectation: z.ZodEnum<{
+            REQUIRED: "REQUIRED";
+            OPTIONAL: "OPTIONAL";
+            CONDITIONAL: "CONDITIONAL";
+        }>;
+        declaredState: z.ZodEnum<{
+            ACCESS_CONTROLLED: "ACCESS_CONTROLLED";
+            CONFIGURED: "CONFIGURED";
+            PENDING_DISCOVERY: "PENDING_DISCOVERY";
+            KNOWN_MISSING: "KNOWN_MISSING";
+            NEED_AUTHORIZED_SOURCE: "NEED_AUTHORIZED_SOURCE";
+            DEFERRED: "DEFERRED";
+            RETIRED: "RETIRED";
+        }>;
+        coverageState: z.ZodEnum<{
+            ACCESS_CONTROLLED: "ACCESS_CONTROLLED";
+            PARTIAL: "PARTIAL";
+            ACQUIRED: "ACQUIRED";
+            BLOCKED: "BLOCKED";
+            PENDING_DISCOVERY: "PENDING_DISCOVERY";
+            KNOWN_MISSING: "KNOWN_MISSING";
+            NEED_AUTHORIZED_SOURCE: "NEED_AUTHORIZED_SOURCE";
+            DEFERRED: "DEFERRED";
+            RETIRED: "RETIRED";
+            CONFIGURED_UNOBSERVED: "CONFIGURED_UNOBSERVED";
+        }>;
+        configuredItemCount: z.ZodNumber;
+        observedItemCount: z.ZodNumber;
+        acquiredItemCount: z.ZodNumber;
+        blockedItemCount: z.ZodNumber;
+        accessControlledItemCount: z.ZodNumber;
+        evidenceRefs: z.ZodArray<z.ZodString>;
+        blockers: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    blockers: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const sourceGapStateSchema: z.ZodEnum<{
+    ACCESS_CONTROLLED: "ACCESS_CONTROLLED";
+    PENDING_DISCOVERY: "PENDING_DISCOVERY";
+    KNOWN_MISSING: "KNOWN_MISSING";
+    NEED_AUTHORIZED_SOURCE: "NEED_AUTHORIZED_SOURCE";
+    DEFERRED: "DEFERRED";
+}>;
+export declare const sourceGapSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    gapId: z.ZodString;
+    projectKey: z.ZodString;
+    sourceId: z.ZodString;
+    familyId: z.ZodString;
+    state: z.ZodEnum<{
+        ACCESS_CONTROLLED: "ACCESS_CONTROLLED";
+        PENDING_DISCOVERY: "PENDING_DISCOVERY";
+        KNOWN_MISSING: "KNOWN_MISSING";
+        NEED_AUTHORIZED_SOURCE: "NEED_AUTHORIZED_SOURCE";
+        DEFERRED: "DEFERRED";
+    }>;
+    access: z.ZodEnum<{
+        PUBLIC: "PUBLIC";
+        PUBLIC_METADATA: "PUBLIC_METADATA";
+        TENANT: "TENANT";
+        INTERNAL: "INTERNAL";
+        FDE_INTERNAL: "FDE_INTERNAL";
+        ACCESS_CONTROLLED: "ACCESS_CONTROLLED";
+        UNKNOWN: "UNKNOWN";
+    }>;
+    expectedOwner: z.ZodNullable<z.ZodString>;
+    reason: z.ZodString;
+    requiredFor: z.ZodArray<z.ZodString>;
+    evidenceRefs: z.ZodArray<z.ZodString>;
+    recordedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export declare const sourceDiscoveryProposalSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    projectKey: z.ZodString;
+    proposalId: z.ZodString;
+    familyId: z.ZodString;
+    createdAt: z.ZodISODateTime;
+    observedLinks: z.ZodArray<z.ZodObject<{
+        linkId: z.ZodString;
+        url: z.ZodURL;
+        locator: z.ZodString;
+        parentEvidenceRef: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    selectedLinkIds: z.ZodArray<z.ZodString>;
+    completeness: z.ZodObject<{
+        claim: z.ZodEnum<{
+            COMPLETE: "COMPLETE";
+            INCOMPLETE: "INCOMPLETE";
+        }>;
+        missing: z.ZodArray<z.ZodString>;
+        notes: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const sourceDiscoveryValidationSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    projectKey: z.ZodString;
+    proposalId: z.ZodString;
+    familyId: z.ZodString;
+    proposalHash: z.ZodString;
+    valid: z.ZodBoolean;
+    selectedSources: z.ZodArray<z.ZodObject<{
+        linkId: z.ZodString;
+        url: z.ZodURL;
+        parentEvidenceRef: z.ZodString;
+    }, z.core.$strict>>;
+    completeness: z.ZodObject<{
+        claim: z.ZodEnum<{
+            COMPLETE: "COMPLETE";
+            INCOMPLETE: "INCOMPLETE";
+        }>;
+        missing: z.ZodArray<z.ZodString>;
+        notes: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    evidenceRefs: z.ZodArray<z.ZodString>;
+    errors: z.ZodArray<z.ZodString>;
+    warnings: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const sourceDiscoveryReceiptSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    projectKey: z.ZodString;
+    proposalId: z.ZodString;
+    familyId: z.ZodString;
+    proposalHash: z.ZodString;
+    state: z.ZodEnum<{
+        COMPLETE: "COMPLETE";
+        REVIEWED_PARTIAL: "REVIEWED_PARTIAL";
+    }>;
+    proposalRef: z.ZodString;
+    reviewRef: z.ZodString;
+    reviewedAt: z.ZodISODateTime;
+    selectedSources: z.ZodArray<z.ZodObject<{
+        linkId: z.ZodString;
+        url: z.ZodURL;
+        parentEvidenceRef: z.ZodString;
+    }, z.core.$strict>>;
+    completeness: z.ZodObject<{
+        claim: z.ZodEnum<{
+            COMPLETE: "COMPLETE";
+            INCOMPLETE: "INCOMPLETE";
+        }>;
+        missing: z.ZodArray<z.ZodString>;
+        notes: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    evidenceRefs: z.ZodArray<z.ZodString>;
+    configMutationPerformed: z.ZodLiteral<false>;
+}, z.core.$strict>;
+export type SourceDiscoveryPolicy = z.infer<typeof sourceDiscoveryPolicySchema>;
+export type SourceExpectation = z.infer<typeof sourceExpectationSchema>;
+export type SourceDeclaredState = z.infer<typeof sourceDeclaredStateSchema>;
+export type SourceCoverageState = z.infer<typeof sourceCoverageStateSchema>;
+export type SourceUniverseEntry = z.infer<typeof sourceUniverseEntrySchema>;
+export type SourceUniverse = z.infer<typeof sourceUniverseSchema>;
+export type SourceCoverageEntry = z.infer<typeof sourceCoverageEntrySchema>;
+export type SourceCoverageAssessment = z.infer<typeof sourceCoverageAssessmentSchema>;
+export type SourceGap = z.infer<typeof sourceGapSchema>;
+export type SourceDiscoveryProposal = z.infer<typeof sourceDiscoveryProposalSchema>;
+export type SourceDiscoveryValidation = z.infer<typeof sourceDiscoveryValidationSchema>;
+export declare const sourceAdmissionMatchSchema: z.ZodObject<{
+    url: z.ZodURL;
+    status: z.ZodEnum<{
+        BLOCKED: "BLOCKED";
+        ADMITTED: "ADMITTED";
+        MISSING: "MISSING";
+        DUPLICATE: "DUPLICATE";
+    }>;
+    universeSourceId: z.ZodNullable<z.ZodString>;
+    acquisitionSourceId: z.ZodNullable<z.ZodString>;
+    concreteSourceId: z.ZodNullable<z.ZodString>;
+    issues: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const sourceAdmissionAssessmentSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    projectKey: z.ZodString;
+    familyId: z.ZodString;
+    state: z.ZodEnum<{
+        BLOCKED: "BLOCKED";
+        ADMITTED: "ADMITTED";
+    }>;
+    selectedSourceCount: z.ZodNumber;
+    matches: z.ZodArray<z.ZodObject<{
+        url: z.ZodURL;
+        status: z.ZodEnum<{
+            BLOCKED: "BLOCKED";
+            ADMITTED: "ADMITTED";
+            MISSING: "MISSING";
+            DUPLICATE: "DUPLICATE";
+        }>;
+        universeSourceId: z.ZodNullable<z.ZodString>;
+        acquisitionSourceId: z.ZodNullable<z.ZodString>;
+        concreteSourceId: z.ZodNullable<z.ZodString>;
+        issues: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    blockers: z.ZodArray<z.ZodString>;
+    configMutationPerformed: z.ZodLiteral<false>;
+}, z.core.$strict>;
+export type SourceDiscoveryReceipt = z.infer<typeof sourceDiscoveryReceiptSchema>;
+export type SourceAdmissionMatch = z.infer<typeof sourceAdmissionMatchSchema>;
+export type SourceAdmissionAssessment = z.infer<typeof sourceAdmissionAssessmentSchema>;