@kaelio/ktx 0.4.0 → 0.5.0

package/node_modules/@ktx/context/dist/scan/relationship-diagnostics.d.ts

@@ -1,94 +0,0 @@
-import type { KtxRelationshipType, KtxRelationshipUpdate } from './enrichment-types.js';
-import type { KtxResolvedRelationshipDiscoveryCandidate, KtxResolvedRelationshipStatus } from './relationship-graph-resolver.js';
-import type { KtxCompositeRelationshipCandidate } from './relationship-composite-candidates.js';
-import type { KtxRelationshipProfileArtifact } from './relationship-profiling.js';
-import type { KtxConnectionDriver, KtxScanWarning } from './types.js';
-export interface KtxRelationshipArtifactEndpoint {
-    tableId: string;
-    columnIds: string[];
-    table: {
-        catalog: string | null;
-        db: string | null;
-        name: string;
-    };
-    columns: string[];
-}
-export interface KtxRelationshipArtifactEdge {
-    id: string;
-    status: KtxResolvedRelationshipStatus;
-    source: string;
-    from: KtxRelationshipArtifactEndpoint;
-    to: KtxRelationshipArtifactEndpoint;
-    relationshipType: KtxRelationshipType;
-    confidence: number;
-    pkScore: number | null;
-    fkScore: number | null;
-    score: number | null;
-    evidence: unknown | null;
-    validation: unknown | null;
-    graph: unknown | null;
-    reasons: string[];
-}
-export interface KtxRelationshipArtifact {
-    connectionId: string;
-    accepted: KtxRelationshipArtifactEdge[];
-    review: KtxRelationshipArtifactEdge[];
-    rejected: KtxRelationshipArtifactEdge[];
-    skipped: KtxRelationshipUpdate['skipped'];
-}
-export interface KtxRelationshipDiagnosticsSummary {
-    accepted: number;
-    review: number;
-    rejected: number;
-    skipped: number;
-}
-export interface KtxRelationshipDiagnosticsValidation {
-    available: boolean;
-    sqlAvailable: boolean;
-    queryCount: number;
-}
-export interface KtxRelationshipDiagnosticsThresholds {
-    acceptThreshold: number;
-    reviewThreshold: number;
-}
-export interface KtxRelationshipDiagnosticsPolicy {
-    validationRequiredForManifest: boolean;
-    maxCandidatesPerColumn: number;
-    profileSampleRows: number;
-    validationConcurrency: number;
-}
-export interface KtxRelationshipDiagnosticsArtifact {
-    connectionId: string;
-    generatedAt: string;
-    summary: KtxRelationshipDiagnosticsSummary;
-    noAcceptedReason: string | null;
-    candidateCountsBySource: Record<string, number>;
-    validation: KtxRelationshipDiagnosticsValidation;
-    thresholds: KtxRelationshipDiagnosticsThresholds;
-    policy: KtxRelationshipDiagnosticsPolicy;
-    warnings: KtxScanWarning[];
-    profileWarnings: string[];
-}
-export interface BuildKtxRelationshipArtifactsInput {
-    connectionId: string;
-    relationshipUpdate?: KtxRelationshipUpdate | null;
-    resolvedRelationships?: readonly KtxResolvedRelationshipDiscoveryCandidate[];
-    compositeRelationships?: readonly KtxCompositeRelationshipCandidate[];
-}
-export interface BuildKtxRelationshipDiagnosticsInput {
-    connectionId: string;
-    artifacts: KtxRelationshipArtifact;
-    profile: KtxRelationshipProfileArtifact;
-    warnings?: readonly KtxScanWarning[];
-    thresholds?: Partial<KtxRelationshipDiagnosticsThresholds>;
-    policy?: Partial<KtxRelationshipDiagnosticsPolicy>;
-    generatedAt?: string;
-}
-export interface EmptyKtxRelationshipProfileArtifactInput {
-    connectionId: string;
-    driver: KtxConnectionDriver;
-    reason: string;
-}
-export declare function buildKtxRelationshipArtifacts(input: BuildKtxRelationshipArtifactsInput): KtxRelationshipArtifact;
-export declare function emptyKtxRelationshipProfileArtifact(input: EmptyKtxRelationshipProfileArtifactInput): KtxRelationshipProfileArtifact;
-export declare function buildKtxRelationshipDiagnostics(input: BuildKtxRelationshipDiagnosticsInput): KtxRelationshipDiagnosticsArtifact;

