@sequoiaport/codes 0.1.0-beta.0

package/dist/index.js

@@ -0,0 +1,495 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CodesApiError: () => CodesApiError,
+  CptCategory: () => CptCategory,
+  HcpcsCategory: () => HcpcsCategory,
+  Icd10Category: () => Icd10Category,
+  LcdCategory: () => LcdCategory,
+  LoincCategory: () => LoincCategory,
+  NcdCategory: () => NcdCategory,
+  RxnormCategory: () => RxnormCategory,
+  SequoiaCodesClient: () => SequoiaCodesClient,
+  SnomedCategory: () => SnomedCategory
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var CodesApiError = class extends Error {
+  constructor(status, message, action) {
+    super(message);
+    this.status = status;
+    this.action = action;
+    this.name = "CodesApiError";
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      status: this.status,
+      message: this.message,
+      action: this.action
+    };
+  }
+};
+
+// src/engines.ts
+var import_zod = require("zod");
+var SnomedSearchCodeInputSchema = import_zod.z.object({
+  query: import_zod.z.string().min(1),
+  limit: import_zod.z.number().int().min(1).max(200).optional()
+});
+var SnomedIdentifyCodeInputSchema = import_zod.z.object({
+  code: import_zod.z.string().min(1)
+});
+var SnomedCategory = class {
+  constructor(request) {
+    this.request = request;
+  }
+  async searchCode(input) {
+    const validated = SnomedSearchCodeInputSchema.parse(input);
+    return this.request(
+      "snomed/searchCode",
+      validated
+    );
+  }
+  async identifyCode(input) {
+    const validated = SnomedIdentifyCodeInputSchema.parse(input);
+    return this.request("snomed/identifyCode", {
+      code: validated.code
+    });
+  }
+};
+var Icd10SearchCodeInputSchema = import_zod.z.object({
+  query: import_zod.z.string().min(1),
+  limit: import_zod.z.number().int().min(1).max(200).optional(),
+  billingOnly: import_zod.z.boolean().optional()
+});
+var Icd10IdentifyCodeInputSchema = import_zod.z.object({
+  code: import_zod.z.string().min(1)
+});
+var Icd10Category = class {
+  constructor(request) {
+    this.request = request;
+  }
+  async searchCode(input) {
+    const validated = Icd10SearchCodeInputSchema.parse(input);
+    return this.request("icd10/searchCode", validated);
+  }
+  async identifyCode(input) {
+    const validated = Icd10IdentifyCodeInputSchema.parse(input);
+    return this.request("icd10/identifyCode", {
+      code: validated.code
+    });
+  }
+  async getChapters() {
+    return this.request("icd10/getChapters", {});
+  }
+};
+var CptSearchCodeInputSchema = import_zod.z.object({
+  query: import_zod.z.string().min(1),
+  limit: import_zod.z.number().int().min(1).max(200).optional()
+});
+var CptIdentifyCodeInputSchema = import_zod.z.object({
+  code: import_zod.z.string().min(1)
+});
+var CptGetCostInputSchema = import_zod.z.object({
+  code: import_zod.z.string().min(1)
+});
+var CptLinkIcd10InputSchema = import_zod.z.object({
+  code: import_zod.z.string().min(1)
+});
+var CptCategory = class {
+  constructor(request) {
+    this.request = request;
+  }
+  async searchCode(input) {
+    const validated = CptSearchCodeInputSchema.parse(input);
+    return this.request("cpt/searchCode", validated);
+  }
+  async identifyCode(input) {
+    const validated = CptIdentifyCodeInputSchema.parse(input);
+    return this.request("cpt/identifyCode", {
+      code: validated.code
+    });
+  }
+  async getCost(input) {
+    const validated = CptGetCostInputSchema.parse(input);
+    return this.request("cpt/getCost", {
+      code: validated.code
+    });
+  }
+  async linkIcd10(input) {
+    const validated = CptLinkIcd10InputSchema.parse(input);
+    return this.request("cpt/linkIcd10", {
+      code: validated.code
+    });
+  }
+};
+var HcpcsSearchCodeInputSchema = import_zod.z.object({
+  query: import_zod.z.string().min(1),
+  limit: import_zod.z.number().int().min(1).max(200).optional()
+});
+var HcpcsIdentifyCodeInputSchema = import_zod.z.object({
+  code: import_zod.z.string().min(1)
+});
+var HcpcsGetCostInputSchema = import_zod.z.object({
+  code: import_zod.z.string().min(1)
+});
+var HcpcsCategory = class {
+  constructor(request) {
+    this.request = request;
+  }
+  async searchCode(input) {
+    const validated = HcpcsSearchCodeInputSchema.parse(input);
+    return this.request("hcpcs/searchCode", validated);
+  }
+  async identifyCode(input) {
+    const validated = HcpcsIdentifyCodeInputSchema.parse(input);
+    return this.request("hcpcs/identifyCode", {
+      code: validated.code
+    });
+  }
+  async getCost(input) {
+    const validated = HcpcsGetCostInputSchema.parse(input);
+    return this.request("hcpcs/getCost", {
+      code: validated.code
+    });
+  }
+};
+var LoincSearchCodeInputSchema = import_zod.z.object({
+  query: import_zod.z.string().min(1),
+  limit: import_zod.z.number().int().min(1).max(200).optional()
+});
+var LoincIdentifyCodeInputSchema = import_zod.z.object({
+  code: import_zod.z.string().min(1)
+});
+var LoincGetPanelMembersInputSchema = import_zod.z.object({
+  code: import_zod.z.string().min(1)
+});
+var LoincCategory = class {
+  constructor(request) {
+    this.request = request;
+  }
+  async searchCode(input) {
+    const validated = LoincSearchCodeInputSchema.parse(input);
+    return this.request(
+      "loinc/searchCode",
+      validated
+    );
+  }
+  async identifyCode(input) {
+    const validated = LoincIdentifyCodeInputSchema.parse(input);
+    return this.request("loinc/identifyCode", {
+      code: validated.code
+    });
+  }
+  async getPanelMembers(input) {
+    const validated = LoincGetPanelMembersInputSchema.parse(input);
+    return this.request(
+      "loinc/getPanelMembers",
+      { code: validated.code }
+    );
+  }
+};
+var RxnormSearchCodeInputSchema = import_zod.z.object({
+  query: import_zod.z.string().min(1),
+  limit: import_zod.z.number().int().min(1).max(200).optional()
+});
+var RxnormIdentifyCodeInputSchema = import_zod.z.object({
+  type: import_zod.z.enum(["ndc", "rxcui"]),
+  code: import_zod.z.string().min(1)
+});
+var RxnormGetIngredientsInputSchema = import_zod.z.object({
+  rxcui: import_zod.z.string().min(1)
+});
+var RxnormCategory = class {
+  constructor(request) {
+    this.request = request;
+  }
+  async searchCode(input) {
+    const validated = RxnormSearchCodeInputSchema.parse(input);
+    return this.request("rxnorm/searchCode", validated);
+  }
+  async identifyCode(input) {
+    const validated = RxnormIdentifyCodeInputSchema.parse(input);
+    return this.request(
+      "rxnorm/identifyCode",
+      { type: validated.type, code: validated.code }
+    );
+  }
+  async getIngredients(input) {
+    const validated = RxnormGetIngredientsInputSchema.parse(input);
+    return this.request(
+      "rxnorm/getIngredients",
+      validated
+    );
+  }
+};
+var LcdSearchGuidelinesInputSchema = import_zod.z.object({
+  query: import_zod.z.string().min(1),
+  limit: import_zod.z.number().int().min(1).max(200).optional()
+});
+var LcdIdentifyGuidelineInputSchema = import_zod.z.object({
+  id: import_zod.z.string().min(1)
+});
+var LcdCategory = class {
+  constructor(request) {
+    this.request = request;
+  }
+  async searchGuidelines(input) {
+    const validated = LcdSearchGuidelinesInputSchema.parse(input);
+    return this.request(
+      "lcd/searchGuidelines",
+      validated
+    );
+  }
+  async identifyGuideline(input) {
+    const validated = LcdIdentifyGuidelineInputSchema.parse(input);
+    return this.request("lcd/identifyGuideline", {
+      id: validated.id
+    });
+  }
+};
+var NcdSearchGuidelinesInputSchema = import_zod.z.object({
+  query: import_zod.z.string().min(1),
+  limit: import_zod.z.number().int().min(1).max(200).optional()
+});
+var NcdIdentifyGuidelineInputSchema = import_zod.z.object({
+  id: import_zod.z.string().optional(),
+  section: import_zod.z.string().optional()
+}).refine((data) => data.id || data.section, {
+  message: "Either id or section must be provided"
+});
+var NcdCategory = class {
+  constructor(request) {
+    this.request = request;
+  }
+  async searchGuidelines(input) {
+    const validated = NcdSearchGuidelinesInputSchema.parse(input);
+    return this.request(
+      "ncd/searchGuidelines",
+      validated
+    );
+  }
+  async identifyGuideline(input) {
+    const validated = NcdIdentifyGuidelineInputSchema.parse(input);
+    return this.request("ncd/identifyGuideline", {
+      id: validated.id,
+      section: validated.section
+    });
+  }
+};
+
+// src/schemas/clinical.ts
+var import_zod2 = require("zod");
+var DiagnosisToProceduresInputSchema = import_zod2.z.object({
+  snomed_id: import_zod2.z.string().optional(),
+  icd10_code: import_zod2.z.string().optional(),
+  query: import_zod2.z.string().optional()
+});
+var CoverageCheckInputSchema = import_zod2.z.object({
+  cpt_code: import_zod2.z.string().min(1),
+  icd10_code: import_zod2.z.string().optional()
+});
+var DiagnosisToProceduresOutputSchema = import_zod2.z.object({
+  snomed_id: import_zod2.z.string().optional(),
+  icd10_code: import_zod2.z.string().optional(),
+  icd10_mappings: import_zod2.z.array(import_zod2.z.record(import_zod2.z.unknown())).optional(),
+  procedures: import_zod2.z.array(import_zod2.z.record(import_zod2.z.unknown())).optional()
+});
+var CoverageCheckOutputSchema = import_zod2.z.object({
+  cpt_code: import_zod2.z.string(),
+  icd10_code: import_zod2.z.string().optional(),
+  lcd: import_zod2.z.record(import_zod2.z.unknown()).optional(),
+  has_guidelines: import_zod2.z.boolean(),
+  diagnosis_covered: import_zod2.z.boolean().optional()
+});
+var GetCategoriesOutputSchema = import_zod2.z.object({
+  snomed_semantic_tags: import_zod2.z.record(import_zod2.z.unknown()).optional(),
+  icd10_chapters: import_zod2.z.array(import_zod2.z.record(import_zod2.z.unknown())).optional(),
+  cpt_categories: import_zod2.z.array(import_zod2.z.record(import_zod2.z.unknown())).optional()
+});
+
+// src/schemas/system.ts
+var import_zod3 = require("zod");
+var GetResultInputSchema = import_zod3.z.object({
+  request_id: import_zod3.z.string().min(1)
+});
+var GetResultOutputSchema = import_zod3.z.object({
+  request_id: import_zod3.z.string(),
+  status: import_zod3.z.enum(["pending", "running", "completed", "failed"]),
+  query: import_zod3.z.string().optional(),
+  result: import_zod3.z.record(import_zod3.z.unknown()).optional(),
+  error: import_zod3.z.string().optional()
+});
+var EngineStatusSchema = import_zod3.z.record(import_zod3.z.enum(["ok", "error", "unknown"]));
+var HealthOutputSchema = import_zod3.z.object({
+  status: import_zod3.z.enum(["ok", "degraded"]),
+  version: import_zod3.z.string().optional(),
+  environment: import_zod3.z.string().optional(),
+  engines: EngineStatusSchema.optional()
+});
+
+// src/client.ts
+var ClinicalCategory = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /** Check LCD coverage for a CPT code + optional ICD-10 pair */
+  async checkCoverage(input) {
+    const validated = CoverageCheckInputSchema.parse(input);
+    return this.request(
+      "clinical/checkCoverage",
+      validated
+    );
+  }
+  /** Map a diagnosis (SNOMED or ICD-10) to relevant procedures */
+  async getProceduresForDiagnosis(input) {
+    const validated = DiagnosisToProceduresInputSchema.parse(input);
+    return this.request(
+      "clinical/getProceduresForDiagnosis",
+      validated
+    );
+  }
+  /** Get metadata/categories from all engines (semantic tags, chapters, etc.) */
+  async getMetadata() {
+    return this.request("clinical/getMetadata", {});
+  }
+};
+var SystemCategory = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /** Get async request result by ID */
+  async getResult(input) {
+    const validated = GetResultInputSchema.parse(input);
+    return this.request("system/getResult", validated);
+  }
+  /** Health check all engines */
+  async health() {
+    return this.request("system/health", {});
+  }
+};
+var DEFAULT_BASE_URL = "https://api.sequoiacodes.com";
+var DEFAULT_VERSION = "v1";
+var SequoiaCodesClient = class {
+  apiKey;
+  baseUrl;
+  version;
+  // ==========================================================================
+  // Orchestrator Categories
+  // ==========================================================================
+  /** Clinical orchestrator: coverage check, diagnosis-to-procedures, metadata */
+  clinical;
+  /** System actions: get async result, health check */
+  system;
+  // ==========================================================================
+  // Coding System Categories
+  // ==========================================================================
+  /** SNOMED CT coding system */
+  snomed;
+  /** ICD-10 diagnosis codes */
+  icd10;
+  /** CPT procedure codes */
+  cpt;
+  /** HCPCS procedure codes */
+  hcpcs;
+  /** LOINC laboratory test codes */
+  loinc;
+  /** RxNorm drug/medication codes */
+  rxnorm;
+  // ==========================================================================
+  // Guideline Categories
+  // ==========================================================================
+  /** LCD (Local Coverage Determination) guidelines */
+  lcd;
+  /** NCD (National Coverage Determination) guidelines */
+  ncd;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.baseUrl ?? DEFAULT_BASE_URL;
+    this.version = config.version ?? DEFAULT_VERSION;
+    const boundRequest = this.request.bind(this);
+    this.clinical = new ClinicalCategory(boundRequest);
+    this.system = new SystemCategory(boundRequest);
+    this.snomed = new SnomedCategory(boundRequest);
+    this.icd10 = new Icd10Category(boundRequest);
+    this.cpt = new CptCategory(boundRequest);
+    this.hcpcs = new HcpcsCategory(boundRequest);
+    this.loinc = new LoincCategory(boundRequest);
+    this.rxnorm = new RxnormCategory(boundRequest);
+    this.lcd = new LcdCategory(boundRequest);
+    this.ncd = new NcdCategory(boundRequest);
+  }
+  /**
+   * Make an HTTP request to the Codes API Gateway.
+   */
+  async request(path, params, method = "GET") {
+    const url = new URL(`${this.baseUrl}/${this.version}/${path}`);
+    const headers = {
+      Authorization: `Bearer ${this.apiKey}`,
+      "Content-Type": "application/json"
+    };
+    const options = {
+      method,
+      headers
+    };
+    if (method === "GET" && params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== void 0 && value !== null) {
+          if (Array.isArray(value)) {
+            url.searchParams.set(key, JSON.stringify(value));
+          } else if (typeof value === "object") {
+            url.searchParams.set(key, JSON.stringify(value));
+          } else {
+            url.searchParams.set(key, String(value));
+          }
+        }
+      }
+    } else if (method === "POST" && params) {
+      options.body = JSON.stringify(params);
+    }
+    const response = await fetch(url.toString(), options);
+    const data = await response.json();
+    if (!response.ok || !data.success) {
+      throw new CodesApiError(
+        response.status,
+        data.error || "Unknown error",
+        path
+      );
+    }
+    return data.data;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CodesApiError,
+  CptCategory,
+  HcpcsCategory,
+  Icd10Category,
+  LcdCategory,
+  LoincCategory,
+  NcdCategory,
+  RxnormCategory,
+  SequoiaCodesClient,
+  SnomedCategory
+});