@nexalink/carecompass-sdk 0.6.1 → 0.7.0

package/dist/coding-ui.js

@@ -0,0 +1,358 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from "react";
+import { createRoot } from "react-dom/client";
+import { CARECOMPASS_CODING_DECISION_LABELS, createCodingFlow, decisionConflicts, decisionGaps, decisionPrimaryState, decisionRequiresHumanReview, } from "./coding.js";
+const REVIEW_IDLE_TIMEOUT_MS = 120_000;
+const ENGAGEMENT_TICK_MS = 5_000;
+/**
+ * Reports tenant-scoped reviewer engagement for the rendered decision:
+ * `decision_shown` once per decision, and active review time with a documented
+ * 120s idle pause and visibility rule. Delivery is best-effort and never
+ * blocks or fails the review workflow.
+ */
+const useReviewerEngagement = (flow, decision, workflowId) => {
+    const shownDecisionId = React.useRef(null);
+    const decisionRef = React.useRef(null);
+    const workflowRef = React.useRef(null);
+    const lastReviewActivityRef = React.useRef(Date.now());
+    decisionRef.current = decision;
+    workflowRef.current = workflowId;
+    const decisionId = decision?.decisionId ?? null;
+    const markReviewActivity = React.useCallback(() => {
+        lastReviewActivityRef.current = Date.now();
+    }, []);
+    React.useEffect(() => {
+        if (!decisionId || shownDecisionId.current === decisionId)
+            return;
+        const current = decisionRef.current;
+        if (!current)
+            return;
+        shownDecisionId.current = decisionId;
+        void flow.reportReviewerEvent({
+            eventName: "decision_shown",
+            caseRef: current.caseRef,
+            workflowId: workflowRef.current ?? "rcm-coding-assistance",
+        });
+    }, [decisionId, flow]);
+    React.useEffect(() => {
+        const trackedDecision = decisionRef.current;
+        const trackedWorkflow = workflowRef.current ?? "rcm-coding-assistance";
+        if (!decisionId || !trackedDecision)
+            return;
+        let activeSeconds = 0;
+        let idlePaused = false;
+        lastReviewActivityRef.current = Date.now();
+        let visible = typeof document === "undefined" || document.visibilityState === "visible";
+        const onVisibilityChange = () => {
+            visible = document.visibilityState === "visible";
+            if (visible)
+                markReviewActivity();
+        };
+        if (typeof window !== "undefined") {
+            document.addEventListener("visibilitychange", onVisibilityChange);
+        }
+        const interval = window.setInterval(() => {
+            if (!visible)
+                return;
+            if (Date.now() - lastReviewActivityRef.current > REVIEW_IDLE_TIMEOUT_MS) {
+                idlePaused = true;
+                return;
+            }
+            activeSeconds += ENGAGEMENT_TICK_MS / 1000;
+        }, ENGAGEMENT_TICK_MS);
+        return () => {
+            window.clearInterval(interval);
+            if (typeof window !== "undefined") {
+                document.removeEventListener("visibilitychange", onVisibilityChange);
+            }
+            if (activeSeconds >= 1) {
+                void flow.reportReviewerEvent({
+                    eventName: "review_active_time",
+                    caseRef: trackedDecision.caseRef,
+                    workflowId: trackedWorkflow,
+                    activeSeconds,
+                    idlePaused,
+                });
+            }
+        };
+    }, [decisionId, flow, markReviewActivity]);
+    const reportEvidenceEngagement = React.useCallback((evidenceId, action) => {
+        const current = decisionRef.current;
+        if (!current)
+            return;
+        void flow.reportReviewerEvent({
+            eventName: action === "opened" ? "evidence_opened" : "evidence_copied",
+            caseRef: current.caseRef,
+            workflowId: workflowRef.current ?? "rcm-coding-assistance",
+            evidenceId,
+        });
+    }, [flow]);
+    return { markReviewActivity, reportEvidenceEngagement };
+};
+const defaultLineLabel = (line) => {
+    const unitPart = line.units?.count !== undefined
+        ? ` x${line.units.count}${line.units.unitOfMeasure ? ` ${line.units.unitOfMeasure}` : ""}`
+        : "";
+    return [
+        line.action,
+        line.code.codeSystem,
+        line.code.code,
+        line.modifiers?.length ? ` (${line.modifiers.join(", ")})` : "",
+        unitPart,
+    ]
+        .filter(Boolean)
+        .join(" ");
+};
+const useFlowSnapshot = (flow) => {
+    const [snapshot, setSnapshot] = React.useState(() => flow?.getSnapshot() ?? null);
+    React.useEffect(() => {
+        if (!flow) {
+            setSnapshot(null);
+            return;
+        }
+        const unsubscribe = flow.subscribe(setSnapshot);
+        setSnapshot(flow.getSnapshot());
+        return unsubscribe;
+    }, [flow]);
+    return snapshot;
+};
+export function CareCompassCodingReviewContent({ config, flow, initialCase, labels: labelsOverride, onCodingDecision, packId, renderDecision, renderGap, renderLineDecision, reviewerId, reviewerRole, snapshot, }) {
+    const labels = {
+        ...CARECOMPASS_CODING_DECISION_LABELS,
+        ...labelsOverride,
+    };
+    const [reviewerAction, setReviewerAction] = React.useState(null);
+    const [recordedAt, setRecordedAt] = React.useState(null);
+    const [recording, setRecording] = React.useState(false);
+    const [recordError, setRecordError] = React.useState(null);
+    const notifiedDecisionId = React.useRef(null);
+    const { markReviewActivity, reportEvidenceEngagement } = useReviewerEngagement(flow, snapshot.decision, snapshot.packId);
+    React.useEffect(() => {
+        if (!snapshot.decision) {
+            notifiedDecisionId.current = null;
+            return;
+        }
+        if (snapshot.phase === "complete" &&
+            onCodingDecision &&
+            notifiedDecisionId.current !== snapshot.decision.decisionId) {
+            notifiedDecisionId.current = snapshot.decision.decisionId;
+            onCodingDecision(snapshot.decision);
+        }
+    }, [onCodingDecision, snapshot.decision, snapshot.phase]);
+    React.useEffect(() => {
+        setReviewerAction(null);
+        setRecordedAt(null);
+        setRecordError(null);
+    }, [snapshot.decision?.decisionId]);
+    const submit = async () => {
+        const packRequest = packId ?? snapshot.packId;
+        if (!packRequest || !initialCase)
+            return;
+        try {
+            await flow.submit(packRequest, initialCase);
+        }
+        catch {
+            // The snapshot owns the user-visible error and retry state.
+        }
+    };
+    const cancel = async () => {
+        try {
+            await flow.cancel();
+        }
+        catch {
+            // The snapshot owns the cancellation state.
+        }
+    };
+    const retry = async () => {
+        try {
+            await flow.retryLast();
+        }
+        catch {
+            // The snapshot owns the failure state.
+        }
+    };
+    const recordAction = async (event) => {
+        event.preventDefault();
+        if (!reviewerAction || !snapshot.decision || !reviewerId)
+            return;
+        setRecording(true);
+        setRecordError(null);
+        try {
+            await flow.recordReviewerAction(snapshot.decision.decisionId, {
+                reviewerId,
+                ...(reviewerRole ? { reviewerRole } : {}),
+                action: reviewerAction.action,
+                ...(reviewerAction.notes.trim()
+                    ? { notes: reviewerAction.notes.trim() }
+                    : {}),
+                occurredAt: new Date().toISOString(),
+            });
+            setRecordedAt(new Date().toISOString());
+        }
+        catch (caught) {
+            setRecordError(caught instanceof Error
+                ? caught.message
+                : "The reviewer action could not be recorded.");
+        }
+        finally {
+            setRecording(false);
+        }
+    };
+    const decision = snapshot.decision;
+    const busy = snapshot.loading;
+    const showSubmission = initialCase !== undefined &&
+        snapshot.phase !== "submitting" &&
+        snapshot.phase !== "polling";
+    return (_jsxs("section", { "aria-label": `${config.labels.title} coding review`, onKeyDown: markReviewActivity, onPointerDown: markReviewActivity, onScrollCapture: markReviewActivity, onTouchStart: markReviewActivity, style: {
+            background: config.theme.backgroundColor,
+            border: `1px solid ${config.theme.primaryColor}`,
+            borderRadius: config.theme.borderRadius,
+            color: config.theme.textColor,
+            fontFamily: config.theme.fontFamily,
+            maxWidth: 720,
+            padding: 20,
+        }, children: [_jsxs("header", { children: [_jsx("strong", { children: config.branding.displayName }), snapshot.packId ? (_jsxs("span", { style: { fontSize: 12, opacity: 0.72 }, children: [" ", "\u00B7 ", snapshot.packId] })) : null] }), showSubmission ? (_jsx("button", { disabled: busy, style: { background: config.theme.primaryColor, color: "#fff" }, type: "button", onClick: () => void submit(), children: labels.prepare })) : null, busy ? (_jsxs("p", { "aria-live": "polite", role: "status", children: ["Preparing coding review\u2026", snapshot.cancelable ? (_jsx("button", { onClick: () => void cancel(), style: {
+                            background: "transparent",
+                            border: `1px solid ${config.theme.textColor}33`,
+                            borderRadius: 6,
+                            color: "inherit",
+                            fontSize: 12,
+                            marginLeft: 8,
+                            padding: "4px 8px",
+                        }, type: "button", children: labels.cancel })) : null] })) : null, snapshot.error ? (_jsx("p", { role: "alert", style: { color: "#b91c1c", fontSize: 13 }, children: snapshot.error.message })) : null, snapshot.error && snapshot.canRetry ? (_jsx("button", { onClick: () => void retry(), style: {
+                    background: "transparent",
+                    border: `1px solid ${config.theme.textColor}33`,
+                    borderRadius: 6,
+                    color: "inherit",
+                    fontSize: 12,
+                    padding: "4px 8px",
+                }, type: "button", children: labels.retry })) : null, snapshot.phase === "cancelled" ? (_jsx("p", { role: "status", children: labels.cancelled })) : null, decision ? (_jsxs("div", { "aria-live": "polite", role: "region", "aria-label": "Coding decision result", children: [_jsx("p", { role: "alert", children: decisionRequiresHumanReview(decision)
+                            ? labels.humanReviewRequired
+                            : decisionPrimaryState(decision) }), renderDecision ? (renderDecision(decision, _jsx(DecisionDetail, { decision: decision, labels: labels, onEvidenceEngaged: reportEvidenceEngagement, renderGap: renderGap, renderLineDecision: renderLineDecision }))) : (_jsx(DecisionDetail, { decision: decision, labels: labels, onEvidenceEngaged: reportEvidenceEngagement, renderGap: renderGap, renderLineDecision: renderLineDecision })), !reviewerId ? (_jsx("p", { role: "note", children: "A reviewer ID is required to record an action." })) : null, _jsx("form", { onSubmit: (event) => void recordAction(event), children: _jsxs("fieldset", { disabled: recording || !reviewerId, style: { border: 0, margin: 0, padding: 0 }, children: [_jsx("legend", { children: "Record reviewer action" }), _jsxs("label", { children: ["Action", _jsxs("select", { "aria-label": "Reviewer action", value: reviewerAction?.action ?? "", onChange: (event) => setReviewerAction((current) => ({
+                                                action: event.target
+                                                    .value,
+                                                notes: current?.notes ?? "",
+                                            })), children: [_jsx("option", { value: "", disabled: true, children: "Select\u2026" }), _jsx("option", { value: "approved", children: "Approved" }), _jsx("option", { value: "rejected", children: "Rejected" }), _jsx("option", { value: "escalated", children: "Escalated" })] })] }), _jsxs("label", { children: ["Notes", _jsx("textarea", { "aria-label": "Reviewer notes", rows: 2, value: reviewerAction?.notes ?? "", onChange: (event) => setReviewerAction((current) => ({
+                                                action: current?.action ?? "approved",
+                                                notes: event.target.value,
+                                            })) })] }), _jsx("button", { disabled: !reviewerAction || recording || !reviewerId, type: "submit", children: recording ? "Recording…" : labels.recordAction })] }) }), recordError ? (_jsx("p", { role: "alert", style: { color: "#b91c1c", fontSize: 12 }, children: recordError })) : null, recordedAt ? (_jsxs("p", { role: "status", style: { fontSize: 12 }, children: [labels.actionRecorded, " ", recordedAt, "."] })) : null] })) : null] }));
+}
+function DecisionDetail({ decision, labels, onEvidenceEngaged, renderGap, renderLineDecision, }) {
+    const gaps = decisionGaps(decision);
+    const conflicts = decisionConflicts(decision);
+    const gapLabel = (type) => type === "missing_documentation"
+        ? labels.missingDocumentation
+        : type === "unsupported_scope"
+            ? labels.unsupportedScope
+            : type === "insufficient_evidence"
+                ? labels.insufficientEvidence
+                : type === "policy_conflict"
+                    ? labels.policyConflict
+                    : labels.terminologyUnavailable;
+    return (_jsxs("div", { children: [_jsx("p", { children: decision.rationale }), decision.lineDecisions.length > 0 ? (_jsxs("section", { "aria-label": "Line decisions", children: [_jsx("h3", { children: "Line decisions" }), decision.lineDecisions.map((line) => renderLineDecision ? (_jsx(React.Fragment, { children: renderLineDecision(line) }, line.lineId)) : (_jsxs("p", { children: [_jsx("strong", { children: defaultLineLabel(line) }), " \u2014 ", line.rationale] }, line.lineId)))] })) : null, gaps.length > 0 ? (_jsxs("section", { "aria-label": "Documentation and scope gaps", children: [_jsx("h3", { children: "Gaps" }), gaps.map((gap) => renderGap ? (_jsx(React.Fragment, { children: renderGap(gap) }, gap.gapId)) : (_jsxs("p", { children: [_jsx("strong", { children: gapLabel(gap.type) }), " (", gap.severity, ") \u2014", " ", gap.description] }, gap.gapId)))] })) : null, conflicts.length > 0 ? (_jsxs("section", { "aria-label": "Policy conflicts", children: [_jsx("h3", { children: "Conflicts" }), conflicts.map((conflict) => (_jsxs("p", { children: [_jsx("strong", { children: conflict.type }), " \u2014 ", conflict.summary] }, conflict.conflictId)))] })) : null, decision.evidenceItems?.length ? (_jsxs("section", { "aria-label": "Supporting evidence", children: [_jsx("h3", { children: "Supporting evidence" }), decision.evidenceItems.map((evidence) => (_jsxs("details", { onToggle: (event) => {
+                            if (event.currentTarget.open) {
+                                onEvidenceEngaged?.(evidence.evidenceId, "opened");
+                            }
+                        }, children: [_jsx("summary", { style: {
+                                    cursor: "pointer",
+                                    fontWeight: 700,
+                                    textDecoration: "underline",
+                                }, children: _jsxs("strong", { children: [evidence.source, evidence.sourceVersion
+                                            ? ` (version ${evidence.sourceVersion})`
+                                            : ""] }) }), _jsxs("p", { children: [evidence.excerpt, " ", _jsx("button", { "aria-label": `Copy evidence reference ${evidence.evidenceId}`, onClick: () => {
+                                            const clipboard = navigator.clipboard;
+                                            if (!clipboard)
+                                                return;
+                                            void clipboard
+                                                .writeText(evidence.evidenceId)
+                                                .then(() => onEvidenceEngaged?.(evidence.evidenceId, "copied"))
+                                                .catch(() => undefined);
+                                        }, style: {
+                                            background: "transparent",
+                                            border: 0,
+                                            color: "inherit",
+                                            cursor: "pointer",
+                                            fontSize: 12,
+                                            padding: 0,
+                                            textDecoration: "underline",
+                                        }, type: "button", children: "Copy reference" })] })] }, evidence.evidenceId)))] })) : null] }));
+}
+export function CodingReview({ config, flow: flowProp, initialCase, labels, onAuditEvent, onCodingDecision, onSafetyEvent, packId, pollIntervalMs, renderDecision, renderGap, renderLineDecision, reviewerId, reviewerRole, reviewerAuthProvider, runtimeTokenProvider, }) {
+    const ownedFlow = React.useMemo(() => flowProp ??
+        createCodingFlow(config, {
+            onAuditEvent: flowProp ? undefined : onAuditEvent,
+            onSafetyEvent: flowProp ? undefined : onSafetyEvent,
+            pollIntervalMs,
+            runtimeTokenProvider,
+            reviewerAuthProvider,
+        }), [
+        config,
+        flowProp,
+        onAuditEvent,
+        onSafetyEvent,
+        pollIntervalMs,
+        runtimeTokenProvider,
+        reviewerAuthProvider,
+    ]);
+    React.useEffect(() => {
+        if (flowProp)
+            return;
+        return () => ownedFlow.dispose();
+    }, [flowProp, ownedFlow]);
+    const snapshot = useFlowSnapshot(ownedFlow);
+    if (!snapshot)
+        return null;
+    return (_jsx(CareCompassCodingReviewContent, { config: config, flow: ownedFlow, initialCase: initialCase, labels: labels, onCodingDecision: onCodingDecision, packId: packId, renderDecision: renderDecision, renderGap: renderGap, renderLineDecision: renderLineDecision, reviewerId: reviewerId, reviewerRole: reviewerRole, snapshot: snapshot }));
+}
+/** React adapter for the headless coding flow. Renders nothing itself. */
+export function useCodingReview(config, options = {}) {
+    const flow = React.useMemo(() => createCodingFlow(config, {
+        compliance: options.compliance,
+        fetcher: options.fetcher,
+        now: options.now,
+        onAuditEvent: options.onAuditEvent,
+        onSafetyEvent: options.onSafetyEvent,
+        pollIntervalMs: options.pollIntervalMs,
+        runtimeTokenProvider: options.runtimeTokenProvider,
+        reviewerAuthProvider: options.reviewerAuthProvider,
+        timeoutMs: options.timeoutMs,
+    }), [
+        config,
+        options.compliance,
+        options.fetcher,
+        options.now,
+        options.onAuditEvent,
+        options.onSafetyEvent,
+        options.pollIntervalMs,
+        options.runtimeTokenProvider,
+        options.reviewerAuthProvider,
+        options.timeoutMs,
+    ]);
+    const [snapshot, setSnapshot] = React.useState(() => flow.getSnapshot());
+    React.useEffect(() => {
+        const unsubscribe = flow.subscribe(setSnapshot);
+        setSnapshot(flow.getSnapshot());
+        return () => {
+            unsubscribe();
+            flow.dispose();
+        };
+    }, [flow]);
+    return React.useMemo(() => ({
+        cancel: flow.cancel,
+        flow,
+        recordReviewerAction: flow.recordReviewerAction,
+        retryLast: flow.retryLast,
+        snapshot,
+        submit: flow.submit,
+    }), [flow, snapshot]);
+}
+export function mountCodingReview(element, config, options = {}) {
+    if (!element) {
+        throw new Error("CareCompass coding review mount element was not found.");
+    }
+    const root = createRoot(element);
+    root.render(_jsx(CodingReview, { config: config, initialCase: options.initialCase, onCodingDecision: options.onCodingDecision, packId: options.packId, reviewerAuthProvider: options.reviewerAuthProvider, runtimeTokenProvider: options.runtimeTokenProvider }));
+    return {
+        unmount: () => root.unmount(),
+    };
+}