package/node_modules/@ktx/context/dist/scan/relationship-diagnostics.js

@@ -1,224 +0,0 @@
-const DEFAULT_THRESHOLDS = {
-    acceptThreshold: 0.85,
-    reviewThreshold: 0.55,
-};
-const DEFAULT_POLICY = {
-    validationRequiredForManifest: true,
-    maxCandidatesPerColumn: 25,
-    profileSampleRows: 10000,
-    validationConcurrency: 4,
-};
-function endpointArtifact(endpoint) {
-    return {
-        tableId: endpoint.tableId,
-        columnIds: endpoint.columnIds,
-        table: {
-            catalog: endpoint.table.catalog,
-            db: endpoint.table.db,
-            name: endpoint.table.name,
-        },
-        columns: endpoint.columns,
-    };
-}
-function uniqueReasons(values) {
-    return Array.from(new Set(values.filter((value) => value.trim().length > 0)));
-}
-function relationshipUpdateEdge(relationship, status) {
-    const acceptedReason = relationship.source === 'formal' ? 'formal_metadata_accepted' : 'accepted_relationship_update';
-    return {
-        id: relationship.id,
-        status,
-        source: relationship.source,
-        from: endpointArtifact(relationship.from),
-        to: endpointArtifact(relationship.to),
-        relationshipType: relationship.relationshipType,
-        confidence: relationship.confidence,
-        pkScore: null,
-        fkScore: null,
-        score: relationship.confidence,
-        evidence: relationship.source === 'formal' ? { source: 'formal_metadata' } : null,
-        validation: relationship.source === 'formal' ? { status: 'formal_metadata' } : null,
-        graph: null,
-        reasons: [status === 'accepted' ? acceptedReason : 'rejected_relationship_update'],
-    };
-}
-function resolvedEdge(candidate) {
-    return {
-        id: candidate.id,
-        status: candidate.status,
-        source: candidate.source,
-        from: endpointArtifact(candidate.from),
-        to: endpointArtifact(candidate.to),
-        relationshipType: candidate.relationshipType,
-        confidence: candidate.confidence,
-        pkScore: candidate.pkScore,
-        fkScore: candidate.fkScore,
-        score: candidate.score,
-        evidence: candidate.evidence,
-        validation: candidate.validation,
-        graph: candidate.graph,
-        reasons: uniqueReasons([
-            ...candidate.evidence.reasons,
-            ...candidate.validation.reasons,
-            ...candidate.graph.reasons,
-        ]),
-    };
-}
-function compositeEndpointArtifact(endpoint) {
-    return {
-        tableId: endpoint.tableId,
-        columnIds: endpoint.columnIds,
-        table: {
-            catalog: endpoint.table.catalog,
-            db: endpoint.table.db,
-            name: endpoint.table.name,
-        },
-        columns: endpoint.columns,
-    };
-}
-function compositeEdge(candidate) {
-    return {
-        id: candidate.id,
-        status: candidate.status,
-        source: candidate.source,
-        from: compositeEndpointArtifact(candidate.from),
-        to: compositeEndpointArtifact(candidate.to),
-        relationshipType: candidate.relationshipType,
-        confidence: candidate.confidence,
-        pkScore: null,
-        fkScore: candidate.confidence,
-        score: candidate.confidence,
-        evidence: { source: candidate.source },
-        validation: candidate.validation,
-        graph: null,
-        reasons: uniqueReasons(candidate.validation.reasons),
-    };
-}
-function emptyArtifacts(connectionId) {
-    return {
-        connectionId,
-        accepted: [],
-        review: [],
-        rejected: [],
-        skipped: [],
-    };
-}
-function pushUniqueEdge(edges, edge) {
-    if (!edges.some((item) => item.id === edge.id)) {
-        edges.push(edge);
-    }
-}
-export function buildKtxRelationshipArtifacts(input) {
-    const artifacts = emptyArtifacts(input.connectionId);
-    if (input.resolvedRelationships) {
-        for (const candidate of input.resolvedRelationships) {
-            const edge = resolvedEdge(candidate);
-            if (edge.status === 'accepted') {
-                pushUniqueEdge(artifacts.accepted, edge);
-            }
-            else if (edge.status === 'review') {
-                pushUniqueEdge(artifacts.review, edge);
-            }
-            else {
-                pushUniqueEdge(artifacts.rejected, edge);
-            }
-        }
-    }
-    for (const candidate of input.compositeRelationships ?? []) {
-        const edge = compositeEdge(candidate);
-        if (edge.status === 'accepted') {
-            pushUniqueEdge(artifacts.accepted, edge);
-        }
-        else if (edge.status === 'review') {
-            pushUniqueEdge(artifacts.review, edge);
-        }
-        else {
-            pushUniqueEdge(artifacts.rejected, edge);
-        }
-    }
-    const relationshipUpdate = input.relationshipUpdate;
-    if (relationshipUpdate) {
-        for (const relationship of relationshipUpdate.accepted) {
-            pushUniqueEdge(artifacts.accepted, relationshipUpdateEdge(relationship, 'accepted'));
-        }
-        for (const relationship of relationshipUpdate.rejected) {
-            pushUniqueEdge(artifacts.rejected, relationshipUpdateEdge(relationship, 'rejected'));
-        }
-        artifacts.skipped.push(...relationshipUpdate.skipped);
-    }
-    return {
-        connectionId: artifacts.connectionId,
-        accepted: artifacts.accepted.sort((left, right) => left.id.localeCompare(right.id)),
-        review: artifacts.review.sort((left, right) => left.id.localeCompare(right.id)),
-        rejected: artifacts.rejected.sort((left, right) => left.id.localeCompare(right.id)),
-        skipped: [...artifacts.skipped].sort((left, right) => left.relationshipId.localeCompare(right.relationshipId)),
-    };
-}
-function allEdges(artifacts) {
-    return [...artifacts.accepted, ...artifacts.review, ...artifacts.rejected];
-}
-function candidateCountsBySource(artifacts) {
-    const counts = {};
-    for (const edge of allEdges(artifacts)) {
-        counts[edge.source] = (counts[edge.source] ?? 0) + 1;
-    }
-    return Object.fromEntries(Object.entries(counts).sort(([left], [right]) => left.localeCompare(right)));
-}
-function hasReason(artifacts, reason) {
-    return allEdges(artifacts).some((edge) => edge.reasons.includes(reason));
-}
-function noAcceptedReason(input) {
-    if (input.artifacts.accepted.length > 0) {
-        return null;
-    }
-    if (input.artifacts.review.length > 0 &&
-        (!input.profile.sqlAvailable ||
-            hasReason(input.artifacts, 'validation_unavailable') ||
-            hasReason(input.artifacts, 'validation_unavailable_review_only'))) {
-        return 'validation unavailable; review candidates written';
-    }
-    if (input.artifacts.review.length > 0) {
-        return 'relationship candidates require review before manifest writes';
-    }
-    if (input.artifacts.rejected.length > 0) {
-        return 'all candidate pairs were rejected';
-    }
-    return 'no candidate pairs passed type compatibility';
-}
-export function emptyKtxRelationshipProfileArtifact(input) {
-    return {
-        connectionId: input.connectionId,
-        driver: input.driver,
-        sqlAvailable: false,
-        queryCount: 0,
-        tables: [],
-        columns: {},
-        warnings: [input.reason],
-    };
-}
-export function buildKtxRelationshipDiagnostics(input) {
-    const thresholds = { ...DEFAULT_THRESHOLDS, ...input.thresholds };
-    const policy = { ...DEFAULT_POLICY, ...input.policy };
-    const summary = {
-        accepted: input.artifacts.accepted.length,
-        review: input.artifacts.review.length,
-        rejected: input.artifacts.rejected.length,
-        skipped: input.artifacts.skipped.length,
-    };
-    return {
-        connectionId: input.connectionId,
-        generatedAt: input.generatedAt ?? new Date().toISOString(),
-        summary,
-        noAcceptedReason: noAcceptedReason({ artifacts: input.artifacts, profile: input.profile }),
-        candidateCountsBySource: candidateCountsBySource(input.artifacts),
-        validation: {
-            available: input.profile.sqlAvailable,
-            sqlAvailable: input.profile.sqlAvailable,
-            queryCount: input.profile.queryCount,
-        },
-        thresholds,
-        policy,
-        warnings: [...(input.warnings ?? [])],
-        profileWarnings: [...input.profile.warnings],
-    };
-}

