autoicd-js 0.6.0 → 0.7.0

package/README.md

@@ -4,7 +4,7 @@
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
 [![TypeScript](https://img.shields.io/badge/TypeScript-5.5+-blue.svg)](https://www.typescriptlang.org/)
 
-Official TypeScript SDK for the [AutoICD API](https://autoicdapi.com) — clinical text to ICD-10-CM and ICD-11 diagnosis codes, powered by AI and medical NLP.
+Official TypeScript SDK for the [AutoICD API](https://autoicdapi.com) — AI medical coding that converts clinical text to ICD-10-CM, ICD-11, and ICF codes using medical NLP. Automate ICD-10 coding, ICF functioning classification, and disability assessment in your application.
 
 Zero dependencies. Works in **Node.js 18+**, **Deno**, **Bun**, and **edge runtimes**.
 
@@ -16,9 +16,11 @@ Zero dependencies. Works in **Node.js 18+**, **Deno**, **Bun**, and **edge runti
 
 | | |
 |---|---|
-| **AI-Powered ICD-10 & ICD-11 Coding** | Clinical NLP extracts diagnoses from free-text notes and maps them to ICD-10-CM or ICD-11 codes — no manual lookup required |
+| **AI-Powered ICD-10, ICD-11 & ICF Coding** | Clinical NLP extracts diagnoses from free-text notes and maps them to ICD-10-CM, ICD-11, or ICF codes — no manual lookup required |
+| **Chart Audit with HCC Gap Capture** | Find missed HCCs, unsupported codes, and specificity upgrades with RAF-weighted revenue estimates (CMS v22 + v28 PY2026). Every finding carries evidence spans |
 | **74,000+ ICD-10-CM Codes** | Full 2025 code set enriched with SNOMED CT synonyms for comprehensive matching |
 | **ICD-11 Support** | Search and look up ICD-11 codes, with full ICD-10 ↔ ICD-11 crosswalk mappings |
+| **ICF Functioning Codes** | Code clinical text to WHO ICF categories, search 1,400+ codes, and access Core Sets for 12+ conditions |
 | **Negation & Context Detection** | Knows the difference between "patient has diabetes" and "patient denies diabetes" — flags negated, historical, uncertain, and family-history mentions |
 | **PHI De-identification** | HIPAA-compliant anonymization of names, dates, SSNs, phone numbers, emails, addresses, MRNs, and ages |
 | **Confidence Scoring** | Every code match includes a similarity score and confidence level so you can set your own acceptance thresholds |
@@ -69,6 +71,51 @@ for (const entity of result.entities) {
 
 ## Features
 
+### Chart Audit (HCC gap capture, RADV defense, specificity, denial risk)
+
+Audit a chart to surface coding gaps, unsupported codes, specificity upgrades, and denial-risk flags in a single call. Every finding carries extractive evidence spans pointing back to the source text, and HCC gaps include RAF-weighted revenue estimates using the CMS PY2026 V22 and V28 community models.
+
+```ts
+const audit = await autoicd.audit({
+  text:
+    "68yo M, type 2 diabetes stable on metformin, chronic systolic heart failure " +
+    "on furosemide, edema controlled. A1c 7.4 today.",
+  codes: [{ code: "E11.9", kind: "icd10" }],
+  capabilities: ["hcc", "radv", "specificity", "denial", "problem_list"],
+  context: {
+    patient: { coverage: "medicare_advantage" },
+    hcc_model: "both",
+  },
+});
+
+console.log(`Missed revenue: $${audit.totals.estimated_revenue_recovery.toFixed(0)}`);
+console.log(`RADV exposure:  $${audit.totals.radv_exposure.toFixed(0)}`);
+
+for (const m of audit.missed) {
+  console.log(
+    `MISSED ${m.code} (${m.hcc_category ?? "non-HCC"} ${m.hcc_model ?? ""}) ` +
+    `→ $${m.estimated_revenue?.toFixed(0) ?? 0}: ${m.description}`
+  );
+  for (const span of m.evidence) {
+    console.log(`    evidence: "${span.quote}" [${span.start}-${span.end}]`);
+  }
+}
+```
+
+| Capability | What it surfaces |
+|---|---|
+| `hcc` | Missed HCC codes with `hcc_category`, `raf_weight`, `estimated_revenue` per v22/v28 model |
+| `radv` | Submitted codes with no supporting documentation, with `what_would_support_it` guidance and exposure dollars |
+| `specificity` | Upgrade opportunities from unspecified to more specific child codes |
+| `denial` | Documentation-quality risk flags (missing laterality, missing duration, age/sex mismatches) |
+| `problem_list` | Deduplicated active-conditions list with status (active/historical) and evidence |
+
+Default behavior runs all five capabilities. Pass `capabilities: ["hcc"]` to run a targeted audit.
+
+> **`hcc_model`:** use `"v22"`, `"v28"`, or `"both"` (default). CMS PY2026 MA payment uses V22 and V28 as the two main community models. V24 is the ESRD-specific model and is not accepted here.
+
+Read more about the Audit endpoint at [autoicdapi.com/audit](https://autoicdapi.com/audit).
+
 ### Automated ICD-10 Medical Coding
 
 Extract diagnosis entities from clinical notes and map them to ICD-10-CM codes. Each entity includes ranked candidates with confidence scores, negation status, and context flags.
@@ -167,6 +214,30 @@ for (const mapping of detail.icd11_mappings ?? []) {
 }
 ```
 
+### ICF Functioning Codes
+
+Code clinical text to WHO ICF categories, look up codes, search, and access ICF Core Sets for 12+ conditions.
+
+```typescript
+// Code clinical text to ICF categories
+const icf = await client.icf.code("Patient with stroke and hemiplegia");
+console.log(icf.results[0].codes);
+// [{ code: "b730", description: "Muscle power functions", component: "b", ... }]
+
+// Look up an ICF code
+const code = await client.icf.lookup("d450");
+console.log(code.title); // "Walking"
+console.log(code.definition); // "Moving along a surface on foot..."
+
+// Search ICF codes
+const results = await client.icf.search("mobility");
+
+// Get ICF Core Set for a diagnosis
+const coreSet = await client.icf.coreSet("E11.9");
+console.log(coreSet.conditionName); // "Diabetes Mellitus"
+console.log(coreSet.brief); // [{ code: "b530", title: "Weight maintenance functions", ... }]
+```
+
 ### PHI De-identification
 
 Strip protected health information from clinical notes before storage or analysis. HIPAA-compliant de-identification for names, dates, SSNs, phone numbers, emails, addresses, MRNs, and ages.
@@ -281,6 +352,10 @@ Full REST API documentation at [autoicdapi.com/docs](https://autoicdapi.com/docs
 | `autoicd.icd10.get(code)` | Get details for an ICD-10-CM code (incl. ICD-11 crosswalk) |
 | `autoicd.icd11.search(query, options?)` | Search ICD-11 codes by description |
 | `autoicd.icd11.get(code)` | Get details for an ICD-11 code (incl. ICD-10 crosswalk) |
+| `autoicd.icf.code(text, options?)` | Code clinical text to ICF functioning categories |
+| `autoicd.icf.lookup(code)` | Get details for an ICF code |
+| `autoicd.icf.search(query, options?)` | Search ICF codes by keyword |
+| `autoicd.icf.coreSet(icd10Code)` | Get ICF Core Set for an ICD-10 diagnosis |
 
 ---
 
@@ -303,6 +378,10 @@ import type {
   ICD11CodeDetailFull,
   ICD11CodeSearchResponse,
   CrosswalkMapping,
+  ICFCodingResponse,
+  ICFCodeDetail,
+  ICFCodeSearchResponse,
+  ICFCoreSetResponse,
 } from "autoicd";
 ```
 

package/dist/index.d.mts

@@ -15,6 +15,14 @@ interface CodeOptions {
     includeNegated?: boolean;
     /** Output coding system: `"icd10"` (default) or `"icd11"`. */
     outputSystem?: "icd10" | "icd11";
+    /** Include ICF functioning code results in the response. Defaults to false. */
+    includeIcf?: boolean;
+    /** Include ICD-11 crosswalk codes per ICD-10 match. Defaults to false. */
+    includeIcd11?: boolean;
+    /** Include SNOMED CT concept IDs per ICD-10 match. Defaults to false. */
+    includeSnomed?: boolean;
+    /** Include UMLS CUIs per ICD-10 match. Defaults to false. */
+    includeUmls?: boolean;
 }
 interface CodeMatch {
     /** ICD-10-CM code (e.g., `"E11.21"`). */
@@ -27,6 +35,14 @@ interface CodeMatch {
     confidence: "high" | "moderate";
     /** The index term that produced this match. */
     matched_term: string;
+    /** Mapped ICD-11 codes. */
+    icd11_codes: string[];
+    /** SNOMED CT concept IDs. */
+    snomed_ids: string[];
+    /** UMLS CUIs. */
+    umls_cuis: string[];
+    /** Related ICF category codes. */
+    icf_categories: string[];
 }
 interface CodingEntity {
     /** Entity text as extracted from the input. */
@@ -61,6 +77,9 @@ interface CodingResponse {
     entity_count: number;
     /** Coding results per entity, sorted by position in text. */
     entities: CodingEntity[];
+    /** LOINC lab code results. Only present when `includeLoinc` is true. */
+    /** ICF functioning code results. Only present when `includeIcf` is true. */
+    icf_entities?: ICFCodingEntity[];
 }
 interface SearchOptions {
     /** Maximum number of results (1-100). Defaults to 20. */
@@ -99,8 +118,10 @@ interface CodeDetailFull extends CodeDetail {
     chapter: ChapterInfo | null;
     /** Code block range (e.g., `"E08-E13"`). */
     block: string | null;
-    /** ICD-11 crosswalk mappings (present when ICD-11 data is available). */
-    icd11_mappings?: CrosswalkMapping[];
+    /** ICD-11 crosswalk mappings for this ICD-10 code. */
+    icd11_mappings: CrosswalkMapping[];
+    /** Related ICF categories from WHO Core Sets. */
+    icf_categories: ICFCrossReference[];
 }
 interface CodeSearchResponse {
     /** The search query that was used. */
@@ -166,6 +187,15 @@ interface CrosswalkMapping {
     /** Target coding system: `"icd10"` or `"icd11"`. */
     system: string;
 }
+/** A related ICF category from WHO Core Sets. */
+interface ICFCrossReference {
+    /** ICF code (e.g., "b5401"). */
+    code: string;
+    /** ICF code title. */
+    title: string;
+    /** Component letter: "b", "s", "d", or "e". */
+    component: string;
+}
 interface ICD11CodeDetailFull extends ICD11CodeDetail {
     /** Synonyms grouped by source. */
     synonyms: Record<string, string[]>;
@@ -181,6 +211,8 @@ interface ICD11CodeDetailFull extends ICD11CodeDetail {
     block: string | null;
     /** ICD-10 crosswalk mappings for this ICD-11 code. */
     icd10_mappings: CrosswalkMapping[];
+    /** Related ICF categories (via ICD-10 bridge). */
+    icf_categories: ICFCrossReference[];
 }
 interface ICD11CodeSearchResult {
     /** ICD-11 code. */
@@ -200,6 +232,344 @@ interface ICD11CodeSearchResponse {
     /** Matching ICD-11 codes. */
     codes: ICD11CodeSearchResult[];
 }
+type ICFComponent = "b" | "s" | "d" | "e";
+interface ICFCodeSummary {
+    /** ICF code (e.g., `"b280"`). */
+    code: string;
+    /** Code title. */
+    title: string;
+    /** ICF component: `"b"` (body functions), `"s"` (body structures), `"d"` (activities/participation), `"e"` (environmental factors). */
+    component: ICFComponent;
+    /** Number of direct child codes. */
+    child_count: number;
+}
+interface ICFCodeDetail {
+    /** ICF code. */
+    code: string;
+    /** Code title. */
+    title: string;
+    /** Full definition text, or `null` if not available. */
+    definition: string | null;
+    /** ICF component. */
+    component: ICFComponent;
+    /** Chapter this code belongs to. */
+    chapter: string;
+    /** Parent code in the ICF hierarchy, or `null` for top-level. */
+    parent: ICFCodeSummary | null;
+    /** Direct child codes. */
+    children: ICFCodeSummary[];
+    /** Inclusion notes. */
+    inclusions: string[];
+    /** Exclusion notes. */
+    exclusions: string[];
+    /** Index terms for this code. */
+    index_terms: string[];
+    /** Related ICD-10 codes from WHO Core Sets. */
+    icd10_mappings: CrosswalkMapping[];
+    /** Related ICD-11 codes (via ICD-10 bridge). */
+    icd11_mappings: CrosswalkMapping[];
+    /** Cross-reference IDs: "snomed" (concept IDs), "umls" (CUIs). */
+    cross_references: Record<string, string[]>;
+}
+interface ICFCodeResult {
+    /** Matched ICF code. */
+    code: string;
+    /** Code description. */
+    description: string;
+    /** ICF component. */
+    component: ICFComponent;
+    /** Cosine similarity score (0-1). */
+    similarity: number;
+    /** `"high"` if above high-confidence threshold, else `"moderate"`. */
+    confidence: "high" | "moderate";
+    /** The index term that produced this match. */
+    matched_term: string;
+    /** Related ICD-10 codes. */
+    icd10_codes: string[];
+    /** Related ICD-11 codes. */
+    icd11_codes: string[];
+    /** SNOMED CT concept IDs. */
+    snomed_ids: string[];
+    /** UMLS CUIs. */
+    umls_cuis: string[];
+}
+interface ICFCodingEntity {
+    /** Entity text as extracted from the input. */
+    entity_text: string;
+    /** Ranked ICF code candidates. */
+    codes: ICFCodeResult[];
+}
+interface ICFCodingResponse {
+    /** The input text that was processed. */
+    text: string;
+    /** Coding provider used. */
+    provider: string;
+    /** Total number of entities in results. */
+    entity_count: number;
+    /** Coding results per entity. */
+    results: ICFCodingEntity[];
+}
+interface ICFSearchResponse {
+    /** The search query that was used. */
+    query: string;
+    /** Number of results returned. */
+    count: number;
+    /** Matching ICF codes. */
+    codes: ICFCodeSummary[];
+}
+interface ICFCoreSetResult {
+    /** ICD-10 code used to look up the core set. */
+    icd10_code: string;
+    /** Condition name for this ICD-10 code. */
+    condition_name: string;
+    /** Brief ICF Core Set codes. */
+    brief: ICFCodeSummary[];
+    /** Comprehensive ICF Core Set codes. */
+    comprehensive: ICFCodeSummary[];
+}
+interface LOINCCodeSummary {
+    /** LOINC code (e.g., `"2345-7"`). */
+    code: string;
+    /** Primary description. */
+    long_common_name: string;
+    /** Abbreviated name. */
+    short_name: string;
+    /** LOINC class (e.g., `"CHEM"`). */
+    class_name: string;
+    /** 1=Lab, 2=Clinical, 3=Claims, 4=Surveys. */
+    class_type: number;
+    /** Order, Observation, or Both. */
+    order_obs: string;
+}
+interface LOINCCodeDetail {
+    /** LOINC code. */
+    code: string;
+    /** Primary description. */
+    long_common_name: string;
+    /** Abbreviated name. */
+    short_name: string;
+    /** Display name. */
+    display_name: string;
+    /** Consumer-friendly name. */
+    consumer_name: string;
+    /** What is measured (e.g., `"Glucose"`). */
+    component: string;
+    /** Measurement property (e.g., `"MCnc"`). */
+    property: string;
+    /** Timing (e.g., `"Pt"` = point in time). */
+    time_aspect: string;
+    /** Specimen type (e.g., `"Ser/Plas"`). */
+    system: string;
+    /** Scale (e.g., `"Qn"` = quantitative). */
+    scale_type: string;
+    /** Method used. */
+    method_type: string;
+    /** LOINC class. */
+    class_name: string;
+    /** 1=Lab, 2=Clinical, 3=Claims, 4=Surveys. */
+    class_type: number;
+    /** Definition text, or `null`. */
+    definition: string | null;
+    /** Order, Observation, or Both. */
+    order_obs: string;
+    /** Synonym terms. */
+    related_names: string[];
+    /** Popularity rank. */
+    common_test_rank: number;
+    /** Order popularity rank. */
+    common_order_rank: number;
+    /** Cross-reference IDs: `"snomed"` (concept IDs), `"umls"` (CUIs). */
+    cross_references: Record<string, string[]>;
+}
+interface LOINCSearchResponse {
+    /** The search query that was used. */
+    query: string;
+    /** Number of results returned. */
+    count: number;
+    /** Matching LOINC codes. */
+    codes: LOINCCodeSummary[];
+}
+/** A single LOINC code match from the coding endpoint. */
+interface LOINCCodeResult {
+    code: string;
+    long_common_name: string;
+    component: string;
+    system: string;
+    similarity: number;
+    confidence: "high" | "moderate";
+    matched_term: string;
+    snomed_ids: string[];
+    umls_cuis: string[];
+}
+/** LOINC coding results for a single extracted entity. */
+interface LOINCCodingEntity {
+    entity_text: string;
+    codes: LOINCCodeResult[];
+}
+/** Full LOINC coding response. */
+interface LOINCCodingResponse {
+    text: string;
+    provider: string;
+    entity_count: number;
+    results: LOINCCodingEntity[];
+}
+/**
+ * Audit capability selector. Defaults to all five when omitted.
+ *
+ * - `hcc`: missed HCC codes with RAF-weighted revenue estimates (v22/v28)
+ * - `radv`: submitted codes that cannot be defended against RADV clawback
+ * - `specificity`: suggestions to upgrade unspecified codes to more precise children
+ * - `denial`: documentation-quality flags that correlate with claim denials
+ * - `problem_list`: reconciled active-conditions list across the documentation
+ */
+type AuditCapability = "hcc" | "radv" | "specificity" | "denial" | "problem_list";
+interface AuditDocument {
+    id: string;
+    text: string;
+    type?: "progress_note" | "discharge_summary" | "h_and_p" | "operative_note" | "consult" | "other";
+    date?: string;
+}
+interface AuditCode {
+    code: string;
+    kind: "icd10" | "icd11" | "cpt" | "hcpcs";
+}
+interface AuditContext {
+    patient?: {
+        age?: number;
+        sex?: "male" | "female";
+        coverage?: "medicare_advantage" | "fee_for_service" | "medicaid" | "commercial" | "aco";
+    };
+    claim?: {
+        date_of_service?: string;
+        place_of_service?: string;
+        provider_type?: string;
+    };
+    payer?: {
+        id?: string;
+        type?: string;
+    };
+    rates?: {
+        cms_base_rate?: number;
+        hospital_base_rate?: number;
+        denial_rework_cost?: number;
+    };
+    /** Defaults to `"both"`. `"v24"` is ESRD-specific and NOT accepted; PY2026 MA payment uses v22 + v28. */
+    hcc_model?: "v22" | "v28" | "both";
+}
+interface AuditRequest {
+    text?: string;
+    documents?: AuditDocument[];
+    codes?: AuditCode[];
+    capabilities?: AuditCapability[];
+    context?: AuditContext;
+}
+interface EvidenceSpan {
+    document_id: string;
+    start: number;
+    end: number;
+    quote: string;
+}
+interface ConfirmedCode {
+    code: string;
+    kind: string;
+    description: string;
+    evidence: EvidenceSpan[];
+    confidence: number;
+    hcc_category?: string;
+    raf_weight?: number;
+}
+interface MissedCode {
+    code: string;
+    kind: string;
+    description: string;
+    evidence: EvidenceSpan[];
+    confidence: number;
+    hcc_category?: string;
+    raf_weight?: number;
+    estimated_revenue?: number;
+    hcc_model?: "v22" | "v28";
+}
+interface UnsupportedCode {
+    code: string;
+    kind: string;
+    description: string;
+    reason: string;
+    what_would_support_it: string;
+    radv_risk: "high" | "moderate" | "low";
+    estimated_exposure?: number;
+}
+interface SpecificityUpgrade {
+    from_code: string;
+    to_code: string;
+    from_description: string;
+    to_description: string;
+    evidence: EvidenceSpan[];
+    mcc_cc_change?: {
+        from: "none" | "cc" | "mcc";
+        to: "none" | "cc" | "mcc";
+    };
+    drg_impact?: number;
+}
+interface DenialRisk {
+    code: string;
+    kind: string;
+    description: string;
+    risk: "high" | "moderate" | "low";
+    probability: number;
+    reasons: string[];
+}
+interface ProblemListEntry {
+    condition: string;
+    icd10_code: string;
+    status: "active" | "resolved" | "historical";
+    first_seen: {
+        document_id: string;
+        date?: string;
+    };
+    last_seen: {
+        document_id: string;
+        date?: string;
+    };
+    evidence: EvidenceSpan[];
+}
+interface AuditTotals {
+    missed_raf: number;
+    estimated_revenue_recovery: number;
+    radv_exposure: number;
+    drg_upside: number;
+    codes_confirmed: number;
+    codes_missed: number;
+    codes_unsupported: number;
+    upgrades_available: number;
+}
+interface RatesUsed {
+    cms_base_rate: number;
+    hospital_base_rate: number;
+    source: "cms_national_2026" | "customer_provided";
+    hcc_model: "v22" | "v28" | "both";
+}
+/**
+ * Present on the response when the server dropped one or more requested
+ * capabilities because the caller's plan did not include them.
+ */
+interface UpgradeHint {
+    denied_capabilities: AuditCapability[];
+    required_plan: string;
+    message: string;
+}
+interface AuditResponse {
+    capabilities_run: AuditCapability[];
+    confirmed: ConfirmedCode[];
+    missed: MissedCode[];
+    unsupported: UnsupportedCode[];
+    specificity_upgrades: SpecificityUpgrade[];
+    denial_risk: DenialRisk[];
+    problem_list?: ProblemListEntry[];
+    totals: AuditTotals;
+    provider: string;
+    rates_used: RatesUsed;
+    upgrade_hint?: UpgradeHint;
+}
 
 declare class AutoICD {
     private readonly apiKey;
@@ -212,6 +582,10 @@ declare class AutoICD {
     readonly icd10: ICD10Codes;
     /** Sub-resource for ICD-11 code lookup. */
     readonly icd11: ICD11Codes;
+    /** Sub-resource for ICF code lookup and coding. */
+    readonly icf: ICFCodes;
+    /** Sub-resource for LOINC code lookup and coding. */
+    readonly loinc: LOINCCodes;
     constructor(options: AutoICDOptions);
     /**
      * Code clinical text to ICD-10-CM diagnoses.
@@ -236,6 +610,25 @@ declare class AutoICD {
      * ```
      */
     anonymize(text: string): Promise<AnonymizeResponse>;
+    /**
+     * Audit a chart for coding gaps, RADV risk, specificity, denial flags, and
+     * a reconciled problem list. Every finding carries extractive evidence spans.
+     *
+     * @example
+     * ```ts
+     * const audit = await autoicd.audit({
+     *   text: "68yo M, type 2 diabetes, chronic systolic heart failure on furosemide.",
+     *   codes: [{ code: "E11.9", kind: "icd10" }],
+     *   capabilities: ["hcc", "radv", "specificity", "denial", "problem_list"],
+     *   context: { patient: { coverage: "medicare_advantage" } },
+     * });
+     * console.log(audit.totals.estimated_revenue_recovery);
+     * for (const m of audit.missed) {
+     *   console.log(`${m.code} ${m.hcc_category} $${m.estimated_revenue}`);
+     * }
+     * ```
+     */
+    audit(request: AuditRequest): Promise<AuditResponse>;
     /** @internal */
     get<T>(path: string): Promise<T>;
     /** @internal */
@@ -295,6 +688,100 @@ declare class ICD11Codes {
      */
     get(code: string): Promise<ICD11CodeDetailFull>;
 }
+declare class ICFCodes {
+    private readonly client;
+    constructor(client: AutoICD);
+    /**
+     * Code clinical text to ICF codes.
+     *
+     * @example
+     * ```ts
+     * const result = await autoicd.icf.code("Patient has difficulty walking");
+     * for (const entity of result.results) {
+     *   console.log(entity.entity_text, entity.codes[0]?.code);
+     * }
+     * ```
+     */
+    code(text: string, options?: {
+        topK?: number;
+    }): Promise<ICFCodingResponse>;
+    /**
+     * Get full details for a single ICF code, including definition,
+     * hierarchy (parent/children), inclusions, exclusions, and index terms.
+     *
+     * @example
+     * ```ts
+     * const detail = await autoicd.icf.lookup("b280");
+     * console.log(detail.title);
+     * console.log(detail.definition);
+     * console.log(detail.children.length);
+     * ```
+     */
+    lookup(code: string): Promise<ICFCodeDetail>;
+    /**
+     * Search ICF codes by description.
+     *
+     * @example
+     * ```ts
+     * const results = await autoicd.icf.search("pain");
+     * ```
+     */
+    search(query: string, options?: SearchOptions): Promise<ICFSearchResponse>;
+    /**
+     * Get the ICF Core Set for an ICD-10 diagnosis code.
+     *
+     * @example
+     * ```ts
+     * const coreSet = await autoicd.icf.coreSet("M54.5");
+     * console.log(coreSet.condition_name);
+     * console.log(coreSet.brief.length, "brief codes");
+     * console.log(coreSet.comprehensive.length, "comprehensive codes");
+     * ```
+     */
+    coreSet(icd10Code: string): Promise<ICFCoreSetResult>;
+}
+declare class LOINCCodes {
+    private readonly client;
+    constructor(client: AutoICD);
+    /**
+     * Code clinical text to LOINC codes.
+     *
+     * Extracts lab tests, imaging orders, and clinical observations from
+     * free text and matches to LOINC codes using NER + SapBERT embeddings.
+     *
+     * @example
+     * ```ts
+     * const result = await autoicd.loinc.code("Order CBC, glucose, and TSH");
+     * for (const entity of result.results) {
+     *   console.log(entity.entity_text, entity.codes[0]?.code);
+     * }
+     * ```
+     */
+    code(text: string, options?: {
+        topK?: number;
+    }): Promise<LOINCCodingResponse>;
+    /**
+     * Get full details for a single LOINC code, including 6-axis classification,
+     * definition, related names, and cross-references.
+     *
+     * @example
+     * ```ts
+     * const detail = await autoicd.loinc.lookup("2345-7");
+     * console.log(detail.long_common_name);
+     * console.log(detail.component, detail.system);
+     * ```
+     */
+    lookup(code: string): Promise<LOINCCodeDetail>;
+    /**
+     * Search LOINC codes by description.
+     *
+     * @example
+     * ```ts
+     * const results = await autoicd.loinc.search("glucose");
+     * ```
+     */
+    search(query: string, options?: SearchOptions): Promise<LOINCSearchResponse>;
+}
 
 declare class AutoICDError extends Error {
     readonly status: number;
@@ -311,4 +798,4 @@ declare class NotFoundError extends AutoICDError {
     constructor(message?: string);
 }
 
-export { type AnonymizeResponse, AuthenticationError, AutoICD, AutoICDError, type AutoICDOptions, type ChapterInfo, type CodeDetail, type CodeDetailFull, type CodeMatch, type CodeOptions, type CodeSearchResponse, type CodingEntity, type CodingResponse, type CrosswalkMapping, type ICD11ChapterInfo, type ICD11CodeDetail, type ICD11CodeDetailFull, type ICD11CodeSearchResponse, type ICD11CodeSearchResult, NotFoundError, type PIIEntity, type RateLimit, RateLimitError, type SearchOptions };
+export { type AnonymizeResponse, type AuditCapability, type AuditCode, type AuditContext, type AuditDocument, type AuditRequest, type AuditResponse, type AuditTotals, AuthenticationError, AutoICD, AutoICDError, type AutoICDOptions, type ChapterInfo, type CodeDetail, type CodeDetailFull, type CodeMatch, type CodeOptions, type CodeSearchResponse, type CodingEntity, type CodingResponse, type ConfirmedCode, type CrosswalkMapping, type DenialRisk, type EvidenceSpan, type ICD11ChapterInfo, type ICD11CodeDetail, type ICD11CodeDetailFull, type ICD11CodeSearchResponse, type ICD11CodeSearchResult, type ICFCodeDetail, type ICFCodeResult, type ICFCodeSummary, type ICFCodingEntity, type ICFCodingResponse, type ICFComponent, type ICFCoreSetResult, type ICFCrossReference, type ICFSearchResponse, type LOINCCodeDetail, type LOINCCodeResult, type LOINCCodeSummary, type LOINCCodingEntity, type LOINCCodingResponse, type LOINCSearchResponse, type MissedCode, NotFoundError, type PIIEntity, type ProblemListEntry, type RateLimit, RateLimitError, type RatesUsed, type SearchOptions, type SpecificityUpgrade, type UnsupportedCode, type UpgradeHint };