@nexalink/carecompass-sdk 0.6.0 → 0.7.0

package/dist/coding.js

@@ -0,0 +1,590 @@
+import { CODING_CASE_SCHEMA_VERSION, codingCaseSchema, codingCaseValidationError, codingDecisionSchema, codingDecisionValidationError, codingReviewerActionValidationError, rcmReviewerEventValidationError, } from "@nexalink/coding-contracts";
+import { careCompassCodingErrorCode, createCareCompassClient, } from "./client.js";
+import { phiSummary, resolveCareCompassCompliancePolicy, sanitizeCareCompassValue, } from "./compliance.js";
+import { CARECOMPASS_TELEMETRY_ERROR_CODES, CARECOMPASS_TELEMETRY_EVENTS, createCareCompassTelemetry, } from "./telemetry.js";
+const sleep = (durationMs, signal) => new Promise((resolve) => {
+    if (signal.aborted) {
+        resolve();
+        return;
+    }
+    const timer = setTimeout(done, durationMs);
+    signal.addEventListener("abort", done, { once: true });
+    function done() {
+        clearTimeout(timer);
+        signal.removeEventListener("abort", done);
+        resolve();
+    }
+});
+const cloneCodingValue = (value) => {
+    if (Array.isArray(value)) {
+        return value.map((item) => cloneCodingValue(item));
+    }
+    if (value !== null && typeof value === "object") {
+        const clone = {};
+        for (const [key, item] of Object.entries(value)) {
+            Object.defineProperty(clone, key, {
+                configurable: true,
+                enumerable: true,
+                value: cloneCodingValue(item),
+                writable: true,
+            });
+        }
+        return clone;
+    }
+    return value;
+};
+const errorFrom = (error, code = "unknown") => ({
+    code,
+    message: error instanceof Error ? error.message : String(error),
+});
+export function createCodingFlow(config, options = {}) {
+    const now = options.now ?? Date.now;
+    const pollIntervalMs = options.pollIntervalMs ?? 1500;
+    const timeoutMs = options.timeoutMs ?? 120_000;
+    const abortController = new AbortController();
+    const client = createCareCompassClient(config, {
+        fetcher: options.fetcher,
+        now,
+        runtimeTokenProvider: options.runtimeTokenProvider,
+        reviewerAuthProvider: options.reviewerAuthProvider,
+        signal: abortController.signal,
+    });
+    const compliancePolicy = resolveCareCompassCompliancePolicy(config.compliance);
+    const telemetry = createCareCompassTelemetry(config);
+    const auditEvents = [];
+    const auditListeners = new Set();
+    const safetyListeners = new Set();
+    if (options.onAuditEvent)
+        auditListeners.add(options.onAuditEvent);
+    if (options.onSafetyEvent)
+        safetyListeners.add(options.onSafetyEvent);
+    const listeners = new Set();
+    let sequence = 0;
+    let disposed = false;
+    let cancelRequested = false;
+    let phase = "idle";
+    let error = null;
+    let activeJobId = null;
+    let packId = null;
+    let decision = null;
+    let retry = null;
+    const nextId = (prefix) => `${prefix}-${now()}-${++sequence}`;
+    const emitAudit = (type, outcome, source, matches = []) => {
+        if (!compliancePolicy.auditEnabled)
+            return;
+        const auditEvent = {
+            id: nextId("audit"),
+            occurredAt: now(),
+            outcome,
+            phi: phiSummary(matches),
+            ...(source ? { source } : {}),
+            type,
+        };
+        auditEvents.push(auditEvent);
+        for (const listener of auditListeners)
+            listener(auditEvent);
+    };
+    const emitSafety = (decisionValue, source, matches = []) => {
+        const safetyEvent = {
+            decision: decisionValue,
+            occurredAt: now(),
+            phi: phiSummary(matches),
+            source,
+        };
+        for (const listener of safetyListeners)
+            listener(safetyEvent);
+        emitAudit("safety_decision", decisionValue === "policy_sensitive" ? "recorded" : decisionValue, source, matches);
+    };
+    const applyPhiPolicy = (value, source) => {
+        const sanitized = sanitizeCareCompassValue(value, source, compliancePolicy, options.compliance?.phi);
+        if (sanitized.matches.length === 0)
+            return sanitized;
+        const decisionValue = compliancePolicy.phiAction === "block"
+            ? "blocked"
+            : compliancePolicy.phiAction === "redact"
+                ? "redacted"
+                : "policy_sensitive";
+        emitSafety(decisionValue, source, sanitized.matches);
+        return sanitized;
+    };
+    const getSnapshot = () => ({
+        phase,
+        packId,
+        decision,
+        error: error ? { ...error } : null,
+        loading: phase === "submitting" || phase === "polling",
+        canRetry: !disposed && !cancelRequested && retry !== null && phase === "error",
+        cancelable: !disposed &&
+            !cancelRequested &&
+            (phase === "submitting" || phase === "polling"),
+        retry: retry
+            ? {
+                packId: retry.packId,
+                codingCase: cloneCodingValue(retry.codingCase),
+                requestId: retry.requestId,
+                attempt: retry.attempt,
+            }
+            : null,
+        activeJobId,
+    });
+    const notify = () => {
+        if (disposed)
+            return;
+        const snapshot = getSnapshot();
+        for (const listener of listeners)
+            listener(snapshot);
+    };
+    const event = (value) => ({ ...value, snapshot: getSnapshot() });
+    const fail = (flowError) => {
+        error = flowError;
+        phase = disposed ? "disposed" : "error";
+        activeJobId = null;
+        emitAudit("error", "failed");
+        notify();
+        return event({ type: "error", error: flowError });
+    };
+    const ensureAvailable = () => {
+        if (!disposed)
+            return;
+        throw new Error("CareCompass coding flow is disposed.");
+    };
+    const protectedCase = (codingCase) => {
+        const sanitized = applyPhiPolicy(codingCase, "context");
+        if (sanitized.matches.length > 0) {
+            emitAudit("message", "blocked", "context", sanitized.matches);
+        }
+        return {
+            matches: sanitized.matches,
+            value: sanitized.value,
+        };
+    };
+    const completeCancelled = (requestCase) => {
+        if (disposed)
+            return;
+        phase = "cancelled";
+        activeJobId = null;
+        retry = {
+            packId: packId,
+            codingCase: requestCase,
+            attempt: 0,
+        };
+        notify();
+    };
+    const bestEffortCancel = async (jobId) => {
+        try {
+            await client.cancelCase(jobId);
+        }
+        catch {
+            // The snapshot still reflects the cancellation request; hosts can
+            // resubmit through retryLast when the server did not finalize it.
+        }
+    };
+    async function* stream(packRequest, codingCaseInput, submitOptions = {}) {
+        ensureAvailable();
+        if (phase === "submitting" || phase === "polling") {
+            throw new Error("CareCompass coding request is already in progress.");
+        }
+        if (codingCaseValidationError(codingCaseInput) !== null) {
+            emitSafety("escalated", "widget_action");
+            const flowError = {
+                code: "missing_data",
+                message: "The coding case did not satisfy the canonical CodingCase contract. Route this work item to a qualified coder.",
+            };
+            yield fail(flowError);
+            throw new Error(flowError.message);
+        }
+        const protectedRequest = protectedCase(codingCaseInput);
+        if (compliancePolicy.phiAction === "block" &&
+            protectedRequest.matches.length > 0) {
+            const flowError = {
+                code: "safety_blocked",
+                message: "CareCompass blocked this coding case because detectable PHI is not allowed in strict compliance mode.",
+            };
+            yield fail(flowError);
+            throw new Error(flowError.message);
+        }
+        const requestCase = protectedRequest.value;
+        const requestId = submitOptions.requestId ??
+            (typeof globalThis.crypto?.randomUUID === "function"
+                ? globalThis.crypto.randomUUID()
+                : nextId("request"));
+        packId = packRequest;
+        phase = "submitting";
+        error = null;
+        decision = null;
+        activeJobId = null;
+        cancelRequested = false;
+        retry = null;
+        notify();
+        emitAudit("message", protectedRequest.matches.length > 0 ? "redacted" : "submitted", "context", protectedRequest.matches);
+        const startedAt = now();
+        let failureAlreadyCaptured = false;
+        let jobId;
+        try {
+            const submitted = await client.submitCodingCase({
+                packId: packRequest,
+                codingCase: requestCase,
+                caseSchemaVersion: CODING_CASE_SCHEMA_VERSION,
+                requestId,
+                sessionId: submitOptions.sessionId,
+            });
+            if (disposed)
+                return;
+            jobId = submitted.jobId;
+            activeJobId = jobId;
+            if (cancelRequested) {
+                await bestEffortCancel(jobId);
+                completeCancelled(requestCase);
+                return;
+            }
+            phase = "polling";
+            notify();
+            yield event({ type: "case_submitted", packId: packRequest, jobId });
+            while (now() - startedAt < timeoutMs) {
+                if (disposed || cancelRequested)
+                    break;
+                const status = await client.codingStatus(jobId);
+                if (disposed)
+                    return;
+                yield event({ type: "status", jobId, status: status.status });
+                if (status.status === "cancelled") {
+                    completeCancelled(requestCase);
+                    yield event({ type: "cancelled" });
+                    return;
+                }
+                if (status.status === "failed") {
+                    const flowError = {
+                        code: status.error?.code ?? "escalated",
+                        message: status.error?.message ??
+                            "The coding request could not be completed safely. Route this work item to a qualified coder.",
+                    };
+                    retry = {
+                        packId: packRequest,
+                        codingCase: requestCase,
+                        attempt: 0,
+                    };
+                    yield fail(flowError);
+                    failureAlreadyCaptured = true;
+                    throw new Error(flowError.message);
+                }
+                if (status.status === "complete") {
+                    const rawDecision = status.decision;
+                    if (!rawDecision ||
+                        codingDecisionValidationError(rawDecision) !== null) {
+                        telemetry.capture(CARECOMPASS_TELEMETRY_EVENTS.CODING_DECISION_INVALID, {
+                            errorCode: CARECOMPASS_TELEMETRY_ERROR_CODES.INFERENCE_FAILED,
+                            failureCategory: "inference",
+                        });
+                        emitSafety("escalated", "tool_call");
+                        const flowError = {
+                            code: "invalid_decision",
+                            message: "The hosted runtime returned a decision that violated the canonical CodingDecision contract. Route this work item to a qualified coder.",
+                        };
+                        retry = {
+                            packId: packRequest,
+                            codingCase: requestCase,
+                            attempt: 0,
+                        };
+                        yield fail(flowError);
+                        failureAlreadyCaptured = true;
+                        throw new Error(flowError.message);
+                    }
+                    const protectedDecisionValue = applyPhiPolicy(rawDecision, "response");
+                    if (compliancePolicy.phiAction === "block" &&
+                        protectedDecisionValue.matches.length > 0) {
+                        const flowError = {
+                            code: "safety_blocked",
+                            message: "CareCompass blocked a decision because detectable PHI is not allowed in strict compliance mode.",
+                        };
+                        retry = {
+                            packId: packRequest,
+                            codingCase: requestCase,
+                            attempt: 0,
+                        };
+                        yield fail(flowError);
+                        failureAlreadyCaptured = true;
+                        throw new Error(flowError.message);
+                    }
+                    const decisionValue = codingDecisionSchema.parse(protectedDecisionValue.value);
+                    decision = decisionValue;
+                    phase = "complete";
+                    error = null;
+                    activeJobId = null;
+                    retry = null;
+                    notify();
+                    emitAudit("message", protectedDecisionValue.matches.length > 0
+                        ? "redacted"
+                        : "completed", "response", protectedDecisionValue.matches);
+                    telemetry.capture(CARECOMPASS_TELEMETRY_EVENTS.CODING_DECISION_RECEIVED, { durationMs: now() - startedAt });
+                    yield event({
+                        type: "decision_completed",
+                        decision: decisionValue,
+                    });
+                    return;
+                }
+                if (pollIntervalMs > 0) {
+                    await sleep(pollIntervalMs, abortController.signal);
+                }
+            }
+            if (disposed)
+                return;
+            if (cancelRequested) {
+                await bestEffortCancel(jobId);
+                completeCancelled(requestCase);
+                yield event({ type: "cancelled" });
+                return;
+            }
+            client.recordInferenceTimeout(jobId, now() - startedAt);
+            const timedOut = errorFrom(new Error("CareCompass coding request timed out."), "request_timeout");
+            retry = {
+                packId: packRequest,
+                codingCase: requestCase,
+                requestId,
+                attempt: 0,
+            };
+            yield fail(timedOut);
+            failureAlreadyCaptured = true;
+            throw new Error(timedOut.message);
+        }
+        catch (caught) {
+            if (disposed)
+                return;
+            if (failureAlreadyCaptured)
+                throw caught;
+            if (cancelRequested) {
+                phase = "cancelled";
+                activeJobId = null;
+                notify();
+                return;
+            }
+            const requestError = errorFrom(caught, careCompassCodingErrorCode(caught) ?? "network_error");
+            const submissionWasAccepted = activeJobId !== null;
+            const reuseRequestId = submissionWasAccepted || requestError.code === "network_error";
+            retry = {
+                packId: packRequest,
+                codingCase: requestCase,
+                ...(reuseRequestId ? { requestId } : {}),
+                attempt: 0,
+            };
+            yield fail(requestError);
+            throw caught instanceof Error ? caught : new Error(requestError.message);
+        }
+    }
+    const drain = async (iterator) => {
+        for await (const flowEvent of iterator) {
+            void flowEvent;
+            // Consumers that only need the final state can use submit.
+        }
+        return getSnapshot();
+    };
+    return {
+        cancel: async () => {
+            ensureAvailable();
+            cancelRequested = true;
+            const jobId = activeJobId;
+            if (jobId) {
+                try {
+                    await client.cancelCase(jobId);
+                }
+                catch {
+                    // The snapshot still reflects the cancellation request; hosts can
+                    // resubmit through retryLast when the server did not finalize it.
+                }
+            }
+            return getSnapshot();
+        },
+        dispose: () => {
+            if (disposed)
+                return;
+            disposed = true;
+            phase = "disposed";
+            activeJobId = null;
+            cancelRequested = true;
+            abortController.abort();
+            listeners.clear();
+            auditListeners.clear();
+            safetyListeners.clear();
+        },
+        exportAuditTrail: () => auditEvents.map((auditEvent) => ({
+            ...auditEvent,
+            phi: {
+                categories: [...auditEvent.phi.categories],
+                count: auditEvent.phi.count,
+            },
+        })),
+        getSnapshot,
+        listAuthorizedPacks: () => client.listAuthorizedPacks(),
+        getPackSchema: (packRequest) => client.getPackSchema(packRequest),
+        recordReviewerAction: async (decisionId, action) => {
+            if (codingReviewerActionValidationError(action) !== null) {
+                throw new Error("The reviewer action did not satisfy the canonical CodingReviewerAction contract.");
+            }
+            return await client.recordReviewerAction(decisionId, {
+                ...action,
+            });
+        },
+        reportReviewerEvent: async (event) => {
+            const payload = {
+                ...event,
+                source: "embed",
+                occurredAt: event.occurredAt ?? new Date(now()).toISOString(),
+            };
+            if (rcmReviewerEventValidationError(payload) !== null)
+                return false;
+            try {
+                const result = await client.reportReviewerEvent(payload);
+                return result.accepted === true;
+            }
+            catch {
+                return false;
+            }
+        },
+        reset: () => {
+            ensureAvailable();
+            phase = "idle";
+            error = null;
+            decision = null;
+            packId = null;
+            activeJobId = null;
+            cancelRequested = false;
+            retry = null;
+            notify();
+        },
+        retryLast: async () => {
+            ensureAvailable();
+            if (!retry)
+                return getSnapshot();
+            const retryRequest = retry;
+            retry = null;
+            return await drain(stream(retryRequest.packId, retryRequest.codingCase, {
+                requestId: retryRequest.requestId,
+            }));
+        },
+        stream,
+        submit: (packRequest, codingCase, submitOptions) => drain(stream(packRequest, codingCase, submitOptions)),
+        subscribe: (listener) => {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        subscribeAudit: (listener) => {
+            auditListeners.add(listener);
+            return () => auditListeners.delete(listener);
+        },
+        subscribeSafety: (listener) => {
+            safetyListeners.add(listener);
+            return () => safetyListeners.delete(listener);
+        },
+    };
+}
+const UNSUPPORTED_SCOPE_PATHS = new Set([
+    "codingIntent",
+    "servicePeriod.startDate",
+    "servicePeriod.endDate",
+    "context.setting",
+    "context.otherSettingDescription",
+    "context.placeOfService",
+    "context.jurisdiction",
+    "context.specialty",
+    "context.provider.npi",
+    "context.provider.role",
+    "context.provider.taxonomy",
+    "context.facility.facilityType",
+]);
+const valueAtPath = (values, path) => {
+    let cursor = values;
+    for (const part of path.split(".")) {
+        if (cursor === null || typeof cursor !== "object")
+            return undefined;
+        cursor = cursor[part];
+    }
+    return cursor;
+};
+const draftErrorFromIssues = (values, issues) => issues.map((issue) => {
+    const path = issue.path.join(".");
+    const raw = valueAtPath(values, path);
+    const absent = raw === undefined || raw === null || raw === "";
+    const code = absent
+        ? "missing_data"
+        : issue.code === "invalid_value" && UNSUPPORTED_SCOPE_PATHS.has(path)
+            ? "unsupported_scope"
+            : "invalid_value";
+    return { path, code, message: issue.message };
+});
+export function createCodingDraft(initial = {}) {
+    let values = cloneCodingValue(initial);
+    const snapshot = () => {
+        const result = codingCaseSchema.safeParse(values);
+        if (result.success) {
+            return { values: cloneCodingValue(values), errors: [], complete: true };
+        }
+        return {
+            values: cloneCodingValue(values),
+            errors: draftErrorFromIssues(values, result.error.issues),
+            complete: false,
+        };
+    };
+    return {
+        reset: (nextValues = {}) => {
+            values = cloneCodingValue(nextValues);
+        },
+        set: (path, value) => {
+            const parts = path.split(".");
+            if (parts.some((part) => !part ||
+                part === "__proto__" ||
+                part === "prototype" ||
+                part === "constructor")) {
+                throw new Error("Coding draft path contains an unsafe segment.");
+            }
+            let cursor = values;
+            for (const part of parts.slice(0, -1)) {
+                const next = cursor[part];
+                if (!next || typeof next !== "object" || Array.isArray(next)) {
+                    cursor[part] = {};
+                }
+                cursor = cursor[part];
+            }
+            cursor[parts[parts.length - 1]] = cloneCodingValue(value);
+        },
+        snapshot,
+        validate: snapshot,
+    };
+}
+export const decisionPrimaryState = (decision) => decision.disposition;
+export const decisionGaps = (decision) => [
+    ...(decision.gaps ?? []),
+];
+export const decisionBlockingGaps = (decision) => (decision.gaps ?? []).filter((gap) => gap.severity === "blocking");
+export const decisionConflicts = (decision) => [
+    ...(decision.conflicts ?? []),
+];
+export const decisionRequiresHumanReview = (decision) => decision.humanReviewRequired === true;
+export const decisionPackVersions = (decision) => ({
+    packId: decision.provenance.pack.packId,
+    packVersion: decision.provenance.pack.packVersion,
+    modelId: decision.provenance.model.modelId,
+    modelVersion: decision.provenance.model.modelVersion,
+    terminology: decision.provenance.terminology,
+    rules: decision.provenance.rules,
+    decisionSchemaVersion: decision.provenance.decisionSchemaVersion,
+    caseSchemaVersion: decision.provenance.caseSchemaVersion,
+});
+export const CARECOMPASS_CODING_DECISION_LABELS = {
+    humanReviewRequired: "Human review required — no billing or coding decision has been made.",
+    abstain: "Abstained — insufficient documentation to support any coding recommendation.",
+    escalate: "Escalated — this case requires qualified coder review before any coding action.",
+    reviewRequired: "Review required",
+    missingDocumentation: "Missing documentation",
+    unsupportedScope: "Unsupported scope",
+    insufficientEvidence: "Insufficient evidence",
+    policyConflict: "Policy conflict",
+    terminologyUnavailable: "Terminology unavailable",
+    retry: "Retry",
+    cancel: "Cancel",
+    error: "CareCompass is unavailable right now.",
+    prepare: "Prepare for coding review",
+    cancelled: "Review cancelled.",
+    recordAction: "Record action",
+    actionRecorded: "Reviewer action recorded at",
+};

package/dist/index.d.ts

@@ -1,11 +1,22 @@
+export { ADAPTER_IDS, careCompassAdapterIds, csvRowPayload, fhirR4ClaimPayload, jsonClaimPayload, x12837Payload, } from "./adapters.js";
+export type { CareCompassAdapterEnvelope, CareCompassAdapterId, } from "./adapters.js";
 export { createCareCompassClient } from "./client.js";
-export type { CareCompassAskRequest, CareCompassAskResponse, CareCompassClientOptions, CareCompassRetrievalMetadata, CareCompassRetrievalReference, CareCompassRuntimeTokenProvider, CareCompassRuntimeTokenRequest, CareCompassStatusResponse, CareCompassWorkflowId, } from "./client.js";
+export type { CareCompassAskRequest, CareCompassAskResponse, CareCompassClientOptions, CareCompassCodingError, CareCompassCodingErrorCode, CareCompassCodingStatus, CareCompassCodingStatusResponse, CareCompassPackCatalogEntry, CareCompassPackSchema, CareCompassRetrievalMetadata, CareCompassRetrievalReference, CareCompassReviewerActionResult, CareCompassReviewerAuthProvider, CareCompassRuntimeTokenProvider, CareCompassRuntimeTokenRequest, CareCompassStatusResponse, CareCompassSubmitCodingCaseRequest, CareCompassSubmitCodingCaseResponse, CareCompassWorkflowId, } from "./client.js";
+export { CARECOMPASS_CODING_DECISION_LABELS, createCodingDraft, createCodingFlow, decisionBlockingGaps, decisionConflicts, decisionGaps, decisionPackVersions, decisionPrimaryState, decisionRequiresHumanReview, } from "./coding.js";
+export type { CodingDecisionLabels, CodingDraftError, CodingDraftErrorCode, CodingDraftSnapshot, CodingDecisionPrimaryState, CodingFlow, CodingFlowError, CodingFlowErrorCode, CodingFlowEvent, CodingFlowOptions, CodingFlowPhase, CodingFlowRetryMetadata, CodingFlowSnapshot, CodingFlowSubmitOptions, TypedCodingGap, } from "./coding.js";
+export { CareCompassCodingReviewContent, CodingReview, mountCodingReview, useCodingReview, } from "./coding-ui.js";
+export type { CodingDecisionLine, CodingReviewProps, CodingReviewRenderProps, UseCodingReviewResult, } from "./coding-ui.js";
+export { CARECOMPASS_CODING_REVIEW_ELEMENT_TAG, defineCodingReviewElement, } from "./coding-element.js";
+export type { CareCompassCodingReviewElement } from "./coding-element.js";
 export { CareCompassChat, CareCompassEmbed, useCareCompass, } from "./component.js";
 export type { CareCompassChatProps, CareCompassReactController, UseCareCompassOptions, } from "./component.js";
 export { createCareCompassCore } from "./core.js";
 export type { CareCompassContext, CareCompassCore, CareCompassCoreError, CareCompassCoreErrorCode, CareCompassCoreEvent, CareCompassCoreOptions, CareCompassCoreSnapshot, CareCompassLifecyclePhase, CareCompassMessage, CareCompassRetryMetadata, CareCompassSendMessageOptions, } from "./core.js";
 export { CARECOMPASS_RCM_SYNTHETIC_DEMO, createRcmCodingWorkflow, RcmCodingAssistant, } from "./rcm.js";
 export type { RcmCodeRecommendation, RcmCodeSystem, RcmCodingAssistanceInput, RcmCodingAssistanceResult, RcmCodingAssistantProps, RcmCodingWorkflow, RcmCodingWorkflowOptions, RcmConfidence, RcmCustomerRules, RcmPolicyReference, RcmPolicyRetriever, RcmReviewDisposition, } from "./rcm.js";
+export { PIN_TIME_WORKFLOW_ID, RCM_WORKFLOW_ID, } from "@nexalink/coding-contracts";
+export type { CodingCase, CodingDecision, CodingReviewerAction, } from "@nexalink/coding-contracts";
+export { codingCaseValidationError, codingDecisionValidationError, validCodingCase, validCodingDecision, } from "@nexalink/coding-contracts";
 export { mountCareCompass } from "./mount.js";
 export { CARECOMPASS_ELEMENT_TAG, defineCareCompassElement, } from "./web-component.js";
 export type { CareCompassWebComponentElement } from "./web-component.js";

package/dist/index.js

@@ -1,7 +1,13 @@
+export { ADAPTER_IDS, careCompassAdapterIds, csvRowPayload, fhirR4ClaimPayload, jsonClaimPayload, x12837Payload, } from "./adapters.js";
 export { createCareCompassClient } from "./client.js";
+export { CARECOMPASS_CODING_DECISION_LABELS, createCodingDraft, createCodingFlow, decisionBlockingGaps, decisionConflicts, decisionGaps, decisionPackVersions, decisionPrimaryState, decisionRequiresHumanReview, } from "./coding.js";
+export { CareCompassCodingReviewContent, CodingReview, mountCodingReview, useCodingReview, } from "./coding-ui.js";
+export { CARECOMPASS_CODING_REVIEW_ELEMENT_TAG, defineCodingReviewElement, } from "./coding-element.js";
 export { CareCompassChat, CareCompassEmbed, useCareCompass, } from "./component.js";
 export { createCareCompassCore } from "./core.js";
 export { CARECOMPASS_RCM_SYNTHETIC_DEMO, createRcmCodingWorkflow, RcmCodingAssistant, } from "./rcm.js";
+export { PIN_TIME_WORKFLOW_ID, RCM_WORKFLOW_ID, } from "@nexalink/coding-contracts";
+export { codingCaseValidationError, codingDecisionValidationError, validCodingCase, validCodingDecision, } from "@nexalink/coding-contracts";
 export { mountCareCompass } from "./mount.js";
 export { CARECOMPASS_ELEMENT_TAG, defineCareCompassElement, } from "./web-component.js";
 export { generateCareCompassIframeSnippet, generateCareCompassSnippet, } from "./snippet.js";

package/dist/rcm.d.ts

@@ -1,24 +1,13 @@
 import React from "react";
+import { type RcmCodingInput, type RcmCodingOutput } from "@nexalink/coding-contracts";
 import { type CareCompassCore, type CareCompassCoreOptions } from "./core.js";
 import type { CareCompassAuditListener, CareCompassSafetyListener } from "./compliance.js";
 import type { CareCompassConfig } from "./schema.js";
 /** A narrow, structured input for coding review. Do not include direct patient identifiers. */
-export type RcmCodingAssistanceInput = {
-    encounterId: string;
-    diagnosisNarrative: string;
-    procedureNarrative?: string;
-    serviceDate?: string;
-    placeOfService?: string;
-    claimContext?: {
-        /** Required in development and staging; when supplied, it must match the authenticated SDK environment. */
-        stage?: CareCompassConfig["environment"];
-        payerName?: string;
-        submittedCodes?: string[];
-    };
-};
-export type RcmCodeSystem = "ICD-10-CM" | "CPT" | "HCPCS";
-export type RcmConfidence = "low" | "medium" | "high";
-export type RcmReviewDisposition = "review_required" | "abstain" | "escalate";
+export type RcmCodingAssistanceInput = Omit<RcmCodingInput, "supportingReferences">;
+export type RcmCodeSystem = RcmCodingOutput["recommendations"][number]["codeSystem"];
+export type RcmConfidence = RcmCodingOutput["recommendations"][number]["confidence"];
+export type RcmReviewDisposition = RcmCodingOutput["disposition"];
 export type RcmPolicyReference = {
     corpusId: string;
     id: string;