package/node_modules/@ktx/context/dist/scan/relationship-discovery.d.ts

@@ -1,27 +0,0 @@
-import type { KtxLlmRuntimePort } from '../llm/index.js';
-import type { KtxScanRelationshipConfig } from '../project/config.js';
-import type { KtxEnrichedSchema, KtxRelationshipUpdate } from './enrichment-types.js';
-import { type KtxCompositeRelationshipCandidate } from './relationship-composite-candidates.js';
-import { type KtxResolvedRelationshipDiscoveryCandidate } from './relationship-graph-resolver.js';
-import { type KtxRelationshipProfileArtifact } from './relationship-profiling.js';
-import type { KtxConnectionDriver, KtxScanConnector, KtxScanContext, KtxScanEnrichmentSummary, KtxScanRelationshipSummary, KtxScanWarning } from './types.js';
-export interface DiscoverKtxRelationshipsInput {
-    connectionId: string;
-    driver: KtxConnectionDriver;
-    connector: KtxScanConnector;
-    schema: KtxEnrichedSchema;
-    context: KtxScanContext;
-    settings: KtxScanRelationshipConfig;
-    llmRuntime?: KtxLlmRuntimePort | null;
-}
-export interface DiscoverKtxRelationshipsResult {
-    relationshipUpdate: KtxRelationshipUpdate;
-    relationships: KtxScanRelationshipSummary;
-    profile: KtxRelationshipProfileArtifact;
-    resolvedRelationships: KtxResolvedRelationshipDiscoveryCandidate[];
-    compositeRelationships: KtxCompositeRelationshipCandidate[];
-    statisticalValidation: KtxScanEnrichmentSummary['statisticalValidation'];
-    llmRelationshipValidation: KtxScanEnrichmentSummary['llmRelationshipValidation'];
-    warnings: KtxScanWarning[];
-}
-export declare function discoverKtxRelationships(input: DiscoverKtxRelationshipsInput): Promise<DiscoverKtxRelationshipsResult>;

