@sequoiaport/codes 0.1.0-beta.0

package/dist/index.mjs

@@ -0,0 +1,459 @@
+// 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
+import { z } from "zod";
+var SnomedSearchCodeInputSchema = z.object({
+  query: z.string().min(1),
+  limit: z.number().int().min(1).max(200).optional()
+});
+var SnomedIdentifyCodeInputSchema = z.object({
+  code: 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 = z.object({
+  query: z.string().min(1),
+  limit: z.number().int().min(1).max(200).optional(),
+  billingOnly: z.boolean().optional()
+});
+var Icd10IdentifyCodeInputSchema = z.object({
+  code: 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 = z.object({
+  query: z.string().min(1),
+  limit: z.number().int().min(1).max(200).optional()
+});
+var CptIdentifyCodeInputSchema = z.object({
+  code: z.string().min(1)
+});
+var CptGetCostInputSchema = z.object({
+  code: z.string().min(1)
+});
+var CptLinkIcd10InputSchema = z.object({
+  code: 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 = z.object({
+  query: z.string().min(1),
+  limit: z.number().int().min(1).max(200).optional()
+});
+var HcpcsIdentifyCodeInputSchema = z.object({
+  code: z.string().min(1)
+});
+var HcpcsGetCostInputSchema = z.object({
+  code: 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 = z.object({
+  query: z.string().min(1),
+  limit: z.number().int().min(1).max(200).optional()
+});
+var LoincIdentifyCodeInputSchema = z.object({
+  code: z.string().min(1)
+});
+var LoincGetPanelMembersInputSchema = z.object({
+  code: 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 = z.object({
+  query: z.string().min(1),
+  limit: z.number().int().min(1).max(200).optional()
+});
+var RxnormIdentifyCodeInputSchema = z.object({
+  type: z.enum(["ndc", "rxcui"]),
+  code: z.string().min(1)
+});
+var RxnormGetIngredientsInputSchema = z.object({
+  rxcui: 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 = z.object({
+  query: z.string().min(1),
+  limit: z.number().int().min(1).max(200).optional()
+});
+var LcdIdentifyGuidelineInputSchema = z.object({
+  id: 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 = z.object({
+  query: z.string().min(1),
+  limit: z.number().int().min(1).max(200).optional()
+});
+var NcdIdentifyGuidelineInputSchema = z.object({
+  id: z.string().optional(),
+  section: 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
+import { z as z2 } from "zod";
+var DiagnosisToProceduresInputSchema = z2.object({
+  snomed_id: z2.string().optional(),
+  icd10_code: z2.string().optional(),
+  query: z2.string().optional()
+});
+var CoverageCheckInputSchema = z2.object({
+  cpt_code: z2.string().min(1),
+  icd10_code: z2.string().optional()
+});
+var DiagnosisToProceduresOutputSchema = z2.object({
+  snomed_id: z2.string().optional(),
+  icd10_code: z2.string().optional(),
+  icd10_mappings: z2.array(z2.record(z2.unknown())).optional(),
+  procedures: z2.array(z2.record(z2.unknown())).optional()
+});
+var CoverageCheckOutputSchema = z2.object({
+  cpt_code: z2.string(),
+  icd10_code: z2.string().optional(),
+  lcd: z2.record(z2.unknown()).optional(),
+  has_guidelines: z2.boolean(),
+  diagnosis_covered: z2.boolean().optional()
+});
+var GetCategoriesOutputSchema = z2.object({
+  snomed_semantic_tags: z2.record(z2.unknown()).optional(),
+  icd10_chapters: z2.array(z2.record(z2.unknown())).optional(),
+  cpt_categories: z2.array(z2.record(z2.unknown())).optional()
+});
+
+// src/schemas/system.ts
+import { z as z3 } from "zod";
+var GetResultInputSchema = z3.object({
+  request_id: z3.string().min(1)
+});
+var GetResultOutputSchema = z3.object({
+  request_id: z3.string(),
+  status: z3.enum(["pending", "running", "completed", "failed"]),
+  query: z3.string().optional(),
+  result: z3.record(z3.unknown()).optional(),
+  error: z3.string().optional()
+});
+var EngineStatusSchema = z3.record(z3.enum(["ok", "error", "unknown"]));
+var HealthOutputSchema = z3.object({
+  status: z3.enum(["ok", "degraded"]),
+  version: z3.string().optional(),
+  environment: z3.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;
+  }
+};
+export {
+  CodesApiError,
+  CptCategory,
+  HcpcsCategory,
+  Icd10Category,
+  LcdCategory,
+  LoincCategory,
+  NcdCategory,
+  RxnormCategory,
+  SequoiaCodesClient,
+  SnomedCategory
+};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@sequoiaport/codes",
+  "version": "0.1.0-beta.0",
+  "description": "Retrieve ICD-10, CPT, SNOMED, and more medical codes via the Sequoia Codes API.",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "tsup"
+  },
+  "keywords": [
+    "sequoia",
+    "sequoiaport",
+    "icd10",
+    "cpt",
+    "hcpcs",
+    "loinc",
+    "rxnorm",
+    "snomed",
+    "lcd",
+    "ncd",
+    "clinical",
+    "codes",
+    "medical",
+    "coding",
+    "api",
+    "sdk"
+  ],
+  "author": "wconvery",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.4.0",
+    "typescript": "^5.8.2"
+  }
+}