package/dist/coding.d.ts

@@ -0,0 +1,188 @@
+import { type CodingCase, type CodingDecision, type CodingReviewerAction, type RcmReviewerEvent } from "@nexalink/coding-contracts";
+import { type CareCompassCodingErrorCode, type CareCompassCodingStatus, type CareCompassPackCatalogEntry, type CareCompassPackSchema, type CareCompassRuntimeTokenProvider, type CareCompassReviewerAuthProvider, type CareCompassReviewerActionResult, type CareCompassWorkflowId } from "./client.js";
+import { type CareCompassAuditEvent, type CareCompassAuditListener, type CareCompassComplianceRuntimeOptions, type CareCompassSafetyListener } from "./compliance.js";
+import type { CareCompassConfig } from "./schema.js";
+type Fetcher = typeof fetch;
+/**
+ * Client-observed failure codes for structured coding flows. Server-returned
+ * codes are preserved; `safety_blocked` and `invalid_decision` are produced
+ * locally as the SDK fails closed.
+ */
+export type CodingFlowErrorCode = CareCompassCodingErrorCode | "safety_blocked";
+export type CodingFlowError = {
+    code: CodingFlowErrorCode;
+    message: string;
+};
+export type CodingFlowPhase = "idle" | "submitting" | "polling" | "complete" | "error" | "cancelled" | "disposed";
+export type CodingFlowRetryMetadata = {
+    packId: CareCompassWorkflowId;
+    codingCase: CodingCase;
+    /** Reused only when the original submission outcome was ambiguous. */
+    requestId?: string;
+    attempt: number;
+};
+export type CodingFlowSnapshot = {
+    phase: CodingFlowPhase;
+    packId: CareCompassWorkflowId | null;
+    decision: CodingDecision | null;
+    error: CodingFlowError | null;
+    loading: boolean;
+    canRetry: boolean;
+    cancelable: boolean;
+    retry: CodingFlowRetryMetadata | null;
+    activeJobId: string | null;
+};
+export type CodingFlowEvent = {
+    type: "case_submitted";
+    packId: CareCompassWorkflowId;
+    jobId: string;
+    snapshot: CodingFlowSnapshot;
+} | {
+    type: "status";
+    jobId: string;
+    status: CareCompassCodingStatus;
+    snapshot: CodingFlowSnapshot;
+} | {
+    type: "decision_completed";
+    decision: CodingDecision;
+    snapshot: CodingFlowSnapshot;
+} | {
+    type: "error";
+    error: CodingFlowError;
+    snapshot: CodingFlowSnapshot;
+} | {
+    type: "cancelled";
+    snapshot: CodingFlowSnapshot;
+} | {
+    type: "reset";
+    snapshot: CodingFlowSnapshot;
+};
+export type CodingFlowSubmitOptions = {
+    /** Reuse this value only when retrying the same hosted submission. */
+    requestId?: string;
+    sessionId?: string;
+};
+/**
+ * Tenant-scoped reviewer engagement event (rcm-reviewer-event-v1). The SDK
+ * adds `source: "embed"` and an `occurredAt` timestamp when omitted. Events
+ * carry only an opaque case reference, categorical facts, and aggregate
+ * durations — never prompts, document contents, or direct identifiers.
+ */
+export type CareCompassReviewerEventInput = {
+    eventName: RcmReviewerEvent["eventName"];
+    caseRef: string;
+    workflowId: CareCompassWorkflowId;
+    eventId?: string;
+    occurredAt?: string;
+    reviewId?: string;
+    packId?: string;
+    packVersion?: string;
+    environment?: RcmReviewerEvent["environment"];
+    evidenceId?: string;
+    activeSeconds?: number;
+    idlePaused?: boolean;
+};
+export type CodingFlowOptions = {
+    compliance?: CareCompassComplianceRuntimeOptions;
+    fetcher?: Fetcher;
+    now?: () => number;
+    onAuditEvent?: CareCompassAuditListener;
+    onSafetyEvent?: CareCompassSafetyListener;
+    pollIntervalMs?: number;
+    runtimeTokenProvider?: CareCompassRuntimeTokenProvider;
+    reviewerAuthProvider?: CareCompassReviewerAuthProvider;
+    timeoutMs?: number;
+};
+export type CodingFlow = {
+    cancel: () => Promise<CodingFlowSnapshot>;
+    dispose: () => void;
+    exportAuditTrail: () => CareCompassAuditEvent[];
+    getSnapshot: () => CodingFlowSnapshot;
+    listAuthorizedPacks: () => Promise<CareCompassPackCatalogEntry[]>;
+    getPackSchema: (packId: CareCompassWorkflowId) => Promise<CareCompassPackSchema>;
+    recordReviewerAction: (decisionId: string, action: CodingReviewerAction) => Promise<CareCompassReviewerActionResult>;
+    /**
+     * Best-effort engagement telemetry. Returns false when the event fails
+     * validation or delivery; it never throws and never blocks a review.
+     */
+    reportReviewerEvent: (event: CareCompassReviewerEventInput) => Promise<boolean>;
+    reset: () => void;
+    retryLast: () => Promise<CodingFlowSnapshot>;
+    stream: (packId: CareCompassWorkflowId, codingCase: CodingCase, options?: CodingFlowSubmitOptions) => AsyncIterable<CodingFlowEvent>;
+    submit: (packId: CareCompassWorkflowId, codingCase: CodingCase, options?: CodingFlowSubmitOptions) => Promise<CodingFlowSnapshot>;
+    subscribe: (listener: (snapshot: CodingFlowSnapshot) => void) => () => void;
+    subscribeAudit: (listener: CareCompassAuditListener) => () => void;
+    subscribeSafety: (listener: CareCompassSafetyListener) => () => void;
+};
+export declare function createCodingFlow(config: CareCompassConfig, options?: CodingFlowOptions): CodingFlow;
+export type CodingDraftErrorCode = "missing_data" | "unsupported_scope" | "invalid_value";
+export type CodingDraftError = {
+    path: string;
+    code: CodingDraftErrorCode;
+    message: string;
+};
+export type CodingDraftSnapshot = {
+    values: Record<string, unknown>;
+    errors: CodingDraftError[];
+    complete: boolean;
+};
+export declare function createCodingDraft(initial?: Partial<CodingCase>): {
+    reset: (values?: Partial<CodingCase>) => void;
+    set: (path: string, value: unknown) => void;
+    snapshot: () => CodingDraftSnapshot;
+    validate: () => CodingDraftSnapshot;
+};
+export type CodingDecisionPrimaryState = "review_required" | "abstain" | "escalate";
+export declare const decisionPrimaryState: (decision: CodingDecision) => CodingDecisionPrimaryState;
+export type TypedCodingGap = {
+    gapId: string;
+    type: NonNullable<CodingDecision["gaps"]>[number]["type"];
+    description: string;
+    severity: NonNullable<CodingDecision["gaps"]>[number]["severity"];
+};
+export declare const decisionGaps: (decision: CodingDecision) => TypedCodingGap[];
+export declare const decisionBlockingGaps: (decision: CodingDecision) => TypedCodingGap[];
+export declare const decisionConflicts: (decision: CodingDecision) => {
+    conflictId: string;
+    type: "other" | "payer_vs_national" | "plan_vs_contract" | "terminology_period" | "rule_vs_rule" | "model_vs_rule";
+    summary: string;
+    references?: string[] | undefined;
+}[];
+export declare const decisionRequiresHumanReview: (decision: CodingDecision) => boolean;
+export declare const decisionPackVersions: (decision: CodingDecision) => {
+    packId: string;
+    packVersion: string;
+    modelId: string;
+    modelVersion: string;
+    terminology: {
+        system: "ICD-10-CM" | "OTHER" | "CPT" | "HCPCS" | "ICD-10-PCS" | "NDC" | "CDT" | "REVENUE_CODE" | "DRG" | "MODIFIERS";
+        editionVersion: string;
+        licenseApproved: boolean;
+    }[];
+    rules: {
+        ruleId: string;
+        ruleVersion: string;
+    }[];
+    decisionSchemaVersion: string;
+    caseSchemaVersion: string;
+};
+export type CodingDecisionLabels = {
+    humanReviewRequired: string;
+    abstain: string;
+    escalate: string;
+    reviewRequired: string;
+    missingDocumentation: string;
+    unsupportedScope: string;
+    insufficientEvidence: string;
+    policyConflict: string;
+    terminologyUnavailable: string;
+    retry: string;
+    cancel: string;
+    error: string;
+    prepare: string;
+    cancelled: string;
+    recordAction: string;
+    actionRecorded: string;
+};
+export declare const CARECOMPASS_CODING_DECISION_LABELS: CodingDecisionLabels;
+export {};