package/node_modules/@ktx/context/dist/scan/relationship-discovery.js

@@ -1,247 +0,0 @@
-import { generateKtxRelationshipDiscoveryCandidates, mergeKtxRelationshipDiscoveryCandidates, } from './relationship-candidates.js';
-import { discoverKtxCompositeRelationships, } from './relationship-composite-candidates.js';
-import { collectKtxFormalMetadataRelationships } from './relationship-formal-metadata.js';
-import { resolveKtxRelationshipGraph, } from './relationship-graph-resolver.js';
-import { proposeKtxRelationshipCandidatesWithLlm } from './relationship-llm-proposal.js';
-import { createKtxRelationshipProfileCache, profileKtxRelationshipSchema, } from './relationship-profiling.js';
-import { validateKtxRelationshipDiscoveryCandidates } from './relationship-validation.js';
-function relationshipFromResolved(candidate) {
-    return {
-        id: candidate.id,
-        source: 'inferred',
-        from: candidate.from,
-        to: candidate.to,
-        relationshipType: candidate.relationshipType,
-        confidence: candidate.fkScore,
-        isPrimaryKeyReference: candidate.pkScore >= 0.78,
-    };
-}
-function relationshipFromComposite(candidate) {
-    return {
-        id: candidate.id,
-        source: 'inferred',
-        from: {
-            tableId: candidate.from.tableId,
-            columnIds: candidate.from.columnIds,
-            table: candidate.from.table,
-            columns: candidate.from.columns,
-        },
-        to: {
-            tableId: candidate.to.tableId,
-            columnIds: candidate.to.columnIds,
-            table: candidate.to.table,
-            columns: candidate.to.columns,
-        },
-        relationshipType: candidate.relationshipType,
-        confidence: candidate.confidence,
-        isPrimaryKeyReference: candidate.status === 'accepted',
-    };
-}
-function relationshipId(input) {
-    return `${input.from.tableId}:(${input.from.columnIds.join(',')})->${input.to.tableId}:(${input.to.columnIds.join(',')})`;
-}
-function nonFormalAcceptedRelationships(input) {
-    return input.resolvedRelationships
-        .filter((candidate) => candidate.status === 'accepted' && !input.formalIds.has(candidate.id))
-        .map(relationshipFromResolved);
-}
-function relationshipSummary(resolvedRelationships) {
-    return {
-        accepted: resolvedRelationships.filter((candidate) => candidate.status === 'accepted').length,
-        review: resolvedRelationships.filter((candidate) => candidate.status === 'review').length,
-        rejected: resolvedRelationships.filter((candidate) => candidate.status === 'rejected').length,
-        skipped: 0,
-    };
-}
-function compositeSummary(relationships) {
-    return {
-        accepted: relationships.filter((candidate) => candidate.status === 'accepted').length,
-        review: relationships.filter((candidate) => candidate.status === 'review').length,
-        rejected: relationships.filter((candidate) => candidate.status === 'rejected').length,
-        skipped: 0,
-    };
-}
-async function detectCompositeRelationships(input) {
-    if (!input.executor || !input.profile.sqlAvailable) {
-        return [];
-    }
-    try {
-        const compositeDetection = await discoverKtxCompositeRelationships({
-            connectionId: input.connectionId,
-            driver: input.driver,
-            schema: input.schema,
-            profiles: input.profile,
-            executor: input.executor,
-            ctx: input.context,
-        });
-        for (const warning of compositeDetection.warnings) {
-            input.warnings.push({
-                code: 'relationship_validation_failed',
-                message: warning,
-                recoverable: true,
-                metadata: { source: 'composite_relationship_detection' },
-            });
-        }
-        return compositeDetection.relationships;
-    }
-    catch (error) {
-        input.warnings.push({
-            code: 'relationship_validation_failed',
-            message: `KTX composite relationship detection failed: ${error instanceof Error ? error.message : String(error)}`,
-            recoverable: true,
-            metadata: { source: 'composite_relationship_detection' },
-        });
-        return [];
-    }
-}
-function combinedRelationshipSummary(input) {
-    const graph = relationshipSummary(input.resolvedRelationships);
-    return {
-        accepted: input.formalAccepted + graph.accepted,
-        review: graph.review,
-        rejected: graph.rejected,
-        skipped: input.formalSkipped,
-    };
-}
-function sqlExecutor(input) {
-    if (!input.connector.capabilities.readOnlySql) {
-        return {
-            executor: null,
-            warnings: [
-                {
-                    code: 'connector_capability_missing',
-                    message: 'KTX scan connector cannot run read-only SQL relationship validation',
-                    recoverable: true,
-                    metadata: { capability: 'readOnlySql' },
-                },
-            ],
-        };
-    }
-    if (!input.connector.executeReadOnly) {
-        return {
-            executor: null,
-            warnings: [
-                {
-                    code: 'relationship_validation_failed',
-                    message: 'KTX scan connector advertises readOnlySql but does not expose executeReadOnly',
-                    recoverable: true,
-                    metadata: { capability: 'readOnlySql' },
-                },
-            ],
-        };
-    }
-    return {
-        executor: {
-            executeReadOnly: input.connector.executeReadOnly.bind(input.connector),
-        },
-        warnings: [],
-    };
-}
-export async function discoverKtxRelationships(input) {
-    const { executor, warnings } = sqlExecutor(input);
-    const formalMetadata = collectKtxFormalMetadataRelationships(input.schema);
-    const profileCache = createKtxRelationshipProfileCache();
-    const profile = await profileKtxRelationshipSchema({
-        connectionId: input.connectionId,
-        driver: input.driver,
-        schema: input.schema,
-        executor,
-        ctx: input.context,
-        profileSampleRows: input.settings.profileSampleRows,
-        cache: profileCache,
-    });
-    const deterministicCandidates = generateKtxRelationshipDiscoveryCandidates(input.schema, {
-        maxCandidatesPerColumn: input.settings.maxCandidatesPerColumn,
-        profiles: profile,
-    });
-    const llmProposalResult = input.settings.llmProposals
-        ? await proposeKtxRelationshipCandidatesWithLlm({
-            connectionId: input.connectionId,
-            schema: input.schema,
-            profile,
-            llmRuntime: input.llmRuntime ?? null,
-            settings: {
-                maxTablesPerBatch: input.settings.maxLlmTablesPerBatch,
-            },
-        })
-        : { candidates: [], warnings: [], llmCalls: 0, summary: 'skipped' };
-    const candidates = mergeKtxRelationshipDiscoveryCandidates([
-        ...deterministicCandidates,
-        ...llmProposalResult.candidates,
-    ]).filter((candidate) => !formalMetadata.acceptedIds.has(candidate.id));
-    warnings.push(...llmProposalResult.warnings);
-    const validated = await validateKtxRelationshipDiscoveryCandidates({
-        connectionId: input.connectionId,
-        driver: input.driver,
-        candidates,
-        profiles: profile,
-        executor,
-        ctx: input.context,
-        tableCount: input.schema.tables.length,
-        settings: {
-            acceptThreshold: input.settings.acceptThreshold,
-            reviewThreshold: input.settings.reviewThreshold,
-            maxDistinctSourceValues: input.settings.profileSampleRows,
-            concurrency: input.settings.validationConcurrency,
-            validationBudget: input.settings.validationBudget,
-        },
-    });
-    const graph = resolveKtxRelationshipGraph({
-        schema: input.schema,
-        profiles: profile,
-        candidates: validated,
-        settings: {
-            acceptThreshold: input.settings.acceptThreshold,
-            reviewThreshold: input.settings.reviewThreshold,
-            validationRequiredForManifest: input.settings.validationRequiredForManifest,
-        },
-    });
-    const compositeRelationships = await detectCompositeRelationships({
-        connectionId: input.connectionId,
-        driver: input.driver,
-        schema: input.schema,
-        profile,
-        executor,
-        context: input.context,
-        warnings,
-    });
-    const inferredAccepted = nonFormalAcceptedRelationships({
-        formalIds: formalMetadata.acceptedIds,
-        resolvedRelationships: graph.relationships,
-    });
-    const compositeAccepted = compositeRelationships
-        .filter((candidate) => candidate.status === 'accepted')
-        .map(relationshipFromComposite);
-    const relationshipsForAcceptance = formalMetadata.accepted.concat(inferredAccepted, compositeAccepted);
-    const acceptedById = new Map(relationshipsForAcceptance.map((relationship) => [relationship.id, relationship]));
-    const accepted = Array.from(acceptedById.values()).sort((left, right) => relationshipId(left).localeCompare(relationshipId(right)));
-    const rejected = graph.relationships
-        .filter((candidate) => candidate.status === 'rejected')
-        .map(relationshipFromResolved);
-    const combined = combinedRelationshipSummary({
-        formalAccepted: formalMetadata.accepted.length,
-        formalSkipped: formalMetadata.skipped.length,
-        resolvedRelationships: graph.relationships,
-    });
-    const compositeCounts = compositeSummary(compositeRelationships);
-    return {
-        relationshipUpdate: {
-            connectionId: input.connectionId,
-            accepted,
-            rejected,
-            skipped: formalMetadata.skipped,
-        },
-        relationships: {
-            accepted: combined.accepted + compositeCounts.accepted,
-            review: combined.review + compositeCounts.review,
-            rejected: combined.rejected + compositeCounts.rejected,
-            skipped: combined.skipped,
-        },
-        profile,
-        resolvedRelationships: graph.relationships,
-        compositeRelationships,
-        statisticalValidation: profile.sqlAvailable ? 'completed' : 'skipped',
-        llmRelationshipValidation: llmProposalResult.summary,
-        warnings,
-    };
-}

package/node_modules/@ktx/context/dist/scan/relationship-feedback-calibration.d.ts

@@ -1,70 +0,0 @@
-import type { KtxLocalProject } from '../project/index.js';
-import { exportLocalRelationshipFeedbackLabels, type ExportLocalRelationshipFeedbackLabelsInput, type ExportLocalRelationshipFeedbackLabelsResult, type KtxRelationshipFeedbackExportWarning, type KtxRelationshipFeedbackLabel } from './relationship-feedback-export.js';
-import type { KtxResolvedRelationshipStatus } from './relationship-graph-resolver.js';
-import type { KtxRelationshipReviewDecisionValue } from './relationship-review-decisions.js';
-type CalibrationPredictedStatus = KtxResolvedRelationshipStatus | 'unscored';
-interface Thresholds {
-    accept: number;
-    review: number;
-}
-export interface BuildKtxRelationshipFeedbackCalibrationReportInput {
-    acceptThreshold?: number;
-    reviewThreshold?: number;
-}
-export interface CalibrateLocalRelationshipFeedbackLabelsInput extends ExportLocalRelationshipFeedbackLabelsInput, BuildKtxRelationshipFeedbackCalibrationReportInput {
-    exportLocalRelationshipFeedbackLabels?: typeof exportLocalRelationshipFeedbackLabels;
-}
-export interface KtxRelationshipFeedbackCalibrationBucket {
-    label: string;
-    minInclusive: number;
-    maxInclusive: number;
-    total: number;
-    accepted: number;
-    rejected: number;
-    acceptanceRate: number | null;
-}
-export interface KtxRelationshipFeedbackCalibrationLabel {
-    candidateId: string;
-    decision: KtxRelationshipReviewDecisionValue;
-    previousStatus: KtxRelationshipFeedbackLabel['previousStatus'];
-    predictedStatus: CalibrationPredictedStatus;
-    bucket: string;
-    score: number | null;
-    pkScore: number | null;
-    fkScore: number | null;
-    connectionId: string;
-    runId: string;
-    fromTable: string;
-    fromColumns: string[];
-    toTable: string;
-    toColumns: string[];
-    source: string;
-    reasons: string[];
-}
-export interface KtxRelationshipFeedbackCalibrationReport {
-    generatedAt: string;
-    filters: ExportLocalRelationshipFeedbackLabelsResult['filters'];
-    thresholds: Thresholds;
-    summary: {
-        total: number;
-        scored: number;
-        unscored: number;
-        acceptedLabels: number;
-        rejectedLabels: number;
-        predictedAccepted: number;
-        predictedReview: number;
-        predictedRejected: number;
-        acceptedBandPrecision: number | null;
-        rejectedBandPrecision: number | null;
-        reviewBandAcceptedRate: number | null;
-        meanAcceptedScore: number | null;
-        meanRejectedScore: number | null;
-    };
-    buckets: KtxRelationshipFeedbackCalibrationBucket[];
-    labels: KtxRelationshipFeedbackCalibrationLabel[];
-    warnings: KtxRelationshipFeedbackExportWarning[];
-}
-export declare function buildKtxRelationshipFeedbackCalibrationReport(feedback: ExportLocalRelationshipFeedbackLabelsResult, input?: BuildKtxRelationshipFeedbackCalibrationReportInput): KtxRelationshipFeedbackCalibrationReport;
-export declare function calibrateLocalRelationshipFeedbackLabels(project: KtxLocalProject, input?: CalibrateLocalRelationshipFeedbackLabelsInput): Promise<KtxRelationshipFeedbackCalibrationReport>;
-export declare function formatKtxRelationshipFeedbackCalibrationMarkdown(report: KtxRelationshipFeedbackCalibrationReport): string;
-export {};