@sequoiaport/codes 0.1.0-beta.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +21 -0
- package/README.md +262 -0
- package/dist/index.d.mts +2423 -0
- package/dist/index.d.ts +2423 -0
- package/dist/index.js +495 -0
- package/dist/index.mjs +459 -0
- package/package.json +41 -0
package/dist/index.d.ts
ADDED
|
@@ -0,0 +1,2423 @@
|
|
|
1
|
+
import { z } from 'zod';
|
|
2
|
+
|
|
3
|
+
/**
|
|
4
|
+
* Configuration for the Sequoia Codes public API client
|
|
5
|
+
*/
|
|
6
|
+
interface SequoiaCodesClientConfig {
|
|
7
|
+
/** API Key for authentication (SEQUOIA_CODES_API_KEY) */
|
|
8
|
+
apiKey: string;
|
|
9
|
+
/** Base URL (defaults to https://api.sequoiacodes.com) */
|
|
10
|
+
baseUrl?: string;
|
|
11
|
+
/** API version (defaults to v1) */
|
|
12
|
+
version?: string;
|
|
13
|
+
}
|
|
14
|
+
/**
|
|
15
|
+
* Standard API response envelope from the Codes API Gateway
|
|
16
|
+
*/
|
|
17
|
+
interface ApiResponse<T> {
|
|
18
|
+
success: boolean;
|
|
19
|
+
data?: T;
|
|
20
|
+
error?: string;
|
|
21
|
+
version: string;
|
|
22
|
+
}
|
|
23
|
+
|
|
24
|
+
/** SNOMED concept result */
|
|
25
|
+
declare const SnomedConceptSchema: z.ZodObject<{
|
|
26
|
+
concept_id: z.ZodString;
|
|
27
|
+
fsn: z.ZodOptional<z.ZodString>;
|
|
28
|
+
preferred_term: z.ZodOptional<z.ZodString>;
|
|
29
|
+
semantic_tag: z.ZodOptional<z.ZodString>;
|
|
30
|
+
definition_status: z.ZodOptional<z.ZodString>;
|
|
31
|
+
effective_time: z.ZodOptional<z.ZodString>;
|
|
32
|
+
active: z.ZodOptional<z.ZodBoolean>;
|
|
33
|
+
module_id: z.ZodOptional<z.ZodString>;
|
|
34
|
+
similarity: z.ZodOptional<z.ZodNumber>;
|
|
35
|
+
rrf_score: z.ZodOptional<z.ZodNumber>;
|
|
36
|
+
text_score: z.ZodOptional<z.ZodNumber>;
|
|
37
|
+
match_type: z.ZodOptional<z.ZodString>;
|
|
38
|
+
icd10_codes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
39
|
+
}, "strip", z.ZodTypeAny, {
|
|
40
|
+
concept_id: string;
|
|
41
|
+
fsn?: string | undefined;
|
|
42
|
+
preferred_term?: string | undefined;
|
|
43
|
+
semantic_tag?: string | undefined;
|
|
44
|
+
definition_status?: string | undefined;
|
|
45
|
+
effective_time?: string | undefined;
|
|
46
|
+
active?: boolean | undefined;
|
|
47
|
+
module_id?: string | undefined;
|
|
48
|
+
similarity?: number | undefined;
|
|
49
|
+
rrf_score?: number | undefined;
|
|
50
|
+
text_score?: number | undefined;
|
|
51
|
+
match_type?: string | undefined;
|
|
52
|
+
icd10_codes?: string[] | undefined;
|
|
53
|
+
}, {
|
|
54
|
+
concept_id: string;
|
|
55
|
+
fsn?: string | undefined;
|
|
56
|
+
preferred_term?: string | undefined;
|
|
57
|
+
semantic_tag?: string | undefined;
|
|
58
|
+
definition_status?: string | undefined;
|
|
59
|
+
effective_time?: string | undefined;
|
|
60
|
+
active?: boolean | undefined;
|
|
61
|
+
module_id?: string | undefined;
|
|
62
|
+
similarity?: number | undefined;
|
|
63
|
+
rrf_score?: number | undefined;
|
|
64
|
+
text_score?: number | undefined;
|
|
65
|
+
match_type?: string | undefined;
|
|
66
|
+
icd10_codes?: string[] | undefined;
|
|
67
|
+
}>;
|
|
68
|
+
/** ICD-10 mapping result */
|
|
69
|
+
declare const Icd10MappingSchema: z.ZodObject<{
|
|
70
|
+
icd10_code: z.ZodString;
|
|
71
|
+
icd10_term: z.ZodOptional<z.ZodString>;
|
|
72
|
+
map_category: z.ZodOptional<z.ZodString>;
|
|
73
|
+
map_priority: z.ZodOptional<z.ZodNumber>;
|
|
74
|
+
map_rule: z.ZodOptional<z.ZodString>;
|
|
75
|
+
map_advice: z.ZodOptional<z.ZodString>;
|
|
76
|
+
map_target: z.ZodOptional<z.ZodString>;
|
|
77
|
+
correlation_id: z.ZodOptional<z.ZodString>;
|
|
78
|
+
}, "strip", z.ZodTypeAny, {
|
|
79
|
+
icd10_code: string;
|
|
80
|
+
icd10_term?: string | undefined;
|
|
81
|
+
map_category?: string | undefined;
|
|
82
|
+
map_priority?: number | undefined;
|
|
83
|
+
map_rule?: string | undefined;
|
|
84
|
+
map_advice?: string | undefined;
|
|
85
|
+
map_target?: string | undefined;
|
|
86
|
+
correlation_id?: string | undefined;
|
|
87
|
+
}, {
|
|
88
|
+
icd10_code: string;
|
|
89
|
+
icd10_term?: string | undefined;
|
|
90
|
+
map_category?: string | undefined;
|
|
91
|
+
map_priority?: number | undefined;
|
|
92
|
+
map_rule?: string | undefined;
|
|
93
|
+
map_advice?: string | undefined;
|
|
94
|
+
map_target?: string | undefined;
|
|
95
|
+
correlation_id?: string | undefined;
|
|
96
|
+
}>;
|
|
97
|
+
/** SNOMED relationship */
|
|
98
|
+
declare const SnomedRelationshipSchema: z.ZodObject<{
|
|
99
|
+
relationship_id: z.ZodOptional<z.ZodString>;
|
|
100
|
+
source_id: z.ZodString;
|
|
101
|
+
destination_id: z.ZodString;
|
|
102
|
+
relationship_type_id: z.ZodString;
|
|
103
|
+
relationship_type_name: z.ZodOptional<z.ZodString>;
|
|
104
|
+
destination_term: z.ZodOptional<z.ZodString>;
|
|
105
|
+
characteristic_type: z.ZodOptional<z.ZodString>;
|
|
106
|
+
active: z.ZodOptional<z.ZodBoolean>;
|
|
107
|
+
}, "strip", z.ZodTypeAny, {
|
|
108
|
+
source_id: string;
|
|
109
|
+
destination_id: string;
|
|
110
|
+
relationship_type_id: string;
|
|
111
|
+
active?: boolean | undefined;
|
|
112
|
+
relationship_id?: string | undefined;
|
|
113
|
+
relationship_type_name?: string | undefined;
|
|
114
|
+
destination_term?: string | undefined;
|
|
115
|
+
characteristic_type?: string | undefined;
|
|
116
|
+
}, {
|
|
117
|
+
source_id: string;
|
|
118
|
+
destination_id: string;
|
|
119
|
+
relationship_type_id: string;
|
|
120
|
+
active?: boolean | undefined;
|
|
121
|
+
relationship_id?: string | undefined;
|
|
122
|
+
relationship_type_name?: string | undefined;
|
|
123
|
+
destination_term?: string | undefined;
|
|
124
|
+
characteristic_type?: string | undefined;
|
|
125
|
+
}>;
|
|
126
|
+
/** search_hybrid output */
|
|
127
|
+
declare const SearchHybridOutputSchema$2: z.ZodObject<{
|
|
128
|
+
query: z.ZodString;
|
|
129
|
+
count: z.ZodNumber;
|
|
130
|
+
results: z.ZodArray<z.ZodObject<{
|
|
131
|
+
concept_id: z.ZodString;
|
|
132
|
+
fsn: z.ZodOptional<z.ZodString>;
|
|
133
|
+
preferred_term: z.ZodOptional<z.ZodString>;
|
|
134
|
+
semantic_tag: z.ZodOptional<z.ZodString>;
|
|
135
|
+
definition_status: z.ZodOptional<z.ZodString>;
|
|
136
|
+
effective_time: z.ZodOptional<z.ZodString>;
|
|
137
|
+
active: z.ZodOptional<z.ZodBoolean>;
|
|
138
|
+
module_id: z.ZodOptional<z.ZodString>;
|
|
139
|
+
similarity: z.ZodOptional<z.ZodNumber>;
|
|
140
|
+
rrf_score: z.ZodOptional<z.ZodNumber>;
|
|
141
|
+
text_score: z.ZodOptional<z.ZodNumber>;
|
|
142
|
+
match_type: z.ZodOptional<z.ZodString>;
|
|
143
|
+
icd10_codes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
144
|
+
}, "strip", z.ZodTypeAny, {
|
|
145
|
+
concept_id: string;
|
|
146
|
+
fsn?: string | undefined;
|
|
147
|
+
preferred_term?: string | undefined;
|
|
148
|
+
semantic_tag?: string | undefined;
|
|
149
|
+
definition_status?: string | undefined;
|
|
150
|
+
effective_time?: string | undefined;
|
|
151
|
+
active?: boolean | undefined;
|
|
152
|
+
module_id?: string | undefined;
|
|
153
|
+
similarity?: number | undefined;
|
|
154
|
+
rrf_score?: number | undefined;
|
|
155
|
+
text_score?: number | undefined;
|
|
156
|
+
match_type?: string | undefined;
|
|
157
|
+
icd10_codes?: string[] | undefined;
|
|
158
|
+
}, {
|
|
159
|
+
concept_id: string;
|
|
160
|
+
fsn?: string | undefined;
|
|
161
|
+
preferred_term?: string | undefined;
|
|
162
|
+
semantic_tag?: string | undefined;
|
|
163
|
+
definition_status?: string | undefined;
|
|
164
|
+
effective_time?: string | undefined;
|
|
165
|
+
active?: boolean | undefined;
|
|
166
|
+
module_id?: string | undefined;
|
|
167
|
+
similarity?: number | undefined;
|
|
168
|
+
rrf_score?: number | undefined;
|
|
169
|
+
text_score?: number | undefined;
|
|
170
|
+
match_type?: string | undefined;
|
|
171
|
+
icd10_codes?: string[] | undefined;
|
|
172
|
+
}>, "many">;
|
|
173
|
+
search_mode: z.ZodLiteral<"hybrid">;
|
|
174
|
+
vector_weight: z.ZodOptional<z.ZodNumber>;
|
|
175
|
+
}, "strip", z.ZodTypeAny, {
|
|
176
|
+
query: string;
|
|
177
|
+
count: number;
|
|
178
|
+
results: {
|
|
179
|
+
concept_id: string;
|
|
180
|
+
fsn?: string | undefined;
|
|
181
|
+
preferred_term?: string | undefined;
|
|
182
|
+
semantic_tag?: string | undefined;
|
|
183
|
+
definition_status?: string | undefined;
|
|
184
|
+
effective_time?: string | undefined;
|
|
185
|
+
active?: boolean | undefined;
|
|
186
|
+
module_id?: string | undefined;
|
|
187
|
+
similarity?: number | undefined;
|
|
188
|
+
rrf_score?: number | undefined;
|
|
189
|
+
text_score?: number | undefined;
|
|
190
|
+
match_type?: string | undefined;
|
|
191
|
+
icd10_codes?: string[] | undefined;
|
|
192
|
+
}[];
|
|
193
|
+
search_mode: "hybrid";
|
|
194
|
+
vector_weight?: number | undefined;
|
|
195
|
+
}, {
|
|
196
|
+
query: string;
|
|
197
|
+
count: number;
|
|
198
|
+
results: {
|
|
199
|
+
concept_id: string;
|
|
200
|
+
fsn?: string | undefined;
|
|
201
|
+
preferred_term?: string | undefined;
|
|
202
|
+
semantic_tag?: string | undefined;
|
|
203
|
+
definition_status?: string | undefined;
|
|
204
|
+
effective_time?: string | undefined;
|
|
205
|
+
active?: boolean | undefined;
|
|
206
|
+
module_id?: string | undefined;
|
|
207
|
+
similarity?: number | undefined;
|
|
208
|
+
rrf_score?: number | undefined;
|
|
209
|
+
text_score?: number | undefined;
|
|
210
|
+
match_type?: string | undefined;
|
|
211
|
+
icd10_codes?: string[] | undefined;
|
|
212
|
+
}[];
|
|
213
|
+
search_mode: "hybrid";
|
|
214
|
+
vector_weight?: number | undefined;
|
|
215
|
+
}>;
|
|
216
|
+
/** lookup_code output */
|
|
217
|
+
declare const LookupCodeOutputSchema$1: z.ZodObject<{
|
|
218
|
+
concept: z.ZodNullable<z.ZodObject<{
|
|
219
|
+
concept_id: z.ZodString;
|
|
220
|
+
fsn: z.ZodOptional<z.ZodString>;
|
|
221
|
+
preferred_term: z.ZodOptional<z.ZodString>;
|
|
222
|
+
semantic_tag: z.ZodOptional<z.ZodString>;
|
|
223
|
+
definition_status: z.ZodOptional<z.ZodString>;
|
|
224
|
+
effective_time: z.ZodOptional<z.ZodString>;
|
|
225
|
+
active: z.ZodOptional<z.ZodBoolean>;
|
|
226
|
+
module_id: z.ZodOptional<z.ZodString>;
|
|
227
|
+
similarity: z.ZodOptional<z.ZodNumber>;
|
|
228
|
+
rrf_score: z.ZodOptional<z.ZodNumber>;
|
|
229
|
+
text_score: z.ZodOptional<z.ZodNumber>;
|
|
230
|
+
match_type: z.ZodOptional<z.ZodString>;
|
|
231
|
+
icd10_codes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
232
|
+
}, "strip", z.ZodTypeAny, {
|
|
233
|
+
concept_id: string;
|
|
234
|
+
fsn?: string | undefined;
|
|
235
|
+
preferred_term?: string | undefined;
|
|
236
|
+
semantic_tag?: string | undefined;
|
|
237
|
+
definition_status?: string | undefined;
|
|
238
|
+
effective_time?: string | undefined;
|
|
239
|
+
active?: boolean | undefined;
|
|
240
|
+
module_id?: string | undefined;
|
|
241
|
+
similarity?: number | undefined;
|
|
242
|
+
rrf_score?: number | undefined;
|
|
243
|
+
text_score?: number | undefined;
|
|
244
|
+
match_type?: string | undefined;
|
|
245
|
+
icd10_codes?: string[] | undefined;
|
|
246
|
+
}, {
|
|
247
|
+
concept_id: string;
|
|
248
|
+
fsn?: string | undefined;
|
|
249
|
+
preferred_term?: string | undefined;
|
|
250
|
+
semantic_tag?: string | undefined;
|
|
251
|
+
definition_status?: string | undefined;
|
|
252
|
+
effective_time?: string | undefined;
|
|
253
|
+
active?: boolean | undefined;
|
|
254
|
+
module_id?: string | undefined;
|
|
255
|
+
similarity?: number | undefined;
|
|
256
|
+
rrf_score?: number | undefined;
|
|
257
|
+
text_score?: number | undefined;
|
|
258
|
+
match_type?: string | undefined;
|
|
259
|
+
icd10_codes?: string[] | undefined;
|
|
260
|
+
}>>;
|
|
261
|
+
}, "strip", z.ZodTypeAny, {
|
|
262
|
+
concept: {
|
|
263
|
+
concept_id: string;
|
|
264
|
+
fsn?: string | undefined;
|
|
265
|
+
preferred_term?: string | undefined;
|
|
266
|
+
semantic_tag?: string | undefined;
|
|
267
|
+
definition_status?: string | undefined;
|
|
268
|
+
effective_time?: string | undefined;
|
|
269
|
+
active?: boolean | undefined;
|
|
270
|
+
module_id?: string | undefined;
|
|
271
|
+
similarity?: number | undefined;
|
|
272
|
+
rrf_score?: number | undefined;
|
|
273
|
+
text_score?: number | undefined;
|
|
274
|
+
match_type?: string | undefined;
|
|
275
|
+
icd10_codes?: string[] | undefined;
|
|
276
|
+
} | null;
|
|
277
|
+
}, {
|
|
278
|
+
concept: {
|
|
279
|
+
concept_id: string;
|
|
280
|
+
fsn?: string | undefined;
|
|
281
|
+
preferred_term?: string | undefined;
|
|
282
|
+
semantic_tag?: string | undefined;
|
|
283
|
+
definition_status?: string | undefined;
|
|
284
|
+
effective_time?: string | undefined;
|
|
285
|
+
active?: boolean | undefined;
|
|
286
|
+
module_id?: string | undefined;
|
|
287
|
+
similarity?: number | undefined;
|
|
288
|
+
rrf_score?: number | undefined;
|
|
289
|
+
text_score?: number | undefined;
|
|
290
|
+
match_type?: string | undefined;
|
|
291
|
+
icd10_codes?: string[] | undefined;
|
|
292
|
+
} | null;
|
|
293
|
+
}>;
|
|
294
|
+
type SnomedConcept = z.infer<typeof SnomedConceptSchema>;
|
|
295
|
+
type Icd10Mapping = z.infer<typeof Icd10MappingSchema>;
|
|
296
|
+
type SnomedRelationship = z.infer<typeof SnomedRelationshipSchema>;
|
|
297
|
+
type SnomedSearchOutput = z.infer<typeof SearchHybridOutputSchema$2>;
|
|
298
|
+
type SnomedLookupOutput = z.infer<typeof LookupCodeOutputSchema$1>;
|
|
299
|
+
|
|
300
|
+
/** ICD-10 code result */
|
|
301
|
+
declare const Icd10CodeSchema: z.ZodObject<{
|
|
302
|
+
code: z.ZodString;
|
|
303
|
+
short_description: z.ZodOptional<z.ZodString>;
|
|
304
|
+
long_description: z.ZodOptional<z.ZodString>;
|
|
305
|
+
chapter: z.ZodOptional<z.ZodString>;
|
|
306
|
+
chapter_description: z.ZodOptional<z.ZodString>;
|
|
307
|
+
block: z.ZodOptional<z.ZodString>;
|
|
308
|
+
block_description: z.ZodOptional<z.ZodString>;
|
|
309
|
+
category: z.ZodOptional<z.ZodString>;
|
|
310
|
+
subcategory: z.ZodOptional<z.ZodString>;
|
|
311
|
+
is_billable: z.ZodOptional<z.ZodBoolean>;
|
|
312
|
+
valid_for_submission: z.ZodOptional<z.ZodBoolean>;
|
|
313
|
+
similarity: z.ZodOptional<z.ZodNumber>;
|
|
314
|
+
rrf_score: z.ZodOptional<z.ZodNumber>;
|
|
315
|
+
text_score: z.ZodOptional<z.ZodNumber>;
|
|
316
|
+
match_type: z.ZodOptional<z.ZodString>;
|
|
317
|
+
}, "strip", z.ZodTypeAny, {
|
|
318
|
+
code: string;
|
|
319
|
+
similarity?: number | undefined;
|
|
320
|
+
rrf_score?: number | undefined;
|
|
321
|
+
text_score?: number | undefined;
|
|
322
|
+
match_type?: string | undefined;
|
|
323
|
+
short_description?: string | undefined;
|
|
324
|
+
long_description?: string | undefined;
|
|
325
|
+
chapter?: string | undefined;
|
|
326
|
+
chapter_description?: string | undefined;
|
|
327
|
+
block?: string | undefined;
|
|
328
|
+
block_description?: string | undefined;
|
|
329
|
+
category?: string | undefined;
|
|
330
|
+
subcategory?: string | undefined;
|
|
331
|
+
is_billable?: boolean | undefined;
|
|
332
|
+
valid_for_submission?: boolean | undefined;
|
|
333
|
+
}, {
|
|
334
|
+
code: string;
|
|
335
|
+
similarity?: number | undefined;
|
|
336
|
+
rrf_score?: number | undefined;
|
|
337
|
+
text_score?: number | undefined;
|
|
338
|
+
match_type?: string | undefined;
|
|
339
|
+
short_description?: string | undefined;
|
|
340
|
+
long_description?: string | undefined;
|
|
341
|
+
chapter?: string | undefined;
|
|
342
|
+
chapter_description?: string | undefined;
|
|
343
|
+
block?: string | undefined;
|
|
344
|
+
block_description?: string | undefined;
|
|
345
|
+
category?: string | undefined;
|
|
346
|
+
subcategory?: string | undefined;
|
|
347
|
+
is_billable?: boolean | undefined;
|
|
348
|
+
valid_for_submission?: boolean | undefined;
|
|
349
|
+
}>;
|
|
350
|
+
/** ICD-10 chapter */
|
|
351
|
+
declare const Icd10ChapterSchema: z.ZodObject<{
|
|
352
|
+
chapter_code: z.ZodString;
|
|
353
|
+
chapter_description: z.ZodString;
|
|
354
|
+
code_range: z.ZodOptional<z.ZodString>;
|
|
355
|
+
}, "strip", z.ZodTypeAny, {
|
|
356
|
+
chapter_description: string;
|
|
357
|
+
chapter_code: string;
|
|
358
|
+
code_range?: string | undefined;
|
|
359
|
+
}, {
|
|
360
|
+
chapter_description: string;
|
|
361
|
+
chapter_code: string;
|
|
362
|
+
code_range?: string | undefined;
|
|
363
|
+
}>;
|
|
364
|
+
/** search_hybrid output */
|
|
365
|
+
declare const SearchHybridOutputSchema$1: z.ZodObject<{
|
|
366
|
+
query: z.ZodString;
|
|
367
|
+
count: z.ZodNumber;
|
|
368
|
+
results: z.ZodArray<z.ZodObject<{
|
|
369
|
+
code: z.ZodString;
|
|
370
|
+
short_description: z.ZodOptional<z.ZodString>;
|
|
371
|
+
long_description: z.ZodOptional<z.ZodString>;
|
|
372
|
+
chapter: z.ZodOptional<z.ZodString>;
|
|
373
|
+
chapter_description: z.ZodOptional<z.ZodString>;
|
|
374
|
+
block: z.ZodOptional<z.ZodString>;
|
|
375
|
+
block_description: z.ZodOptional<z.ZodString>;
|
|
376
|
+
category: z.ZodOptional<z.ZodString>;
|
|
377
|
+
subcategory: z.ZodOptional<z.ZodString>;
|
|
378
|
+
is_billable: z.ZodOptional<z.ZodBoolean>;
|
|
379
|
+
valid_for_submission: z.ZodOptional<z.ZodBoolean>;
|
|
380
|
+
similarity: z.ZodOptional<z.ZodNumber>;
|
|
381
|
+
rrf_score: z.ZodOptional<z.ZodNumber>;
|
|
382
|
+
text_score: z.ZodOptional<z.ZodNumber>;
|
|
383
|
+
match_type: z.ZodOptional<z.ZodString>;
|
|
384
|
+
}, "strip", z.ZodTypeAny, {
|
|
385
|
+
code: string;
|
|
386
|
+
similarity?: number | undefined;
|
|
387
|
+
rrf_score?: number | undefined;
|
|
388
|
+
text_score?: number | undefined;
|
|
389
|
+
match_type?: string | undefined;
|
|
390
|
+
short_description?: string | undefined;
|
|
391
|
+
long_description?: string | undefined;
|
|
392
|
+
chapter?: string | undefined;
|
|
393
|
+
chapter_description?: string | undefined;
|
|
394
|
+
block?: string | undefined;
|
|
395
|
+
block_description?: string | undefined;
|
|
396
|
+
category?: string | undefined;
|
|
397
|
+
subcategory?: string | undefined;
|
|
398
|
+
is_billable?: boolean | undefined;
|
|
399
|
+
valid_for_submission?: boolean | undefined;
|
|
400
|
+
}, {
|
|
401
|
+
code: string;
|
|
402
|
+
similarity?: number | undefined;
|
|
403
|
+
rrf_score?: number | undefined;
|
|
404
|
+
text_score?: number | undefined;
|
|
405
|
+
match_type?: string | undefined;
|
|
406
|
+
short_description?: string | undefined;
|
|
407
|
+
long_description?: string | undefined;
|
|
408
|
+
chapter?: string | undefined;
|
|
409
|
+
chapter_description?: string | undefined;
|
|
410
|
+
block?: string | undefined;
|
|
411
|
+
block_description?: string | undefined;
|
|
412
|
+
category?: string | undefined;
|
|
413
|
+
subcategory?: string | undefined;
|
|
414
|
+
is_billable?: boolean | undefined;
|
|
415
|
+
valid_for_submission?: boolean | undefined;
|
|
416
|
+
}>, "many">;
|
|
417
|
+
search_mode: z.ZodLiteral<"hybrid">;
|
|
418
|
+
vector_weight: z.ZodOptional<z.ZodNumber>;
|
|
419
|
+
}, "strip", z.ZodTypeAny, {
|
|
420
|
+
query: string;
|
|
421
|
+
count: number;
|
|
422
|
+
results: {
|
|
423
|
+
code: string;
|
|
424
|
+
similarity?: number | undefined;
|
|
425
|
+
rrf_score?: number | undefined;
|
|
426
|
+
text_score?: number | undefined;
|
|
427
|
+
match_type?: string | undefined;
|
|
428
|
+
short_description?: string | undefined;
|
|
429
|
+
long_description?: string | undefined;
|
|
430
|
+
chapter?: string | undefined;
|
|
431
|
+
chapter_description?: string | undefined;
|
|
432
|
+
block?: string | undefined;
|
|
433
|
+
block_description?: string | undefined;
|
|
434
|
+
category?: string | undefined;
|
|
435
|
+
subcategory?: string | undefined;
|
|
436
|
+
is_billable?: boolean | undefined;
|
|
437
|
+
valid_for_submission?: boolean | undefined;
|
|
438
|
+
}[];
|
|
439
|
+
search_mode: "hybrid";
|
|
440
|
+
vector_weight?: number | undefined;
|
|
441
|
+
}, {
|
|
442
|
+
query: string;
|
|
443
|
+
count: number;
|
|
444
|
+
results: {
|
|
445
|
+
code: string;
|
|
446
|
+
similarity?: number | undefined;
|
|
447
|
+
rrf_score?: number | undefined;
|
|
448
|
+
text_score?: number | undefined;
|
|
449
|
+
match_type?: string | undefined;
|
|
450
|
+
short_description?: string | undefined;
|
|
451
|
+
long_description?: string | undefined;
|
|
452
|
+
chapter?: string | undefined;
|
|
453
|
+
chapter_description?: string | undefined;
|
|
454
|
+
block?: string | undefined;
|
|
455
|
+
block_description?: string | undefined;
|
|
456
|
+
category?: string | undefined;
|
|
457
|
+
subcategory?: string | undefined;
|
|
458
|
+
is_billable?: boolean | undefined;
|
|
459
|
+
valid_for_submission?: boolean | undefined;
|
|
460
|
+
}[];
|
|
461
|
+
search_mode: "hybrid";
|
|
462
|
+
vector_weight?: number | undefined;
|
|
463
|
+
}>;
|
|
464
|
+
/** lookup_code output */
|
|
465
|
+
declare const LookupCodeOutputSchema: z.ZodObject<{
|
|
466
|
+
code: z.ZodString;
|
|
467
|
+
result: z.ZodNullable<z.ZodObject<{
|
|
468
|
+
code: z.ZodString;
|
|
469
|
+
short_description: z.ZodOptional<z.ZodString>;
|
|
470
|
+
long_description: z.ZodOptional<z.ZodString>;
|
|
471
|
+
chapter: z.ZodOptional<z.ZodString>;
|
|
472
|
+
chapter_description: z.ZodOptional<z.ZodString>;
|
|
473
|
+
block: z.ZodOptional<z.ZodString>;
|
|
474
|
+
block_description: z.ZodOptional<z.ZodString>;
|
|
475
|
+
category: z.ZodOptional<z.ZodString>;
|
|
476
|
+
subcategory: z.ZodOptional<z.ZodString>;
|
|
477
|
+
is_billable: z.ZodOptional<z.ZodBoolean>;
|
|
478
|
+
valid_for_submission: z.ZodOptional<z.ZodBoolean>;
|
|
479
|
+
similarity: z.ZodOptional<z.ZodNumber>;
|
|
480
|
+
rrf_score: z.ZodOptional<z.ZodNumber>;
|
|
481
|
+
text_score: z.ZodOptional<z.ZodNumber>;
|
|
482
|
+
match_type: z.ZodOptional<z.ZodString>;
|
|
483
|
+
}, "strip", z.ZodTypeAny, {
|
|
484
|
+
code: string;
|
|
485
|
+
similarity?: number | undefined;
|
|
486
|
+
rrf_score?: number | undefined;
|
|
487
|
+
text_score?: number | undefined;
|
|
488
|
+
match_type?: string | undefined;
|
|
489
|
+
short_description?: string | undefined;
|
|
490
|
+
long_description?: string | undefined;
|
|
491
|
+
chapter?: string | undefined;
|
|
492
|
+
chapter_description?: string | undefined;
|
|
493
|
+
block?: string | undefined;
|
|
494
|
+
block_description?: string | undefined;
|
|
495
|
+
category?: string | undefined;
|
|
496
|
+
subcategory?: string | undefined;
|
|
497
|
+
is_billable?: boolean | undefined;
|
|
498
|
+
valid_for_submission?: boolean | undefined;
|
|
499
|
+
}, {
|
|
500
|
+
code: string;
|
|
501
|
+
similarity?: number | undefined;
|
|
502
|
+
rrf_score?: number | undefined;
|
|
503
|
+
text_score?: number | undefined;
|
|
504
|
+
match_type?: string | undefined;
|
|
505
|
+
short_description?: string | undefined;
|
|
506
|
+
long_description?: string | undefined;
|
|
507
|
+
chapter?: string | undefined;
|
|
508
|
+
chapter_description?: string | undefined;
|
|
509
|
+
block?: string | undefined;
|
|
510
|
+
block_description?: string | undefined;
|
|
511
|
+
category?: string | undefined;
|
|
512
|
+
subcategory?: string | undefined;
|
|
513
|
+
is_billable?: boolean | undefined;
|
|
514
|
+
valid_for_submission?: boolean | undefined;
|
|
515
|
+
}>>;
|
|
516
|
+
}, "strip", z.ZodTypeAny, {
|
|
517
|
+
code: string;
|
|
518
|
+
result: {
|
|
519
|
+
code: string;
|
|
520
|
+
similarity?: number | undefined;
|
|
521
|
+
rrf_score?: number | undefined;
|
|
522
|
+
text_score?: number | undefined;
|
|
523
|
+
match_type?: string | undefined;
|
|
524
|
+
short_description?: string | undefined;
|
|
525
|
+
long_description?: string | undefined;
|
|
526
|
+
chapter?: string | undefined;
|
|
527
|
+
chapter_description?: string | undefined;
|
|
528
|
+
block?: string | undefined;
|
|
529
|
+
block_description?: string | undefined;
|
|
530
|
+
category?: string | undefined;
|
|
531
|
+
subcategory?: string | undefined;
|
|
532
|
+
is_billable?: boolean | undefined;
|
|
533
|
+
valid_for_submission?: boolean | undefined;
|
|
534
|
+
} | null;
|
|
535
|
+
}, {
|
|
536
|
+
code: string;
|
|
537
|
+
result: {
|
|
538
|
+
code: string;
|
|
539
|
+
similarity?: number | undefined;
|
|
540
|
+
rrf_score?: number | undefined;
|
|
541
|
+
text_score?: number | undefined;
|
|
542
|
+
match_type?: string | undefined;
|
|
543
|
+
short_description?: string | undefined;
|
|
544
|
+
long_description?: string | undefined;
|
|
545
|
+
chapter?: string | undefined;
|
|
546
|
+
chapter_description?: string | undefined;
|
|
547
|
+
block?: string | undefined;
|
|
548
|
+
block_description?: string | undefined;
|
|
549
|
+
category?: string | undefined;
|
|
550
|
+
subcategory?: string | undefined;
|
|
551
|
+
is_billable?: boolean | undefined;
|
|
552
|
+
valid_for_submission?: boolean | undefined;
|
|
553
|
+
} | null;
|
|
554
|
+
}>;
|
|
555
|
+
/** get_chapters output */
|
|
556
|
+
declare const GetChaptersOutputSchema: z.ZodObject<{
|
|
557
|
+
count: z.ZodNumber;
|
|
558
|
+
chapters: z.ZodArray<z.ZodObject<{
|
|
559
|
+
chapter_code: z.ZodString;
|
|
560
|
+
chapter_description: z.ZodString;
|
|
561
|
+
code_range: z.ZodOptional<z.ZodString>;
|
|
562
|
+
}, "strip", z.ZodTypeAny, {
|
|
563
|
+
chapter_description: string;
|
|
564
|
+
chapter_code: string;
|
|
565
|
+
code_range?: string | undefined;
|
|
566
|
+
}, {
|
|
567
|
+
chapter_description: string;
|
|
568
|
+
chapter_code: string;
|
|
569
|
+
code_range?: string | undefined;
|
|
570
|
+
}>, "many">;
|
|
571
|
+
}, "strip", z.ZodTypeAny, {
|
|
572
|
+
count: number;
|
|
573
|
+
chapters: {
|
|
574
|
+
chapter_description: string;
|
|
575
|
+
chapter_code: string;
|
|
576
|
+
code_range?: string | undefined;
|
|
577
|
+
}[];
|
|
578
|
+
}, {
|
|
579
|
+
count: number;
|
|
580
|
+
chapters: {
|
|
581
|
+
chapter_description: string;
|
|
582
|
+
chapter_code: string;
|
|
583
|
+
code_range?: string | undefined;
|
|
584
|
+
}[];
|
|
585
|
+
}>;
|
|
586
|
+
type Icd10Code = z.infer<typeof Icd10CodeSchema>;
|
|
587
|
+
type Icd10Chapter = z.infer<typeof Icd10ChapterSchema>;
|
|
588
|
+
type Icd10SearchOutput = z.infer<typeof SearchHybridOutputSchema$1>;
|
|
589
|
+
type Icd10LookupOutput = z.infer<typeof LookupCodeOutputSchema>;
|
|
590
|
+
type Icd10GetChaptersOutput = z.infer<typeof GetChaptersOutputSchema>;
|
|
591
|
+
|
|
592
|
+
/** CPT/HCPCS code result */
|
|
593
|
+
declare const CPTCodeSchema: z.ZodObject<{
|
|
594
|
+
code: z.ZodString;
|
|
595
|
+
code_type: z.ZodEnum<["CPT", "HCPCS"]>;
|
|
596
|
+
short_description: z.ZodString;
|
|
597
|
+
long_description: z.ZodOptional<z.ZodString>;
|
|
598
|
+
indications: z.ZodOptional<z.ZodString>;
|
|
599
|
+
category: z.ZodOptional<z.ZodString>;
|
|
600
|
+
specialty: z.ZodOptional<z.ZodString>;
|
|
601
|
+
similarity: z.ZodOptional<z.ZodNumber>;
|
|
602
|
+
rvu_work: z.ZodOptional<z.ZodNumber>;
|
|
603
|
+
rvu_pe: z.ZodOptional<z.ZodNumber>;
|
|
604
|
+
rvu_mp: z.ZodOptional<z.ZodNumber>;
|
|
605
|
+
}, "strip", z.ZodTypeAny, {
|
|
606
|
+
code: string;
|
|
607
|
+
short_description: string;
|
|
608
|
+
code_type: "CPT" | "HCPCS";
|
|
609
|
+
similarity?: number | undefined;
|
|
610
|
+
long_description?: string | undefined;
|
|
611
|
+
category?: string | undefined;
|
|
612
|
+
indications?: string | undefined;
|
|
613
|
+
specialty?: string | undefined;
|
|
614
|
+
rvu_work?: number | undefined;
|
|
615
|
+
rvu_pe?: number | undefined;
|
|
616
|
+
rvu_mp?: number | undefined;
|
|
617
|
+
}, {
|
|
618
|
+
code: string;
|
|
619
|
+
short_description: string;
|
|
620
|
+
code_type: "CPT" | "HCPCS";
|
|
621
|
+
similarity?: number | undefined;
|
|
622
|
+
long_description?: string | undefined;
|
|
623
|
+
category?: string | undefined;
|
|
624
|
+
indications?: string | undefined;
|
|
625
|
+
specialty?: string | undefined;
|
|
626
|
+
rvu_work?: number | undefined;
|
|
627
|
+
rvu_pe?: number | undefined;
|
|
628
|
+
rvu_mp?: number | undefined;
|
|
629
|
+
}>;
|
|
630
|
+
/** search_hybrid output */
|
|
631
|
+
declare const SearchHybridOutputSchema: z.ZodObject<{
|
|
632
|
+
query: z.ZodString;
|
|
633
|
+
count: z.ZodNumber;
|
|
634
|
+
results: z.ZodArray<z.ZodObject<{
|
|
635
|
+
code: z.ZodString;
|
|
636
|
+
code_type: z.ZodEnum<["CPT", "HCPCS"]>;
|
|
637
|
+
short_description: z.ZodString;
|
|
638
|
+
long_description: z.ZodOptional<z.ZodString>;
|
|
639
|
+
indications: z.ZodOptional<z.ZodString>;
|
|
640
|
+
category: z.ZodOptional<z.ZodString>;
|
|
641
|
+
specialty: z.ZodOptional<z.ZodString>;
|
|
642
|
+
similarity: z.ZodOptional<z.ZodNumber>;
|
|
643
|
+
rvu_work: z.ZodOptional<z.ZodNumber>;
|
|
644
|
+
rvu_pe: z.ZodOptional<z.ZodNumber>;
|
|
645
|
+
rvu_mp: z.ZodOptional<z.ZodNumber>;
|
|
646
|
+
}, "strip", z.ZodTypeAny, {
|
|
647
|
+
code: string;
|
|
648
|
+
short_description: string;
|
|
649
|
+
code_type: "CPT" | "HCPCS";
|
|
650
|
+
similarity?: number | undefined;
|
|
651
|
+
long_description?: string | undefined;
|
|
652
|
+
category?: string | undefined;
|
|
653
|
+
indications?: string | undefined;
|
|
654
|
+
specialty?: string | undefined;
|
|
655
|
+
rvu_work?: number | undefined;
|
|
656
|
+
rvu_pe?: number | undefined;
|
|
657
|
+
rvu_mp?: number | undefined;
|
|
658
|
+
}, {
|
|
659
|
+
code: string;
|
|
660
|
+
short_description: string;
|
|
661
|
+
code_type: "CPT" | "HCPCS";
|
|
662
|
+
similarity?: number | undefined;
|
|
663
|
+
long_description?: string | undefined;
|
|
664
|
+
category?: string | undefined;
|
|
665
|
+
indications?: string | undefined;
|
|
666
|
+
specialty?: string | undefined;
|
|
667
|
+
rvu_work?: number | undefined;
|
|
668
|
+
rvu_pe?: number | undefined;
|
|
669
|
+
rvu_mp?: number | undefined;
|
|
670
|
+
}>, "many">;
|
|
671
|
+
}, "strip", z.ZodTypeAny, {
|
|
672
|
+
query: string;
|
|
673
|
+
count: number;
|
|
674
|
+
results: {
|
|
675
|
+
code: string;
|
|
676
|
+
short_description: string;
|
|
677
|
+
code_type: "CPT" | "HCPCS";
|
|
678
|
+
similarity?: number | undefined;
|
|
679
|
+
long_description?: string | undefined;
|
|
680
|
+
category?: string | undefined;
|
|
681
|
+
indications?: string | undefined;
|
|
682
|
+
specialty?: string | undefined;
|
|
683
|
+
rvu_work?: number | undefined;
|
|
684
|
+
rvu_pe?: number | undefined;
|
|
685
|
+
rvu_mp?: number | undefined;
|
|
686
|
+
}[];
|
|
687
|
+
}, {
|
|
688
|
+
query: string;
|
|
689
|
+
count: number;
|
|
690
|
+
results: {
|
|
691
|
+
code: string;
|
|
692
|
+
short_description: string;
|
|
693
|
+
code_type: "CPT" | "HCPCS";
|
|
694
|
+
similarity?: number | undefined;
|
|
695
|
+
long_description?: string | undefined;
|
|
696
|
+
category?: string | undefined;
|
|
697
|
+
indications?: string | undefined;
|
|
698
|
+
specialty?: string | undefined;
|
|
699
|
+
rvu_work?: number | undefined;
|
|
700
|
+
rvu_pe?: number | undefined;
|
|
701
|
+
rvu_mp?: number | undefined;
|
|
702
|
+
}[];
|
|
703
|
+
}>;
|
|
704
|
+
/** get_code output */
|
|
705
|
+
declare const GetCodeOutputSchema: z.ZodObject<{
|
|
706
|
+
code: z.ZodString;
|
|
707
|
+
found: z.ZodBoolean;
|
|
708
|
+
result: z.ZodOptional<z.ZodObject<{
|
|
709
|
+
code: z.ZodString;
|
|
710
|
+
code_type: z.ZodEnum<["CPT", "HCPCS"]>;
|
|
711
|
+
short_description: z.ZodString;
|
|
712
|
+
long_description: z.ZodOptional<z.ZodString>;
|
|
713
|
+
indications: z.ZodOptional<z.ZodString>;
|
|
714
|
+
category: z.ZodOptional<z.ZodString>;
|
|
715
|
+
specialty: z.ZodOptional<z.ZodString>;
|
|
716
|
+
similarity: z.ZodOptional<z.ZodNumber>;
|
|
717
|
+
rvu_work: z.ZodOptional<z.ZodNumber>;
|
|
718
|
+
rvu_pe: z.ZodOptional<z.ZodNumber>;
|
|
719
|
+
rvu_mp: z.ZodOptional<z.ZodNumber>;
|
|
720
|
+
}, "strip", z.ZodTypeAny, {
|
|
721
|
+
code: string;
|
|
722
|
+
short_description: string;
|
|
723
|
+
code_type: "CPT" | "HCPCS";
|
|
724
|
+
similarity?: number | undefined;
|
|
725
|
+
long_description?: string | undefined;
|
|
726
|
+
category?: string | undefined;
|
|
727
|
+
indications?: string | undefined;
|
|
728
|
+
specialty?: string | undefined;
|
|
729
|
+
rvu_work?: number | undefined;
|
|
730
|
+
rvu_pe?: number | undefined;
|
|
731
|
+
rvu_mp?: number | undefined;
|
|
732
|
+
}, {
|
|
733
|
+
code: string;
|
|
734
|
+
short_description: string;
|
|
735
|
+
code_type: "CPT" | "HCPCS";
|
|
736
|
+
similarity?: number | undefined;
|
|
737
|
+
long_description?: string | undefined;
|
|
738
|
+
category?: string | undefined;
|
|
739
|
+
indications?: string | undefined;
|
|
740
|
+
specialty?: string | undefined;
|
|
741
|
+
rvu_work?: number | undefined;
|
|
742
|
+
rvu_pe?: number | undefined;
|
|
743
|
+
rvu_mp?: number | undefined;
|
|
744
|
+
}>>;
|
|
745
|
+
}, "strip", z.ZodTypeAny, {
|
|
746
|
+
code: string;
|
|
747
|
+
found: boolean;
|
|
748
|
+
result?: {
|
|
749
|
+
code: string;
|
|
750
|
+
short_description: string;
|
|
751
|
+
code_type: "CPT" | "HCPCS";
|
|
752
|
+
similarity?: number | undefined;
|
|
753
|
+
long_description?: string | undefined;
|
|
754
|
+
category?: string | undefined;
|
|
755
|
+
indications?: string | undefined;
|
|
756
|
+
specialty?: string | undefined;
|
|
757
|
+
rvu_work?: number | undefined;
|
|
758
|
+
rvu_pe?: number | undefined;
|
|
759
|
+
rvu_mp?: number | undefined;
|
|
760
|
+
} | undefined;
|
|
761
|
+
}, {
|
|
762
|
+
code: string;
|
|
763
|
+
found: boolean;
|
|
764
|
+
result?: {
|
|
765
|
+
code: string;
|
|
766
|
+
short_description: string;
|
|
767
|
+
code_type: "CPT" | "HCPCS";
|
|
768
|
+
similarity?: number | undefined;
|
|
769
|
+
long_description?: string | undefined;
|
|
770
|
+
category?: string | undefined;
|
|
771
|
+
indications?: string | undefined;
|
|
772
|
+
specialty?: string | undefined;
|
|
773
|
+
rvu_work?: number | undefined;
|
|
774
|
+
rvu_pe?: number | undefined;
|
|
775
|
+
rvu_mp?: number | undefined;
|
|
776
|
+
} | undefined;
|
|
777
|
+
}>;
|
|
778
|
+
/** get_cost output */
|
|
779
|
+
declare const GetCostOutputSchema: z.ZodObject<{
|
|
780
|
+
cost: z.ZodObject<{
|
|
781
|
+
code: z.ZodString;
|
|
782
|
+
rvu_work: z.ZodNumber;
|
|
783
|
+
rvu_pe: z.ZodNumber;
|
|
784
|
+
rvu_mp: z.ZodNumber;
|
|
785
|
+
rvu_total: z.ZodNumber;
|
|
786
|
+
conversion_factor: z.ZodNumber;
|
|
787
|
+
fee_schedule: z.ZodString;
|
|
788
|
+
effective_date: z.ZodOptional<z.ZodString>;
|
|
789
|
+
}, "strip", z.ZodTypeAny, {
|
|
790
|
+
code: string;
|
|
791
|
+
rvu_work: number;
|
|
792
|
+
rvu_pe: number;
|
|
793
|
+
rvu_mp: number;
|
|
794
|
+
rvu_total: number;
|
|
795
|
+
conversion_factor: number;
|
|
796
|
+
fee_schedule: string;
|
|
797
|
+
effective_date?: string | undefined;
|
|
798
|
+
}, {
|
|
799
|
+
code: string;
|
|
800
|
+
rvu_work: number;
|
|
801
|
+
rvu_pe: number;
|
|
802
|
+
rvu_mp: number;
|
|
803
|
+
rvu_total: number;
|
|
804
|
+
conversion_factor: number;
|
|
805
|
+
fee_schedule: string;
|
|
806
|
+
effective_date?: string | undefined;
|
|
807
|
+
}>;
|
|
808
|
+
}, "strip", z.ZodTypeAny, {
|
|
809
|
+
cost: {
|
|
810
|
+
code: string;
|
|
811
|
+
rvu_work: number;
|
|
812
|
+
rvu_pe: number;
|
|
813
|
+
rvu_mp: number;
|
|
814
|
+
rvu_total: number;
|
|
815
|
+
conversion_factor: number;
|
|
816
|
+
fee_schedule: string;
|
|
817
|
+
effective_date?: string | undefined;
|
|
818
|
+
};
|
|
819
|
+
}, {
|
|
820
|
+
cost: {
|
|
821
|
+
code: string;
|
|
822
|
+
rvu_work: number;
|
|
823
|
+
rvu_pe: number;
|
|
824
|
+
rvu_mp: number;
|
|
825
|
+
rvu_total: number;
|
|
826
|
+
conversion_factor: number;
|
|
827
|
+
fee_schedule: string;
|
|
828
|
+
effective_date?: string | undefined;
|
|
829
|
+
};
|
|
830
|
+
}>;
|
|
831
|
+
/** link_icd10 output */
|
|
832
|
+
declare const LinkIcd10OutputSchema: z.ZodObject<{
|
|
833
|
+
code: z.ZodString;
|
|
834
|
+
code_type: z.ZodString;
|
|
835
|
+
short_description: z.ZodString;
|
|
836
|
+
indications: z.ZodString;
|
|
837
|
+
search_terms: z.ZodArray<z.ZodString, "many">;
|
|
838
|
+
_usage: z.ZodString;
|
|
839
|
+
}, "strip", z.ZodTypeAny, {
|
|
840
|
+
code: string;
|
|
841
|
+
short_description: string;
|
|
842
|
+
code_type: string;
|
|
843
|
+
indications: string;
|
|
844
|
+
search_terms: string[];
|
|
845
|
+
_usage: string;
|
|
846
|
+
}, {
|
|
847
|
+
code: string;
|
|
848
|
+
short_description: string;
|
|
849
|
+
code_type: string;
|
|
850
|
+
indications: string;
|
|
851
|
+
search_terms: string[];
|
|
852
|
+
_usage: string;
|
|
853
|
+
}>;
|
|
854
|
+
/** search_guidelines output (LCD) */
|
|
855
|
+
declare const SearchGuidelinesOutputSchema: z.ZodObject<{
|
|
856
|
+
query: z.ZodString;
|
|
857
|
+
guidelines: z.ZodArray<z.ZodObject<{
|
|
858
|
+
lcd_id: z.ZodString;
|
|
859
|
+
title: z.ZodString;
|
|
860
|
+
contractor: z.ZodString;
|
|
861
|
+
effective_date: z.ZodString;
|
|
862
|
+
summary: z.ZodOptional<z.ZodString>;
|
|
863
|
+
}, "strip", z.ZodTypeAny, {
|
|
864
|
+
effective_date: string;
|
|
865
|
+
lcd_id: string;
|
|
866
|
+
title: string;
|
|
867
|
+
contractor: string;
|
|
868
|
+
summary?: string | undefined;
|
|
869
|
+
}, {
|
|
870
|
+
effective_date: string;
|
|
871
|
+
lcd_id: string;
|
|
872
|
+
title: string;
|
|
873
|
+
contractor: string;
|
|
874
|
+
summary?: string | undefined;
|
|
875
|
+
}>, "many">;
|
|
876
|
+
count: z.ZodNumber;
|
|
877
|
+
}, "strip", z.ZodTypeAny, {
|
|
878
|
+
query: string;
|
|
879
|
+
count: number;
|
|
880
|
+
guidelines: {
|
|
881
|
+
effective_date: string;
|
|
882
|
+
lcd_id: string;
|
|
883
|
+
title: string;
|
|
884
|
+
contractor: string;
|
|
885
|
+
summary?: string | undefined;
|
|
886
|
+
}[];
|
|
887
|
+
}, {
|
|
888
|
+
query: string;
|
|
889
|
+
count: number;
|
|
890
|
+
guidelines: {
|
|
891
|
+
effective_date: string;
|
|
892
|
+
lcd_id: string;
|
|
893
|
+
title: string;
|
|
894
|
+
contractor: string;
|
|
895
|
+
summary?: string | undefined;
|
|
896
|
+
}[];
|
|
897
|
+
}>;
|
|
898
|
+
/** get_lcd_by_id output */
|
|
899
|
+
declare const GetLcdByIdOutputSchema: z.ZodObject<{
|
|
900
|
+
lcd: z.ZodObject<{
|
|
901
|
+
lcd_id: z.ZodString;
|
|
902
|
+
title: z.ZodString;
|
|
903
|
+
contractor: z.ZodString;
|
|
904
|
+
effective_date: z.ZodString;
|
|
905
|
+
content: z.ZodString;
|
|
906
|
+
summary: z.ZodOptional<z.ZodString>;
|
|
907
|
+
}, "strip", z.ZodTypeAny, {
|
|
908
|
+
effective_date: string;
|
|
909
|
+
lcd_id: string;
|
|
910
|
+
title: string;
|
|
911
|
+
contractor: string;
|
|
912
|
+
content: string;
|
|
913
|
+
summary?: string | undefined;
|
|
914
|
+
}, {
|
|
915
|
+
effective_date: string;
|
|
916
|
+
lcd_id: string;
|
|
917
|
+
title: string;
|
|
918
|
+
contractor: string;
|
|
919
|
+
content: string;
|
|
920
|
+
summary?: string | undefined;
|
|
921
|
+
}>;
|
|
922
|
+
linked_codes: z.ZodArray<z.ZodString, "many">;
|
|
923
|
+
codes_count: z.ZodNumber;
|
|
924
|
+
}, "strip", z.ZodTypeAny, {
|
|
925
|
+
lcd: {
|
|
926
|
+
effective_date: string;
|
|
927
|
+
lcd_id: string;
|
|
928
|
+
title: string;
|
|
929
|
+
contractor: string;
|
|
930
|
+
content: string;
|
|
931
|
+
summary?: string | undefined;
|
|
932
|
+
};
|
|
933
|
+
linked_codes: string[];
|
|
934
|
+
codes_count: number;
|
|
935
|
+
}, {
|
|
936
|
+
lcd: {
|
|
937
|
+
effective_date: string;
|
|
938
|
+
lcd_id: string;
|
|
939
|
+
title: string;
|
|
940
|
+
contractor: string;
|
|
941
|
+
content: string;
|
|
942
|
+
summary?: string | undefined;
|
|
943
|
+
};
|
|
944
|
+
linked_codes: string[];
|
|
945
|
+
codes_count: number;
|
|
946
|
+
}>;
|
|
947
|
+
/** search_ncd output */
|
|
948
|
+
declare const SearchNcdOutputSchema: z.ZodObject<{
|
|
949
|
+
query: z.ZodString;
|
|
950
|
+
ncds: z.ZodArray<z.ZodObject<{
|
|
951
|
+
ncd_id: z.ZodString;
|
|
952
|
+
section: z.ZodString;
|
|
953
|
+
title: z.ZodString;
|
|
954
|
+
effective_date: z.ZodString;
|
|
955
|
+
coverage_level: z.ZodNumber;
|
|
956
|
+
}, "strip", z.ZodTypeAny, {
|
|
957
|
+
effective_date: string;
|
|
958
|
+
title: string;
|
|
959
|
+
ncd_id: string;
|
|
960
|
+
section: string;
|
|
961
|
+
coverage_level: number;
|
|
962
|
+
}, {
|
|
963
|
+
effective_date: string;
|
|
964
|
+
title: string;
|
|
965
|
+
ncd_id: string;
|
|
966
|
+
section: string;
|
|
967
|
+
coverage_level: number;
|
|
968
|
+
}>, "many">;
|
|
969
|
+
count: z.ZodNumber;
|
|
970
|
+
}, "strip", z.ZodTypeAny, {
|
|
971
|
+
query: string;
|
|
972
|
+
count: number;
|
|
973
|
+
ncds: {
|
|
974
|
+
effective_date: string;
|
|
975
|
+
title: string;
|
|
976
|
+
ncd_id: string;
|
|
977
|
+
section: string;
|
|
978
|
+
coverage_level: number;
|
|
979
|
+
}[];
|
|
980
|
+
}, {
|
|
981
|
+
query: string;
|
|
982
|
+
count: number;
|
|
983
|
+
ncds: {
|
|
984
|
+
effective_date: string;
|
|
985
|
+
title: string;
|
|
986
|
+
ncd_id: string;
|
|
987
|
+
section: string;
|
|
988
|
+
coverage_level: number;
|
|
989
|
+
}[];
|
|
990
|
+
}>;
|
|
991
|
+
/** get_ncd output */
|
|
992
|
+
declare const GetNcdOutputSchema: z.ZodObject<{
|
|
993
|
+
ncd: z.ZodObject<{
|
|
994
|
+
ncd_id: z.ZodString;
|
|
995
|
+
section: z.ZodString;
|
|
996
|
+
title: z.ZodString;
|
|
997
|
+
effective_date: z.ZodString;
|
|
998
|
+
coverage_level: z.ZodNumber;
|
|
999
|
+
content: z.ZodString;
|
|
1000
|
+
}, "strip", z.ZodTypeAny, {
|
|
1001
|
+
effective_date: string;
|
|
1002
|
+
title: string;
|
|
1003
|
+
content: string;
|
|
1004
|
+
ncd_id: string;
|
|
1005
|
+
section: string;
|
|
1006
|
+
coverage_level: number;
|
|
1007
|
+
}, {
|
|
1008
|
+
effective_date: string;
|
|
1009
|
+
title: string;
|
|
1010
|
+
content: string;
|
|
1011
|
+
ncd_id: string;
|
|
1012
|
+
section: string;
|
|
1013
|
+
coverage_level: number;
|
|
1014
|
+
}>;
|
|
1015
|
+
}, "strip", z.ZodTypeAny, {
|
|
1016
|
+
ncd: {
|
|
1017
|
+
effective_date: string;
|
|
1018
|
+
title: string;
|
|
1019
|
+
content: string;
|
|
1020
|
+
ncd_id: string;
|
|
1021
|
+
section: string;
|
|
1022
|
+
coverage_level: number;
|
|
1023
|
+
};
|
|
1024
|
+
}, {
|
|
1025
|
+
ncd: {
|
|
1026
|
+
effective_date: string;
|
|
1027
|
+
title: string;
|
|
1028
|
+
content: string;
|
|
1029
|
+
ncd_id: string;
|
|
1030
|
+
section: string;
|
|
1031
|
+
coverage_level: number;
|
|
1032
|
+
};
|
|
1033
|
+
}>;
|
|
1034
|
+
type CPTCode = z.infer<typeof CPTCodeSchema>;
|
|
1035
|
+
type CptSearchOutput = z.infer<typeof SearchHybridOutputSchema>;
|
|
1036
|
+
type CptGetCodeOutput = z.infer<typeof GetCodeOutputSchema>;
|
|
1037
|
+
type CptGetCostOutput = z.infer<typeof GetCostOutputSchema>;
|
|
1038
|
+
type CptLinkIcd10Output = z.infer<typeof LinkIcd10OutputSchema>;
|
|
1039
|
+
type LcdSearchOutput = z.infer<typeof SearchGuidelinesOutputSchema>;
|
|
1040
|
+
type LcdGetOutput = z.infer<typeof GetLcdByIdOutputSchema>;
|
|
1041
|
+
type NcdSearchOutput = z.infer<typeof SearchNcdOutputSchema>;
|
|
1042
|
+
type NcdGetOutput = z.infer<typeof GetNcdOutputSchema>;
|
|
1043
|
+
|
|
1044
|
+
/** LOINC code result */
|
|
1045
|
+
declare const LoincCodeSchema: z.ZodObject<{
|
|
1046
|
+
loinc_num: z.ZodString;
|
|
1047
|
+
component: z.ZodOptional<z.ZodString>;
|
|
1048
|
+
property: z.ZodOptional<z.ZodString>;
|
|
1049
|
+
time_aspect: z.ZodOptional<z.ZodString>;
|
|
1050
|
+
system: z.ZodOptional<z.ZodString>;
|
|
1051
|
+
scale_type: z.ZodOptional<z.ZodString>;
|
|
1052
|
+
method_type: z.ZodOptional<z.ZodString>;
|
|
1053
|
+
class: z.ZodOptional<z.ZodString>;
|
|
1054
|
+
class_type: z.ZodOptional<z.ZodNumber>;
|
|
1055
|
+
order_obs: z.ZodOptional<z.ZodString>;
|
|
1056
|
+
long_common_name: z.ZodOptional<z.ZodString>;
|
|
1057
|
+
short_name: z.ZodOptional<z.ZodString>;
|
|
1058
|
+
display_name: z.ZodOptional<z.ZodString>;
|
|
1059
|
+
consumer_name: z.ZodOptional<z.ZodString>;
|
|
1060
|
+
common_test_rank: z.ZodOptional<z.ZodNumber>;
|
|
1061
|
+
common_order_rank: z.ZodOptional<z.ZodNumber>;
|
|
1062
|
+
indications: z.ZodOptional<z.ZodString>;
|
|
1063
|
+
clinical_phrases: z.ZodOptional<z.ZodString>;
|
|
1064
|
+
documentation_keywords: z.ZodOptional<z.ZodString>;
|
|
1065
|
+
interpretation_guidance: z.ZodOptional<z.ZodString>;
|
|
1066
|
+
related_tests: z.ZodOptional<z.ZodString>;
|
|
1067
|
+
specimen_requirements: z.ZodOptional<z.ZodString>;
|
|
1068
|
+
test_category: z.ZodOptional<z.ZodString>;
|
|
1069
|
+
body_system: z.ZodOptional<z.ZodString>;
|
|
1070
|
+
specialty: z.ZodOptional<z.ZodString>;
|
|
1071
|
+
mapped_to: z.ZodOptional<z.ZodString>;
|
|
1072
|
+
status: z.ZodOptional<z.ZodString>;
|
|
1073
|
+
similarity: z.ZodOptional<z.ZodNumber>;
|
|
1074
|
+
rrf_score: z.ZodOptional<z.ZodNumber>;
|
|
1075
|
+
match_type: z.ZodOptional<z.ZodString>;
|
|
1076
|
+
}, "strip", z.ZodTypeAny, {
|
|
1077
|
+
loinc_num: string;
|
|
1078
|
+
similarity?: number | undefined;
|
|
1079
|
+
rrf_score?: number | undefined;
|
|
1080
|
+
match_type?: string | undefined;
|
|
1081
|
+
status?: string | undefined;
|
|
1082
|
+
indications?: string | undefined;
|
|
1083
|
+
specialty?: string | undefined;
|
|
1084
|
+
component?: string | undefined;
|
|
1085
|
+
property?: string | undefined;
|
|
1086
|
+
time_aspect?: string | undefined;
|
|
1087
|
+
system?: string | undefined;
|
|
1088
|
+
scale_type?: string | undefined;
|
|
1089
|
+
method_type?: string | undefined;
|
|
1090
|
+
class?: string | undefined;
|
|
1091
|
+
class_type?: number | undefined;
|
|
1092
|
+
order_obs?: string | undefined;
|
|
1093
|
+
long_common_name?: string | undefined;
|
|
1094
|
+
short_name?: string | undefined;
|
|
1095
|
+
display_name?: string | undefined;
|
|
1096
|
+
consumer_name?: string | undefined;
|
|
1097
|
+
common_test_rank?: number | undefined;
|
|
1098
|
+
common_order_rank?: number | undefined;
|
|
1099
|
+
clinical_phrases?: string | undefined;
|
|
1100
|
+
documentation_keywords?: string | undefined;
|
|
1101
|
+
interpretation_guidance?: string | undefined;
|
|
1102
|
+
related_tests?: string | undefined;
|
|
1103
|
+
specimen_requirements?: string | undefined;
|
|
1104
|
+
test_category?: string | undefined;
|
|
1105
|
+
body_system?: string | undefined;
|
|
1106
|
+
mapped_to?: string | undefined;
|
|
1107
|
+
}, {
|
|
1108
|
+
loinc_num: string;
|
|
1109
|
+
similarity?: number | undefined;
|
|
1110
|
+
rrf_score?: number | undefined;
|
|
1111
|
+
match_type?: string | undefined;
|
|
1112
|
+
status?: string | undefined;
|
|
1113
|
+
indications?: string | undefined;
|
|
1114
|
+
specialty?: string | undefined;
|
|
1115
|
+
component?: string | undefined;
|
|
1116
|
+
property?: string | undefined;
|
|
1117
|
+
time_aspect?: string | undefined;
|
|
1118
|
+
system?: string | undefined;
|
|
1119
|
+
scale_type?: string | undefined;
|
|
1120
|
+
method_type?: string | undefined;
|
|
1121
|
+
class?: string | undefined;
|
|
1122
|
+
class_type?: number | undefined;
|
|
1123
|
+
order_obs?: string | undefined;
|
|
1124
|
+
long_common_name?: string | undefined;
|
|
1125
|
+
short_name?: string | undefined;
|
|
1126
|
+
display_name?: string | undefined;
|
|
1127
|
+
consumer_name?: string | undefined;
|
|
1128
|
+
common_test_rank?: number | undefined;
|
|
1129
|
+
common_order_rank?: number | undefined;
|
|
1130
|
+
clinical_phrases?: string | undefined;
|
|
1131
|
+
documentation_keywords?: string | undefined;
|
|
1132
|
+
interpretation_guidance?: string | undefined;
|
|
1133
|
+
related_tests?: string | undefined;
|
|
1134
|
+
specimen_requirements?: string | undefined;
|
|
1135
|
+
test_category?: string | undefined;
|
|
1136
|
+
body_system?: string | undefined;
|
|
1137
|
+
mapped_to?: string | undefined;
|
|
1138
|
+
}>;
|
|
1139
|
+
/** Panel member */
|
|
1140
|
+
declare const PanelMemberSchema: z.ZodObject<{
|
|
1141
|
+
member_loinc: z.ZodString;
|
|
1142
|
+
member_name: z.ZodOptional<z.ZodString>;
|
|
1143
|
+
sequence: z.ZodOptional<z.ZodNumber>;
|
|
1144
|
+
observation_required: z.ZodOptional<z.ZodString>;
|
|
1145
|
+
component: z.ZodOptional<z.ZodString>;
|
|
1146
|
+
long_common_name: z.ZodOptional<z.ZodString>;
|
|
1147
|
+
class: z.ZodOptional<z.ZodString>;
|
|
1148
|
+
}, "strip", z.ZodTypeAny, {
|
|
1149
|
+
member_loinc: string;
|
|
1150
|
+
component?: string | undefined;
|
|
1151
|
+
class?: string | undefined;
|
|
1152
|
+
long_common_name?: string | undefined;
|
|
1153
|
+
member_name?: string | undefined;
|
|
1154
|
+
sequence?: number | undefined;
|
|
1155
|
+
observation_required?: string | undefined;
|
|
1156
|
+
}, {
|
|
1157
|
+
member_loinc: string;
|
|
1158
|
+
component?: string | undefined;
|
|
1159
|
+
class?: string | undefined;
|
|
1160
|
+
long_common_name?: string | undefined;
|
|
1161
|
+
member_name?: string | undefined;
|
|
1162
|
+
sequence?: number | undefined;
|
|
1163
|
+
observation_required?: string | undefined;
|
|
1164
|
+
}>;
|
|
1165
|
+
/** Panel info */
|
|
1166
|
+
declare const PanelInfoSchema: z.ZodObject<{
|
|
1167
|
+
panel_loinc: z.ZodString;
|
|
1168
|
+
panel_name: z.ZodOptional<z.ZodString>;
|
|
1169
|
+
member_count: z.ZodOptional<z.ZodNumber>;
|
|
1170
|
+
members: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
1171
|
+
member_loinc: z.ZodString;
|
|
1172
|
+
member_name: z.ZodOptional<z.ZodString>;
|
|
1173
|
+
sequence: z.ZodOptional<z.ZodNumber>;
|
|
1174
|
+
observation_required: z.ZodOptional<z.ZodString>;
|
|
1175
|
+
component: z.ZodOptional<z.ZodString>;
|
|
1176
|
+
long_common_name: z.ZodOptional<z.ZodString>;
|
|
1177
|
+
class: z.ZodOptional<z.ZodString>;
|
|
1178
|
+
}, "strip", z.ZodTypeAny, {
|
|
1179
|
+
member_loinc: string;
|
|
1180
|
+
component?: string | undefined;
|
|
1181
|
+
class?: string | undefined;
|
|
1182
|
+
long_common_name?: string | undefined;
|
|
1183
|
+
member_name?: string | undefined;
|
|
1184
|
+
sequence?: number | undefined;
|
|
1185
|
+
observation_required?: string | undefined;
|
|
1186
|
+
}, {
|
|
1187
|
+
member_loinc: string;
|
|
1188
|
+
component?: string | undefined;
|
|
1189
|
+
class?: string | undefined;
|
|
1190
|
+
long_common_name?: string | undefined;
|
|
1191
|
+
member_name?: string | undefined;
|
|
1192
|
+
sequence?: number | undefined;
|
|
1193
|
+
observation_required?: string | undefined;
|
|
1194
|
+
}>, "many">>;
|
|
1195
|
+
}, "strip", z.ZodTypeAny, {
|
|
1196
|
+
panel_loinc: string;
|
|
1197
|
+
panel_name?: string | undefined;
|
|
1198
|
+
member_count?: number | undefined;
|
|
1199
|
+
members?: {
|
|
1200
|
+
member_loinc: string;
|
|
1201
|
+
component?: string | undefined;
|
|
1202
|
+
class?: string | undefined;
|
|
1203
|
+
long_common_name?: string | undefined;
|
|
1204
|
+
member_name?: string | undefined;
|
|
1205
|
+
sequence?: number | undefined;
|
|
1206
|
+
observation_required?: string | undefined;
|
|
1207
|
+
}[] | undefined;
|
|
1208
|
+
}, {
|
|
1209
|
+
panel_loinc: string;
|
|
1210
|
+
panel_name?: string | undefined;
|
|
1211
|
+
member_count?: number | undefined;
|
|
1212
|
+
members?: {
|
|
1213
|
+
member_loinc: string;
|
|
1214
|
+
component?: string | undefined;
|
|
1215
|
+
class?: string | undefined;
|
|
1216
|
+
long_common_name?: string | undefined;
|
|
1217
|
+
member_name?: string | undefined;
|
|
1218
|
+
sequence?: number | undefined;
|
|
1219
|
+
observation_required?: string | undefined;
|
|
1220
|
+
}[] | undefined;
|
|
1221
|
+
}>;
|
|
1222
|
+
/** search_loinc_hybrid output */
|
|
1223
|
+
declare const SearchLoincHybridOutputSchema: z.ZodObject<{
|
|
1224
|
+
query: z.ZodString;
|
|
1225
|
+
mode: z.ZodString;
|
|
1226
|
+
count: z.ZodNumber;
|
|
1227
|
+
results: z.ZodArray<z.ZodObject<{
|
|
1228
|
+
loinc_num: z.ZodString;
|
|
1229
|
+
component: z.ZodOptional<z.ZodString>;
|
|
1230
|
+
property: z.ZodOptional<z.ZodString>;
|
|
1231
|
+
time_aspect: z.ZodOptional<z.ZodString>;
|
|
1232
|
+
system: z.ZodOptional<z.ZodString>;
|
|
1233
|
+
scale_type: z.ZodOptional<z.ZodString>;
|
|
1234
|
+
method_type: z.ZodOptional<z.ZodString>;
|
|
1235
|
+
class: z.ZodOptional<z.ZodString>;
|
|
1236
|
+
class_type: z.ZodOptional<z.ZodNumber>;
|
|
1237
|
+
order_obs: z.ZodOptional<z.ZodString>;
|
|
1238
|
+
long_common_name: z.ZodOptional<z.ZodString>;
|
|
1239
|
+
short_name: z.ZodOptional<z.ZodString>;
|
|
1240
|
+
display_name: z.ZodOptional<z.ZodString>;
|
|
1241
|
+
consumer_name: z.ZodOptional<z.ZodString>;
|
|
1242
|
+
common_test_rank: z.ZodOptional<z.ZodNumber>;
|
|
1243
|
+
common_order_rank: z.ZodOptional<z.ZodNumber>;
|
|
1244
|
+
indications: z.ZodOptional<z.ZodString>;
|
|
1245
|
+
clinical_phrases: z.ZodOptional<z.ZodString>;
|
|
1246
|
+
documentation_keywords: z.ZodOptional<z.ZodString>;
|
|
1247
|
+
interpretation_guidance: z.ZodOptional<z.ZodString>;
|
|
1248
|
+
related_tests: z.ZodOptional<z.ZodString>;
|
|
1249
|
+
specimen_requirements: z.ZodOptional<z.ZodString>;
|
|
1250
|
+
test_category: z.ZodOptional<z.ZodString>;
|
|
1251
|
+
body_system: z.ZodOptional<z.ZodString>;
|
|
1252
|
+
specialty: z.ZodOptional<z.ZodString>;
|
|
1253
|
+
mapped_to: z.ZodOptional<z.ZodString>;
|
|
1254
|
+
status: z.ZodOptional<z.ZodString>;
|
|
1255
|
+
similarity: z.ZodOptional<z.ZodNumber>;
|
|
1256
|
+
rrf_score: z.ZodOptional<z.ZodNumber>;
|
|
1257
|
+
match_type: z.ZodOptional<z.ZodString>;
|
|
1258
|
+
}, "strip", z.ZodTypeAny, {
|
|
1259
|
+
loinc_num: string;
|
|
1260
|
+
similarity?: number | undefined;
|
|
1261
|
+
rrf_score?: number | undefined;
|
|
1262
|
+
match_type?: string | undefined;
|
|
1263
|
+
status?: string | undefined;
|
|
1264
|
+
indications?: string | undefined;
|
|
1265
|
+
specialty?: string | undefined;
|
|
1266
|
+
component?: string | undefined;
|
|
1267
|
+
property?: string | undefined;
|
|
1268
|
+
time_aspect?: string | undefined;
|
|
1269
|
+
system?: string | undefined;
|
|
1270
|
+
scale_type?: string | undefined;
|
|
1271
|
+
method_type?: string | undefined;
|
|
1272
|
+
class?: string | undefined;
|
|
1273
|
+
class_type?: number | undefined;
|
|
1274
|
+
order_obs?: string | undefined;
|
|
1275
|
+
long_common_name?: string | undefined;
|
|
1276
|
+
short_name?: string | undefined;
|
|
1277
|
+
display_name?: string | undefined;
|
|
1278
|
+
consumer_name?: string | undefined;
|
|
1279
|
+
common_test_rank?: number | undefined;
|
|
1280
|
+
common_order_rank?: number | undefined;
|
|
1281
|
+
clinical_phrases?: string | undefined;
|
|
1282
|
+
documentation_keywords?: string | undefined;
|
|
1283
|
+
interpretation_guidance?: string | undefined;
|
|
1284
|
+
related_tests?: string | undefined;
|
|
1285
|
+
specimen_requirements?: string | undefined;
|
|
1286
|
+
test_category?: string | undefined;
|
|
1287
|
+
body_system?: string | undefined;
|
|
1288
|
+
mapped_to?: string | undefined;
|
|
1289
|
+
}, {
|
|
1290
|
+
loinc_num: string;
|
|
1291
|
+
similarity?: number | undefined;
|
|
1292
|
+
rrf_score?: number | undefined;
|
|
1293
|
+
match_type?: string | undefined;
|
|
1294
|
+
status?: string | undefined;
|
|
1295
|
+
indications?: string | undefined;
|
|
1296
|
+
specialty?: string | undefined;
|
|
1297
|
+
component?: string | undefined;
|
|
1298
|
+
property?: string | undefined;
|
|
1299
|
+
time_aspect?: string | undefined;
|
|
1300
|
+
system?: string | undefined;
|
|
1301
|
+
scale_type?: string | undefined;
|
|
1302
|
+
method_type?: string | undefined;
|
|
1303
|
+
class?: string | undefined;
|
|
1304
|
+
class_type?: number | undefined;
|
|
1305
|
+
order_obs?: string | undefined;
|
|
1306
|
+
long_common_name?: string | undefined;
|
|
1307
|
+
short_name?: string | undefined;
|
|
1308
|
+
display_name?: string | undefined;
|
|
1309
|
+
consumer_name?: string | undefined;
|
|
1310
|
+
common_test_rank?: number | undefined;
|
|
1311
|
+
common_order_rank?: number | undefined;
|
|
1312
|
+
clinical_phrases?: string | undefined;
|
|
1313
|
+
documentation_keywords?: string | undefined;
|
|
1314
|
+
interpretation_guidance?: string | undefined;
|
|
1315
|
+
related_tests?: string | undefined;
|
|
1316
|
+
specimen_requirements?: string | undefined;
|
|
1317
|
+
test_category?: string | undefined;
|
|
1318
|
+
body_system?: string | undefined;
|
|
1319
|
+
mapped_to?: string | undefined;
|
|
1320
|
+
}>, "many">;
|
|
1321
|
+
warning: z.ZodOptional<z.ZodString>;
|
|
1322
|
+
}, "strip", z.ZodTypeAny, {
|
|
1323
|
+
query: string;
|
|
1324
|
+
count: number;
|
|
1325
|
+
results: {
|
|
1326
|
+
loinc_num: string;
|
|
1327
|
+
similarity?: number | undefined;
|
|
1328
|
+
rrf_score?: number | undefined;
|
|
1329
|
+
match_type?: string | undefined;
|
|
1330
|
+
status?: string | undefined;
|
|
1331
|
+
indications?: string | undefined;
|
|
1332
|
+
specialty?: string | undefined;
|
|
1333
|
+
component?: string | undefined;
|
|
1334
|
+
property?: string | undefined;
|
|
1335
|
+
time_aspect?: string | undefined;
|
|
1336
|
+
system?: string | undefined;
|
|
1337
|
+
scale_type?: string | undefined;
|
|
1338
|
+
method_type?: string | undefined;
|
|
1339
|
+
class?: string | undefined;
|
|
1340
|
+
class_type?: number | undefined;
|
|
1341
|
+
order_obs?: string | undefined;
|
|
1342
|
+
long_common_name?: string | undefined;
|
|
1343
|
+
short_name?: string | undefined;
|
|
1344
|
+
display_name?: string | undefined;
|
|
1345
|
+
consumer_name?: string | undefined;
|
|
1346
|
+
common_test_rank?: number | undefined;
|
|
1347
|
+
common_order_rank?: number | undefined;
|
|
1348
|
+
clinical_phrases?: string | undefined;
|
|
1349
|
+
documentation_keywords?: string | undefined;
|
|
1350
|
+
interpretation_guidance?: string | undefined;
|
|
1351
|
+
related_tests?: string | undefined;
|
|
1352
|
+
specimen_requirements?: string | undefined;
|
|
1353
|
+
test_category?: string | undefined;
|
|
1354
|
+
body_system?: string | undefined;
|
|
1355
|
+
mapped_to?: string | undefined;
|
|
1356
|
+
}[];
|
|
1357
|
+
mode: string;
|
|
1358
|
+
warning?: string | undefined;
|
|
1359
|
+
}, {
|
|
1360
|
+
query: string;
|
|
1361
|
+
count: number;
|
|
1362
|
+
results: {
|
|
1363
|
+
loinc_num: string;
|
|
1364
|
+
similarity?: number | undefined;
|
|
1365
|
+
rrf_score?: number | undefined;
|
|
1366
|
+
match_type?: string | undefined;
|
|
1367
|
+
status?: string | undefined;
|
|
1368
|
+
indications?: string | undefined;
|
|
1369
|
+
specialty?: string | undefined;
|
|
1370
|
+
component?: string | undefined;
|
|
1371
|
+
property?: string | undefined;
|
|
1372
|
+
time_aspect?: string | undefined;
|
|
1373
|
+
system?: string | undefined;
|
|
1374
|
+
scale_type?: string | undefined;
|
|
1375
|
+
method_type?: string | undefined;
|
|
1376
|
+
class?: string | undefined;
|
|
1377
|
+
class_type?: number | undefined;
|
|
1378
|
+
order_obs?: string | undefined;
|
|
1379
|
+
long_common_name?: string | undefined;
|
|
1380
|
+
short_name?: string | undefined;
|
|
1381
|
+
display_name?: string | undefined;
|
|
1382
|
+
consumer_name?: string | undefined;
|
|
1383
|
+
common_test_rank?: number | undefined;
|
|
1384
|
+
common_order_rank?: number | undefined;
|
|
1385
|
+
clinical_phrases?: string | undefined;
|
|
1386
|
+
documentation_keywords?: string | undefined;
|
|
1387
|
+
interpretation_guidance?: string | undefined;
|
|
1388
|
+
related_tests?: string | undefined;
|
|
1389
|
+
specimen_requirements?: string | undefined;
|
|
1390
|
+
test_category?: string | undefined;
|
|
1391
|
+
body_system?: string | undefined;
|
|
1392
|
+
mapped_to?: string | undefined;
|
|
1393
|
+
}[];
|
|
1394
|
+
mode: string;
|
|
1395
|
+
warning?: string | undefined;
|
|
1396
|
+
}>;
|
|
1397
|
+
/** get_loinc output */
|
|
1398
|
+
declare const GetLoincOutputSchema: z.ZodObject<{
|
|
1399
|
+
loinc_num: z.ZodString;
|
|
1400
|
+
found: z.ZodBoolean;
|
|
1401
|
+
result: z.ZodOptional<z.ZodObject<{
|
|
1402
|
+
loinc_num: z.ZodString;
|
|
1403
|
+
component: z.ZodOptional<z.ZodString>;
|
|
1404
|
+
property: z.ZodOptional<z.ZodString>;
|
|
1405
|
+
time_aspect: z.ZodOptional<z.ZodString>;
|
|
1406
|
+
system: z.ZodOptional<z.ZodString>;
|
|
1407
|
+
scale_type: z.ZodOptional<z.ZodString>;
|
|
1408
|
+
method_type: z.ZodOptional<z.ZodString>;
|
|
1409
|
+
class: z.ZodOptional<z.ZodString>;
|
|
1410
|
+
class_type: z.ZodOptional<z.ZodNumber>;
|
|
1411
|
+
order_obs: z.ZodOptional<z.ZodString>;
|
|
1412
|
+
long_common_name: z.ZodOptional<z.ZodString>;
|
|
1413
|
+
short_name: z.ZodOptional<z.ZodString>;
|
|
1414
|
+
display_name: z.ZodOptional<z.ZodString>;
|
|
1415
|
+
consumer_name: z.ZodOptional<z.ZodString>;
|
|
1416
|
+
common_test_rank: z.ZodOptional<z.ZodNumber>;
|
|
1417
|
+
common_order_rank: z.ZodOptional<z.ZodNumber>;
|
|
1418
|
+
indications: z.ZodOptional<z.ZodString>;
|
|
1419
|
+
clinical_phrases: z.ZodOptional<z.ZodString>;
|
|
1420
|
+
documentation_keywords: z.ZodOptional<z.ZodString>;
|
|
1421
|
+
interpretation_guidance: z.ZodOptional<z.ZodString>;
|
|
1422
|
+
related_tests: z.ZodOptional<z.ZodString>;
|
|
1423
|
+
specimen_requirements: z.ZodOptional<z.ZodString>;
|
|
1424
|
+
test_category: z.ZodOptional<z.ZodString>;
|
|
1425
|
+
body_system: z.ZodOptional<z.ZodString>;
|
|
1426
|
+
specialty: z.ZodOptional<z.ZodString>;
|
|
1427
|
+
mapped_to: z.ZodOptional<z.ZodString>;
|
|
1428
|
+
status: z.ZodOptional<z.ZodString>;
|
|
1429
|
+
similarity: z.ZodOptional<z.ZodNumber>;
|
|
1430
|
+
rrf_score: z.ZodOptional<z.ZodNumber>;
|
|
1431
|
+
match_type: z.ZodOptional<z.ZodString>;
|
|
1432
|
+
}, "strip", z.ZodTypeAny, {
|
|
1433
|
+
loinc_num: string;
|
|
1434
|
+
similarity?: number | undefined;
|
|
1435
|
+
rrf_score?: number | undefined;
|
|
1436
|
+
match_type?: string | undefined;
|
|
1437
|
+
status?: string | undefined;
|
|
1438
|
+
indications?: string | undefined;
|
|
1439
|
+
specialty?: string | undefined;
|
|
1440
|
+
component?: string | undefined;
|
|
1441
|
+
property?: string | undefined;
|
|
1442
|
+
time_aspect?: string | undefined;
|
|
1443
|
+
system?: string | undefined;
|
|
1444
|
+
scale_type?: string | undefined;
|
|
1445
|
+
method_type?: string | undefined;
|
|
1446
|
+
class?: string | undefined;
|
|
1447
|
+
class_type?: number | undefined;
|
|
1448
|
+
order_obs?: string | undefined;
|
|
1449
|
+
long_common_name?: string | undefined;
|
|
1450
|
+
short_name?: string | undefined;
|
|
1451
|
+
display_name?: string | undefined;
|
|
1452
|
+
consumer_name?: string | undefined;
|
|
1453
|
+
common_test_rank?: number | undefined;
|
|
1454
|
+
common_order_rank?: number | undefined;
|
|
1455
|
+
clinical_phrases?: string | undefined;
|
|
1456
|
+
documentation_keywords?: string | undefined;
|
|
1457
|
+
interpretation_guidance?: string | undefined;
|
|
1458
|
+
related_tests?: string | undefined;
|
|
1459
|
+
specimen_requirements?: string | undefined;
|
|
1460
|
+
test_category?: string | undefined;
|
|
1461
|
+
body_system?: string | undefined;
|
|
1462
|
+
mapped_to?: string | undefined;
|
|
1463
|
+
}, {
|
|
1464
|
+
loinc_num: string;
|
|
1465
|
+
similarity?: number | undefined;
|
|
1466
|
+
rrf_score?: number | undefined;
|
|
1467
|
+
match_type?: string | undefined;
|
|
1468
|
+
status?: string | undefined;
|
|
1469
|
+
indications?: string | undefined;
|
|
1470
|
+
specialty?: string | undefined;
|
|
1471
|
+
component?: string | undefined;
|
|
1472
|
+
property?: string | undefined;
|
|
1473
|
+
time_aspect?: string | undefined;
|
|
1474
|
+
system?: string | undefined;
|
|
1475
|
+
scale_type?: string | undefined;
|
|
1476
|
+
method_type?: string | undefined;
|
|
1477
|
+
class?: string | undefined;
|
|
1478
|
+
class_type?: number | undefined;
|
|
1479
|
+
order_obs?: string | undefined;
|
|
1480
|
+
long_common_name?: string | undefined;
|
|
1481
|
+
short_name?: string | undefined;
|
|
1482
|
+
display_name?: string | undefined;
|
|
1483
|
+
consumer_name?: string | undefined;
|
|
1484
|
+
common_test_rank?: number | undefined;
|
|
1485
|
+
common_order_rank?: number | undefined;
|
|
1486
|
+
clinical_phrases?: string | undefined;
|
|
1487
|
+
documentation_keywords?: string | undefined;
|
|
1488
|
+
interpretation_guidance?: string | undefined;
|
|
1489
|
+
related_tests?: string | undefined;
|
|
1490
|
+
specimen_requirements?: string | undefined;
|
|
1491
|
+
test_category?: string | undefined;
|
|
1492
|
+
body_system?: string | undefined;
|
|
1493
|
+
mapped_to?: string | undefined;
|
|
1494
|
+
}>>;
|
|
1495
|
+
}, "strip", z.ZodTypeAny, {
|
|
1496
|
+
found: boolean;
|
|
1497
|
+
loinc_num: string;
|
|
1498
|
+
result?: {
|
|
1499
|
+
loinc_num: string;
|
|
1500
|
+
similarity?: number | undefined;
|
|
1501
|
+
rrf_score?: number | undefined;
|
|
1502
|
+
match_type?: string | undefined;
|
|
1503
|
+
status?: string | undefined;
|
|
1504
|
+
indications?: string | undefined;
|
|
1505
|
+
specialty?: string | undefined;
|
|
1506
|
+
component?: string | undefined;
|
|
1507
|
+
property?: string | undefined;
|
|
1508
|
+
time_aspect?: string | undefined;
|
|
1509
|
+
system?: string | undefined;
|
|
1510
|
+
scale_type?: string | undefined;
|
|
1511
|
+
method_type?: string | undefined;
|
|
1512
|
+
class?: string | undefined;
|
|
1513
|
+
class_type?: number | undefined;
|
|
1514
|
+
order_obs?: string | undefined;
|
|
1515
|
+
long_common_name?: string | undefined;
|
|
1516
|
+
short_name?: string | undefined;
|
|
1517
|
+
display_name?: string | undefined;
|
|
1518
|
+
consumer_name?: string | undefined;
|
|
1519
|
+
common_test_rank?: number | undefined;
|
|
1520
|
+
common_order_rank?: number | undefined;
|
|
1521
|
+
clinical_phrases?: string | undefined;
|
|
1522
|
+
documentation_keywords?: string | undefined;
|
|
1523
|
+
interpretation_guidance?: string | undefined;
|
|
1524
|
+
related_tests?: string | undefined;
|
|
1525
|
+
specimen_requirements?: string | undefined;
|
|
1526
|
+
test_category?: string | undefined;
|
|
1527
|
+
body_system?: string | undefined;
|
|
1528
|
+
mapped_to?: string | undefined;
|
|
1529
|
+
} | undefined;
|
|
1530
|
+
}, {
|
|
1531
|
+
found: boolean;
|
|
1532
|
+
loinc_num: string;
|
|
1533
|
+
result?: {
|
|
1534
|
+
loinc_num: string;
|
|
1535
|
+
similarity?: number | undefined;
|
|
1536
|
+
rrf_score?: number | undefined;
|
|
1537
|
+
match_type?: string | undefined;
|
|
1538
|
+
status?: string | undefined;
|
|
1539
|
+
indications?: string | undefined;
|
|
1540
|
+
specialty?: string | undefined;
|
|
1541
|
+
component?: string | undefined;
|
|
1542
|
+
property?: string | undefined;
|
|
1543
|
+
time_aspect?: string | undefined;
|
|
1544
|
+
system?: string | undefined;
|
|
1545
|
+
scale_type?: string | undefined;
|
|
1546
|
+
method_type?: string | undefined;
|
|
1547
|
+
class?: string | undefined;
|
|
1548
|
+
class_type?: number | undefined;
|
|
1549
|
+
order_obs?: string | undefined;
|
|
1550
|
+
long_common_name?: string | undefined;
|
|
1551
|
+
short_name?: string | undefined;
|
|
1552
|
+
display_name?: string | undefined;
|
|
1553
|
+
consumer_name?: string | undefined;
|
|
1554
|
+
common_test_rank?: number | undefined;
|
|
1555
|
+
common_order_rank?: number | undefined;
|
|
1556
|
+
clinical_phrases?: string | undefined;
|
|
1557
|
+
documentation_keywords?: string | undefined;
|
|
1558
|
+
interpretation_guidance?: string | undefined;
|
|
1559
|
+
related_tests?: string | undefined;
|
|
1560
|
+
specimen_requirements?: string | undefined;
|
|
1561
|
+
test_category?: string | undefined;
|
|
1562
|
+
body_system?: string | undefined;
|
|
1563
|
+
mapped_to?: string | undefined;
|
|
1564
|
+
} | undefined;
|
|
1565
|
+
}>;
|
|
1566
|
+
/** get_panel_members output */
|
|
1567
|
+
declare const GetPanelMembersOutputSchema: z.ZodObject<{
|
|
1568
|
+
panel_loinc: z.ZodString;
|
|
1569
|
+
count: z.ZodNumber;
|
|
1570
|
+
members: z.ZodArray<z.ZodObject<{
|
|
1571
|
+
member_loinc: z.ZodString;
|
|
1572
|
+
member_name: z.ZodOptional<z.ZodString>;
|
|
1573
|
+
sequence: z.ZodOptional<z.ZodNumber>;
|
|
1574
|
+
observation_required: z.ZodOptional<z.ZodString>;
|
|
1575
|
+
component: z.ZodOptional<z.ZodString>;
|
|
1576
|
+
long_common_name: z.ZodOptional<z.ZodString>;
|
|
1577
|
+
class: z.ZodOptional<z.ZodString>;
|
|
1578
|
+
}, "strip", z.ZodTypeAny, {
|
|
1579
|
+
member_loinc: string;
|
|
1580
|
+
component?: string | undefined;
|
|
1581
|
+
class?: string | undefined;
|
|
1582
|
+
long_common_name?: string | undefined;
|
|
1583
|
+
member_name?: string | undefined;
|
|
1584
|
+
sequence?: number | undefined;
|
|
1585
|
+
observation_required?: string | undefined;
|
|
1586
|
+
}, {
|
|
1587
|
+
member_loinc: string;
|
|
1588
|
+
component?: string | undefined;
|
|
1589
|
+
class?: string | undefined;
|
|
1590
|
+
long_common_name?: string | undefined;
|
|
1591
|
+
member_name?: string | undefined;
|
|
1592
|
+
sequence?: number | undefined;
|
|
1593
|
+
observation_required?: string | undefined;
|
|
1594
|
+
}>, "many">;
|
|
1595
|
+
}, "strip", z.ZodTypeAny, {
|
|
1596
|
+
count: number;
|
|
1597
|
+
panel_loinc: string;
|
|
1598
|
+
members: {
|
|
1599
|
+
member_loinc: string;
|
|
1600
|
+
component?: string | undefined;
|
|
1601
|
+
class?: string | undefined;
|
|
1602
|
+
long_common_name?: string | undefined;
|
|
1603
|
+
member_name?: string | undefined;
|
|
1604
|
+
sequence?: number | undefined;
|
|
1605
|
+
observation_required?: string | undefined;
|
|
1606
|
+
}[];
|
|
1607
|
+
}, {
|
|
1608
|
+
count: number;
|
|
1609
|
+
panel_loinc: string;
|
|
1610
|
+
members: {
|
|
1611
|
+
member_loinc: string;
|
|
1612
|
+
component?: string | undefined;
|
|
1613
|
+
class?: string | undefined;
|
|
1614
|
+
long_common_name?: string | undefined;
|
|
1615
|
+
member_name?: string | undefined;
|
|
1616
|
+
sequence?: number | undefined;
|
|
1617
|
+
observation_required?: string | undefined;
|
|
1618
|
+
}[];
|
|
1619
|
+
}>;
|
|
1620
|
+
type LoincCode = z.infer<typeof LoincCodeSchema>;
|
|
1621
|
+
type PanelMember = z.infer<typeof PanelMemberSchema>;
|
|
1622
|
+
type PanelInfo = z.infer<typeof PanelInfoSchema>;
|
|
1623
|
+
type LoincSearchOutput = z.infer<typeof SearchLoincHybridOutputSchema>;
|
|
1624
|
+
type LoincLookupOutput = z.infer<typeof GetLoincOutputSchema>;
|
|
1625
|
+
type LoincGetPanelMembersOutput = z.infer<typeof GetPanelMembersOutputSchema>;
|
|
1626
|
+
|
|
1627
|
+
/** RxNorm drug result */
|
|
1628
|
+
declare const RxnormDrugSchema: z.ZodObject<{
|
|
1629
|
+
rxcui: z.ZodString;
|
|
1630
|
+
name: z.ZodOptional<z.ZodString>;
|
|
1631
|
+
tty: z.ZodOptional<z.ZodString>;
|
|
1632
|
+
suppress: z.ZodOptional<z.ZodString>;
|
|
1633
|
+
language: z.ZodOptional<z.ZodString>;
|
|
1634
|
+
similarity: z.ZodOptional<z.ZodNumber>;
|
|
1635
|
+
}, "strip", z.ZodTypeAny, {
|
|
1636
|
+
rxcui: string;
|
|
1637
|
+
similarity?: number | undefined;
|
|
1638
|
+
name?: string | undefined;
|
|
1639
|
+
tty?: string | undefined;
|
|
1640
|
+
suppress?: string | undefined;
|
|
1641
|
+
language?: string | undefined;
|
|
1642
|
+
}, {
|
|
1643
|
+
rxcui: string;
|
|
1644
|
+
similarity?: number | undefined;
|
|
1645
|
+
name?: string | undefined;
|
|
1646
|
+
tty?: string | undefined;
|
|
1647
|
+
suppress?: string | undefined;
|
|
1648
|
+
language?: string | undefined;
|
|
1649
|
+
}>;
|
|
1650
|
+
/** NDC result */
|
|
1651
|
+
declare const NdcResultSchema: z.ZodObject<{
|
|
1652
|
+
ndc: z.ZodString;
|
|
1653
|
+
rxcui: z.ZodOptional<z.ZodString>;
|
|
1654
|
+
name: z.ZodOptional<z.ZodString>;
|
|
1655
|
+
tty: z.ZodOptional<z.ZodString>;
|
|
1656
|
+
status: z.ZodOptional<z.ZodString>;
|
|
1657
|
+
source: z.ZodOptional<z.ZodString>;
|
|
1658
|
+
}, "strip", z.ZodTypeAny, {
|
|
1659
|
+
ndc: string;
|
|
1660
|
+
status?: string | undefined;
|
|
1661
|
+
rxcui?: string | undefined;
|
|
1662
|
+
name?: string | undefined;
|
|
1663
|
+
tty?: string | undefined;
|
|
1664
|
+
source?: string | undefined;
|
|
1665
|
+
}, {
|
|
1666
|
+
ndc: string;
|
|
1667
|
+
status?: string | undefined;
|
|
1668
|
+
rxcui?: string | undefined;
|
|
1669
|
+
name?: string | undefined;
|
|
1670
|
+
tty?: string | undefined;
|
|
1671
|
+
source?: string | undefined;
|
|
1672
|
+
}>;
|
|
1673
|
+
/** search_drug output */
|
|
1674
|
+
declare const SearchDrugOutputSchema: z.ZodObject<{
|
|
1675
|
+
query: z.ZodString;
|
|
1676
|
+
count: z.ZodNumber;
|
|
1677
|
+
results: z.ZodArray<z.ZodObject<{
|
|
1678
|
+
rxcui: z.ZodString;
|
|
1679
|
+
name: z.ZodOptional<z.ZodString>;
|
|
1680
|
+
tty: z.ZodOptional<z.ZodString>;
|
|
1681
|
+
suppress: z.ZodOptional<z.ZodString>;
|
|
1682
|
+
language: z.ZodOptional<z.ZodString>;
|
|
1683
|
+
similarity: z.ZodOptional<z.ZodNumber>;
|
|
1684
|
+
}, "strip", z.ZodTypeAny, {
|
|
1685
|
+
rxcui: string;
|
|
1686
|
+
similarity?: number | undefined;
|
|
1687
|
+
name?: string | undefined;
|
|
1688
|
+
tty?: string | undefined;
|
|
1689
|
+
suppress?: string | undefined;
|
|
1690
|
+
language?: string | undefined;
|
|
1691
|
+
}, {
|
|
1692
|
+
rxcui: string;
|
|
1693
|
+
similarity?: number | undefined;
|
|
1694
|
+
name?: string | undefined;
|
|
1695
|
+
tty?: string | undefined;
|
|
1696
|
+
suppress?: string | undefined;
|
|
1697
|
+
language?: string | undefined;
|
|
1698
|
+
}>, "many">;
|
|
1699
|
+
search_mode: z.ZodLiteral<"text">;
|
|
1700
|
+
}, "strip", z.ZodTypeAny, {
|
|
1701
|
+
query: string;
|
|
1702
|
+
count: number;
|
|
1703
|
+
results: {
|
|
1704
|
+
rxcui: string;
|
|
1705
|
+
similarity?: number | undefined;
|
|
1706
|
+
name?: string | undefined;
|
|
1707
|
+
tty?: string | undefined;
|
|
1708
|
+
suppress?: string | undefined;
|
|
1709
|
+
language?: string | undefined;
|
|
1710
|
+
}[];
|
|
1711
|
+
search_mode: "text";
|
|
1712
|
+
}, {
|
|
1713
|
+
query: string;
|
|
1714
|
+
count: number;
|
|
1715
|
+
results: {
|
|
1716
|
+
rxcui: string;
|
|
1717
|
+
similarity?: number | undefined;
|
|
1718
|
+
name?: string | undefined;
|
|
1719
|
+
tty?: string | undefined;
|
|
1720
|
+
suppress?: string | undefined;
|
|
1721
|
+
language?: string | undefined;
|
|
1722
|
+
}[];
|
|
1723
|
+
search_mode: "text";
|
|
1724
|
+
}>;
|
|
1725
|
+
/** lookup_ndc output */
|
|
1726
|
+
declare const LookupNdcOutputSchema: z.ZodObject<{
|
|
1727
|
+
query: z.ZodString;
|
|
1728
|
+
count: z.ZodNumber;
|
|
1729
|
+
results: z.ZodArray<z.ZodObject<{
|
|
1730
|
+
ndc: z.ZodString;
|
|
1731
|
+
rxcui: z.ZodOptional<z.ZodString>;
|
|
1732
|
+
name: z.ZodOptional<z.ZodString>;
|
|
1733
|
+
tty: z.ZodOptional<z.ZodString>;
|
|
1734
|
+
status: z.ZodOptional<z.ZodString>;
|
|
1735
|
+
source: z.ZodOptional<z.ZodString>;
|
|
1736
|
+
}, "strip", z.ZodTypeAny, {
|
|
1737
|
+
ndc: string;
|
|
1738
|
+
status?: string | undefined;
|
|
1739
|
+
rxcui?: string | undefined;
|
|
1740
|
+
name?: string | undefined;
|
|
1741
|
+
tty?: string | undefined;
|
|
1742
|
+
source?: string | undefined;
|
|
1743
|
+
}, {
|
|
1744
|
+
ndc: string;
|
|
1745
|
+
status?: string | undefined;
|
|
1746
|
+
rxcui?: string | undefined;
|
|
1747
|
+
name?: string | undefined;
|
|
1748
|
+
tty?: string | undefined;
|
|
1749
|
+
source?: string | undefined;
|
|
1750
|
+
}>, "many">;
|
|
1751
|
+
}, "strip", z.ZodTypeAny, {
|
|
1752
|
+
query: string;
|
|
1753
|
+
count: number;
|
|
1754
|
+
results: {
|
|
1755
|
+
ndc: string;
|
|
1756
|
+
status?: string | undefined;
|
|
1757
|
+
rxcui?: string | undefined;
|
|
1758
|
+
name?: string | undefined;
|
|
1759
|
+
tty?: string | undefined;
|
|
1760
|
+
source?: string | undefined;
|
|
1761
|
+
}[];
|
|
1762
|
+
}, {
|
|
1763
|
+
query: string;
|
|
1764
|
+
count: number;
|
|
1765
|
+
results: {
|
|
1766
|
+
ndc: string;
|
|
1767
|
+
status?: string | undefined;
|
|
1768
|
+
rxcui?: string | undefined;
|
|
1769
|
+
name?: string | undefined;
|
|
1770
|
+
tty?: string | undefined;
|
|
1771
|
+
source?: string | undefined;
|
|
1772
|
+
}[];
|
|
1773
|
+
}>;
|
|
1774
|
+
/** lookup_rxcui output */
|
|
1775
|
+
declare const LookupRxcuiOutputSchema: z.ZodObject<{
|
|
1776
|
+
rxcui: z.ZodString;
|
|
1777
|
+
result: z.ZodNullable<z.ZodObject<{
|
|
1778
|
+
rxcui: z.ZodString;
|
|
1779
|
+
name: z.ZodOptional<z.ZodString>;
|
|
1780
|
+
tty: z.ZodOptional<z.ZodString>;
|
|
1781
|
+
suppress: z.ZodOptional<z.ZodString>;
|
|
1782
|
+
language: z.ZodOptional<z.ZodString>;
|
|
1783
|
+
similarity: z.ZodOptional<z.ZodNumber>;
|
|
1784
|
+
}, "strip", z.ZodTypeAny, {
|
|
1785
|
+
rxcui: string;
|
|
1786
|
+
similarity?: number | undefined;
|
|
1787
|
+
name?: string | undefined;
|
|
1788
|
+
tty?: string | undefined;
|
|
1789
|
+
suppress?: string | undefined;
|
|
1790
|
+
language?: string | undefined;
|
|
1791
|
+
}, {
|
|
1792
|
+
rxcui: string;
|
|
1793
|
+
similarity?: number | undefined;
|
|
1794
|
+
name?: string | undefined;
|
|
1795
|
+
tty?: string | undefined;
|
|
1796
|
+
suppress?: string | undefined;
|
|
1797
|
+
language?: string | undefined;
|
|
1798
|
+
}>>;
|
|
1799
|
+
}, "strip", z.ZodTypeAny, {
|
|
1800
|
+
result: {
|
|
1801
|
+
rxcui: string;
|
|
1802
|
+
similarity?: number | undefined;
|
|
1803
|
+
name?: string | undefined;
|
|
1804
|
+
tty?: string | undefined;
|
|
1805
|
+
suppress?: string | undefined;
|
|
1806
|
+
language?: string | undefined;
|
|
1807
|
+
} | null;
|
|
1808
|
+
rxcui: string;
|
|
1809
|
+
}, {
|
|
1810
|
+
result: {
|
|
1811
|
+
rxcui: string;
|
|
1812
|
+
similarity?: number | undefined;
|
|
1813
|
+
name?: string | undefined;
|
|
1814
|
+
tty?: string | undefined;
|
|
1815
|
+
suppress?: string | undefined;
|
|
1816
|
+
language?: string | undefined;
|
|
1817
|
+
} | null;
|
|
1818
|
+
rxcui: string;
|
|
1819
|
+
}>;
|
|
1820
|
+
/** get_ingredients output */
|
|
1821
|
+
declare const GetIngredientsOutputSchema: z.ZodObject<{
|
|
1822
|
+
rxcui: z.ZodString;
|
|
1823
|
+
count: z.ZodNumber;
|
|
1824
|
+
results: z.ZodArray<z.ZodObject<{
|
|
1825
|
+
rxcui: z.ZodString;
|
|
1826
|
+
name: z.ZodOptional<z.ZodString>;
|
|
1827
|
+
tty: z.ZodOptional<z.ZodString>;
|
|
1828
|
+
suppress: z.ZodOptional<z.ZodString>;
|
|
1829
|
+
language: z.ZodOptional<z.ZodString>;
|
|
1830
|
+
similarity: z.ZodOptional<z.ZodNumber>;
|
|
1831
|
+
}, "strip", z.ZodTypeAny, {
|
|
1832
|
+
rxcui: string;
|
|
1833
|
+
similarity?: number | undefined;
|
|
1834
|
+
name?: string | undefined;
|
|
1835
|
+
tty?: string | undefined;
|
|
1836
|
+
suppress?: string | undefined;
|
|
1837
|
+
language?: string | undefined;
|
|
1838
|
+
}, {
|
|
1839
|
+
rxcui: string;
|
|
1840
|
+
similarity?: number | undefined;
|
|
1841
|
+
name?: string | undefined;
|
|
1842
|
+
tty?: string | undefined;
|
|
1843
|
+
suppress?: string | undefined;
|
|
1844
|
+
language?: string | undefined;
|
|
1845
|
+
}>, "many">;
|
|
1846
|
+
}, "strip", z.ZodTypeAny, {
|
|
1847
|
+
count: number;
|
|
1848
|
+
results: {
|
|
1849
|
+
rxcui: string;
|
|
1850
|
+
similarity?: number | undefined;
|
|
1851
|
+
name?: string | undefined;
|
|
1852
|
+
tty?: string | undefined;
|
|
1853
|
+
suppress?: string | undefined;
|
|
1854
|
+
language?: string | undefined;
|
|
1855
|
+
}[];
|
|
1856
|
+
rxcui: string;
|
|
1857
|
+
}, {
|
|
1858
|
+
count: number;
|
|
1859
|
+
results: {
|
|
1860
|
+
rxcui: string;
|
|
1861
|
+
similarity?: number | undefined;
|
|
1862
|
+
name?: string | undefined;
|
|
1863
|
+
tty?: string | undefined;
|
|
1864
|
+
suppress?: string | undefined;
|
|
1865
|
+
language?: string | undefined;
|
|
1866
|
+
}[];
|
|
1867
|
+
rxcui: string;
|
|
1868
|
+
}>;
|
|
1869
|
+
type RxnormDrug = z.infer<typeof RxnormDrugSchema>;
|
|
1870
|
+
type NdcResult = z.infer<typeof NdcResultSchema>;
|
|
1871
|
+
type RxnormSearchOutput = z.infer<typeof SearchDrugOutputSchema>;
|
|
1872
|
+
type RxnormLookupNdcOutput = z.infer<typeof LookupNdcOutputSchema>;
|
|
1873
|
+
type RxnormLookupRxcuiOutput = z.infer<typeof LookupRxcuiOutputSchema>;
|
|
1874
|
+
type RxnormGetIngredientsOutput = z.infer<typeof GetIngredientsOutputSchema>;
|
|
1875
|
+
|
|
1876
|
+
/**
|
|
1877
|
+
* Simplified Public SDK Engine Categories
|
|
1878
|
+
*
|
|
1879
|
+
* Each coding system has:
|
|
1880
|
+
* - searchCode() - hybrid search
|
|
1881
|
+
* - identifyCode() - lookup by code
|
|
1882
|
+
* - Unique methods specific to that system
|
|
1883
|
+
*
|
|
1884
|
+
* All inputs are Zod objects (even single-parameter methods).
|
|
1885
|
+
*/
|
|
1886
|
+
|
|
1887
|
+
type RequestFunction$1 = <TResult>(path: string, params?: Record<string, unknown>, method?: "GET" | "POST") => Promise<TResult>;
|
|
1888
|
+
declare const SnomedSearchCodeInputSchema: z.ZodObject<{
|
|
1889
|
+
query: z.ZodString;
|
|
1890
|
+
limit: z.ZodOptional<z.ZodNumber>;
|
|
1891
|
+
}, "strip", z.ZodTypeAny, {
|
|
1892
|
+
query: string;
|
|
1893
|
+
limit?: number | undefined;
|
|
1894
|
+
}, {
|
|
1895
|
+
query: string;
|
|
1896
|
+
limit?: number | undefined;
|
|
1897
|
+
}>;
|
|
1898
|
+
declare const SnomedIdentifyCodeInputSchema: z.ZodObject<{
|
|
1899
|
+
code: z.ZodString;
|
|
1900
|
+
}, "strip", z.ZodTypeAny, {
|
|
1901
|
+
code: string;
|
|
1902
|
+
}, {
|
|
1903
|
+
code: string;
|
|
1904
|
+
}>;
|
|
1905
|
+
type SnomedSearchCodeInput = z.infer<typeof SnomedSearchCodeInputSchema>;
|
|
1906
|
+
type SnomedIdentifyCodeInput = z.infer<typeof SnomedIdentifyCodeInputSchema>;
|
|
1907
|
+
/**
|
|
1908
|
+
* SNOMED CT coding system.
|
|
1909
|
+
* - searchCode(): Hybrid search for SNOMED concepts
|
|
1910
|
+
* - identifyCode(): Lookup a specific SNOMED concept by code
|
|
1911
|
+
*/
|
|
1912
|
+
declare class SnomedCategory {
|
|
1913
|
+
private request;
|
|
1914
|
+
constructor(request: RequestFunction$1);
|
|
1915
|
+
searchCode(input: SnomedSearchCodeInput): Promise<SnomedSearchOutput>;
|
|
1916
|
+
identifyCode(input: SnomedIdentifyCodeInput): Promise<SnomedLookupOutput>;
|
|
1917
|
+
}
|
|
1918
|
+
declare const Icd10SearchCodeInputSchema: z.ZodObject<{
|
|
1919
|
+
query: z.ZodString;
|
|
1920
|
+
limit: z.ZodOptional<z.ZodNumber>;
|
|
1921
|
+
billingOnly: z.ZodOptional<z.ZodBoolean>;
|
|
1922
|
+
}, "strip", z.ZodTypeAny, {
|
|
1923
|
+
query: string;
|
|
1924
|
+
limit?: number | undefined;
|
|
1925
|
+
billingOnly?: boolean | undefined;
|
|
1926
|
+
}, {
|
|
1927
|
+
query: string;
|
|
1928
|
+
limit?: number | undefined;
|
|
1929
|
+
billingOnly?: boolean | undefined;
|
|
1930
|
+
}>;
|
|
1931
|
+
declare const Icd10IdentifyCodeInputSchema: z.ZodObject<{
|
|
1932
|
+
code: z.ZodString;
|
|
1933
|
+
}, "strip", z.ZodTypeAny, {
|
|
1934
|
+
code: string;
|
|
1935
|
+
}, {
|
|
1936
|
+
code: string;
|
|
1937
|
+
}>;
|
|
1938
|
+
type Icd10SearchCodeInput = z.infer<typeof Icd10SearchCodeInputSchema>;
|
|
1939
|
+
type Icd10IdentifyCodeInput = z.infer<typeof Icd10IdentifyCodeInputSchema>;
|
|
1940
|
+
/**
|
|
1941
|
+
* ICD-10 diagnosis coding system.
|
|
1942
|
+
* - searchCode(): Hybrid search for ICD-10 codes
|
|
1943
|
+
* - identifyCode(): Lookup a specific ICD-10 code
|
|
1944
|
+
* - getChapters(): Get all ICD-10 chapters
|
|
1945
|
+
*/
|
|
1946
|
+
declare class Icd10Category {
|
|
1947
|
+
private request;
|
|
1948
|
+
constructor(request: RequestFunction$1);
|
|
1949
|
+
searchCode(input: Icd10SearchCodeInput): Promise<Icd10SearchOutput>;
|
|
1950
|
+
identifyCode(input: Icd10IdentifyCodeInput): Promise<Icd10LookupOutput>;
|
|
1951
|
+
getChapters(): Promise<Icd10GetChaptersOutput>;
|
|
1952
|
+
}
|
|
1953
|
+
declare const CptSearchCodeInputSchema: z.ZodObject<{
|
|
1954
|
+
query: z.ZodString;
|
|
1955
|
+
limit: z.ZodOptional<z.ZodNumber>;
|
|
1956
|
+
}, "strip", z.ZodTypeAny, {
|
|
1957
|
+
query: string;
|
|
1958
|
+
limit?: number | undefined;
|
|
1959
|
+
}, {
|
|
1960
|
+
query: string;
|
|
1961
|
+
limit?: number | undefined;
|
|
1962
|
+
}>;
|
|
1963
|
+
declare const CptIdentifyCodeInputSchema: z.ZodObject<{
|
|
1964
|
+
code: z.ZodString;
|
|
1965
|
+
}, "strip", z.ZodTypeAny, {
|
|
1966
|
+
code: string;
|
|
1967
|
+
}, {
|
|
1968
|
+
code: string;
|
|
1969
|
+
}>;
|
|
1970
|
+
declare const CptGetCostInputSchema: z.ZodObject<{
|
|
1971
|
+
code: z.ZodString;
|
|
1972
|
+
}, "strip", z.ZodTypeAny, {
|
|
1973
|
+
code: string;
|
|
1974
|
+
}, {
|
|
1975
|
+
code: string;
|
|
1976
|
+
}>;
|
|
1977
|
+
declare const CptLinkIcd10InputSchema: z.ZodObject<{
|
|
1978
|
+
code: z.ZodString;
|
|
1979
|
+
}, "strip", z.ZodTypeAny, {
|
|
1980
|
+
code: string;
|
|
1981
|
+
}, {
|
|
1982
|
+
code: string;
|
|
1983
|
+
}>;
|
|
1984
|
+
type CptSearchCodeInput = z.infer<typeof CptSearchCodeInputSchema>;
|
|
1985
|
+
type CptIdentifyCodeInput = z.infer<typeof CptIdentifyCodeInputSchema>;
|
|
1986
|
+
type CptGetCostInput = z.infer<typeof CptGetCostInputSchema>;
|
|
1987
|
+
type CptLinkIcd10Input = z.infer<typeof CptLinkIcd10InputSchema>;
|
|
1988
|
+
/**
|
|
1989
|
+
* CPT procedure coding system.
|
|
1990
|
+
* - searchCode(): Hybrid search for CPT codes
|
|
1991
|
+
* - identifyCode(): Lookup a specific CPT code
|
|
1992
|
+
* - getCost(): Get RVU/cost data for a CPT code
|
|
1993
|
+
* - linkIcd10(): Get ICD-10 linking terms for a CPT code
|
|
1994
|
+
*/
|
|
1995
|
+
declare class CptCategory {
|
|
1996
|
+
private request;
|
|
1997
|
+
constructor(request: RequestFunction$1);
|
|
1998
|
+
searchCode(input: CptSearchCodeInput): Promise<CptSearchOutput>;
|
|
1999
|
+
identifyCode(input: CptIdentifyCodeInput): Promise<CptGetCodeOutput>;
|
|
2000
|
+
getCost(input: CptGetCostInput): Promise<CptGetCostOutput>;
|
|
2001
|
+
linkIcd10(input: CptLinkIcd10Input): Promise<CptLinkIcd10Output>;
|
|
2002
|
+
}
|
|
2003
|
+
declare const HcpcsSearchCodeInputSchema: z.ZodObject<{
|
|
2004
|
+
query: z.ZodString;
|
|
2005
|
+
limit: z.ZodOptional<z.ZodNumber>;
|
|
2006
|
+
}, "strip", z.ZodTypeAny, {
|
|
2007
|
+
query: string;
|
|
2008
|
+
limit?: number | undefined;
|
|
2009
|
+
}, {
|
|
2010
|
+
query: string;
|
|
2011
|
+
limit?: number | undefined;
|
|
2012
|
+
}>;
|
|
2013
|
+
declare const HcpcsIdentifyCodeInputSchema: z.ZodObject<{
|
|
2014
|
+
code: z.ZodString;
|
|
2015
|
+
}, "strip", z.ZodTypeAny, {
|
|
2016
|
+
code: string;
|
|
2017
|
+
}, {
|
|
2018
|
+
code: string;
|
|
2019
|
+
}>;
|
|
2020
|
+
declare const HcpcsGetCostInputSchema: z.ZodObject<{
|
|
2021
|
+
code: z.ZodString;
|
|
2022
|
+
}, "strip", z.ZodTypeAny, {
|
|
2023
|
+
code: string;
|
|
2024
|
+
}, {
|
|
2025
|
+
code: string;
|
|
2026
|
+
}>;
|
|
2027
|
+
type HcpcsSearchCodeInput = z.infer<typeof HcpcsSearchCodeInputSchema>;
|
|
2028
|
+
type HcpcsIdentifyCodeInput = z.infer<typeof HcpcsIdentifyCodeInputSchema>;
|
|
2029
|
+
type HcpcsGetCostInput = z.infer<typeof HcpcsGetCostInputSchema>;
|
|
2030
|
+
/**
|
|
2031
|
+
* HCPCS procedure coding system.
|
|
2032
|
+
* - searchCode(): Hybrid search for HCPCS codes
|
|
2033
|
+
* - identifyCode(): Lookup a specific HCPCS code
|
|
2034
|
+
* - getCost(): Get RVU/cost data for an HCPCS code
|
|
2035
|
+
*/
|
|
2036
|
+
declare class HcpcsCategory {
|
|
2037
|
+
private request;
|
|
2038
|
+
constructor(request: RequestFunction$1);
|
|
2039
|
+
searchCode(input: HcpcsSearchCodeInput): Promise<CptSearchOutput>;
|
|
2040
|
+
identifyCode(input: HcpcsIdentifyCodeInput): Promise<CptGetCodeOutput>;
|
|
2041
|
+
getCost(input: HcpcsGetCostInput): Promise<CptGetCostOutput>;
|
|
2042
|
+
}
|
|
2043
|
+
declare const LoincSearchCodeInputSchema: z.ZodObject<{
|
|
2044
|
+
query: z.ZodString;
|
|
2045
|
+
limit: z.ZodOptional<z.ZodNumber>;
|
|
2046
|
+
}, "strip", z.ZodTypeAny, {
|
|
2047
|
+
query: string;
|
|
2048
|
+
limit?: number | undefined;
|
|
2049
|
+
}, {
|
|
2050
|
+
query: string;
|
|
2051
|
+
limit?: number | undefined;
|
|
2052
|
+
}>;
|
|
2053
|
+
declare const LoincIdentifyCodeInputSchema: z.ZodObject<{
|
|
2054
|
+
code: z.ZodString;
|
|
2055
|
+
}, "strip", z.ZodTypeAny, {
|
|
2056
|
+
code: string;
|
|
2057
|
+
}, {
|
|
2058
|
+
code: string;
|
|
2059
|
+
}>;
|
|
2060
|
+
declare const LoincGetPanelMembersInputSchema: z.ZodObject<{
|
|
2061
|
+
code: z.ZodString;
|
|
2062
|
+
}, "strip", z.ZodTypeAny, {
|
|
2063
|
+
code: string;
|
|
2064
|
+
}, {
|
|
2065
|
+
code: string;
|
|
2066
|
+
}>;
|
|
2067
|
+
type LoincSearchCodeInput = z.infer<typeof LoincSearchCodeInputSchema>;
|
|
2068
|
+
type LoincIdentifyCodeInput = z.infer<typeof LoincIdentifyCodeInputSchema>;
|
|
2069
|
+
type LoincGetPanelMembersInput = z.infer<typeof LoincGetPanelMembersInputSchema>;
|
|
2070
|
+
/**
|
|
2071
|
+
* LOINC laboratory test coding system.
|
|
2072
|
+
* - searchCode(): Hybrid search for LOINC codes
|
|
2073
|
+
* - identifyCode(): Lookup a specific LOINC code
|
|
2074
|
+
* - getPanelMembers(): Get all tests in a panel
|
|
2075
|
+
*/
|
|
2076
|
+
declare class LoincCategory {
|
|
2077
|
+
private request;
|
|
2078
|
+
constructor(request: RequestFunction$1);
|
|
2079
|
+
searchCode(input: LoincSearchCodeInput): Promise<LoincSearchOutput>;
|
|
2080
|
+
identifyCode(input: LoincIdentifyCodeInput): Promise<LoincLookupOutput>;
|
|
2081
|
+
getPanelMembers(input: LoincGetPanelMembersInput): Promise<LoincGetPanelMembersOutput>;
|
|
2082
|
+
}
|
|
2083
|
+
declare const RxnormSearchCodeInputSchema: z.ZodObject<{
|
|
2084
|
+
query: z.ZodString;
|
|
2085
|
+
limit: z.ZodOptional<z.ZodNumber>;
|
|
2086
|
+
}, "strip", z.ZodTypeAny, {
|
|
2087
|
+
query: string;
|
|
2088
|
+
limit?: number | undefined;
|
|
2089
|
+
}, {
|
|
2090
|
+
query: string;
|
|
2091
|
+
limit?: number | undefined;
|
|
2092
|
+
}>;
|
|
2093
|
+
declare const RxnormIdentifyCodeInputSchema: z.ZodObject<{
|
|
2094
|
+
type: z.ZodEnum<["ndc", "rxcui"]>;
|
|
2095
|
+
code: z.ZodString;
|
|
2096
|
+
}, "strip", z.ZodTypeAny, {
|
|
2097
|
+
code: string;
|
|
2098
|
+
type: "rxcui" | "ndc";
|
|
2099
|
+
}, {
|
|
2100
|
+
code: string;
|
|
2101
|
+
type: "rxcui" | "ndc";
|
|
2102
|
+
}>;
|
|
2103
|
+
declare const RxnormGetIngredientsInputSchema: z.ZodObject<{
|
|
2104
|
+
rxcui: z.ZodString;
|
|
2105
|
+
}, "strip", z.ZodTypeAny, {
|
|
2106
|
+
rxcui: string;
|
|
2107
|
+
}, {
|
|
2108
|
+
rxcui: string;
|
|
2109
|
+
}>;
|
|
2110
|
+
type RxnormSearchCodeInput = z.infer<typeof RxnormSearchCodeInputSchema>;
|
|
2111
|
+
type RxnormIdentifyCodeInput = z.infer<typeof RxnormIdentifyCodeInputSchema>;
|
|
2112
|
+
type RxnormGetIngredientsInput = z.infer<typeof RxnormGetIngredientsInputSchema>;
|
|
2113
|
+
/**
|
|
2114
|
+
* RxNorm drug/medication coding system.
|
|
2115
|
+
* - searchCode(): Search for drugs by name
|
|
2116
|
+
* - identifyCode({ type, code }): Lookup by NDC or RXCUI
|
|
2117
|
+
* - getIngredients(): Get active ingredients for a drug
|
|
2118
|
+
*/
|
|
2119
|
+
declare class RxnormCategory {
|
|
2120
|
+
private request;
|
|
2121
|
+
constructor(request: RequestFunction$1);
|
|
2122
|
+
searchCode(input: RxnormSearchCodeInput): Promise<RxnormSearchOutput>;
|
|
2123
|
+
identifyCode(input: RxnormIdentifyCodeInput): Promise<RxnormLookupNdcOutput | RxnormLookupRxcuiOutput>;
|
|
2124
|
+
getIngredients(input: RxnormGetIngredientsInput): Promise<RxnormGetIngredientsOutput>;
|
|
2125
|
+
}
|
|
2126
|
+
declare const LcdSearchGuidelinesInputSchema: z.ZodObject<{
|
|
2127
|
+
query: z.ZodString;
|
|
2128
|
+
limit: z.ZodOptional<z.ZodNumber>;
|
|
2129
|
+
}, "strip", z.ZodTypeAny, {
|
|
2130
|
+
query: string;
|
|
2131
|
+
limit?: number | undefined;
|
|
2132
|
+
}, {
|
|
2133
|
+
query: string;
|
|
2134
|
+
limit?: number | undefined;
|
|
2135
|
+
}>;
|
|
2136
|
+
declare const LcdIdentifyGuidelineInputSchema: z.ZodObject<{
|
|
2137
|
+
id: z.ZodString;
|
|
2138
|
+
}, "strip", z.ZodTypeAny, {
|
|
2139
|
+
id: string;
|
|
2140
|
+
}, {
|
|
2141
|
+
id: string;
|
|
2142
|
+
}>;
|
|
2143
|
+
type LcdSearchGuidelinesInput = z.infer<typeof LcdSearchGuidelinesInputSchema>;
|
|
2144
|
+
type LcdIdentifyGuidelineInput = z.infer<typeof LcdIdentifyGuidelineInputSchema>;
|
|
2145
|
+
/**
|
|
2146
|
+
* LCD (Local Coverage Determination) guidelines.
|
|
2147
|
+
* - searchGuidelines(): Search LCD guidelines by text
|
|
2148
|
+
* - identifyGuideline(): Lookup a specific LCD by ID
|
|
2149
|
+
*/
|
|
2150
|
+
declare class LcdCategory {
|
|
2151
|
+
private request;
|
|
2152
|
+
constructor(request: RequestFunction$1);
|
|
2153
|
+
searchGuidelines(input: LcdSearchGuidelinesInput): Promise<LcdSearchOutput>;
|
|
2154
|
+
identifyGuideline(input: LcdIdentifyGuidelineInput): Promise<LcdGetOutput>;
|
|
2155
|
+
}
|
|
2156
|
+
declare const NcdSearchGuidelinesInputSchema: z.ZodObject<{
|
|
2157
|
+
query: z.ZodString;
|
|
2158
|
+
limit: z.ZodOptional<z.ZodNumber>;
|
|
2159
|
+
}, "strip", z.ZodTypeAny, {
|
|
2160
|
+
query: string;
|
|
2161
|
+
limit?: number | undefined;
|
|
2162
|
+
}, {
|
|
2163
|
+
query: string;
|
|
2164
|
+
limit?: number | undefined;
|
|
2165
|
+
}>;
|
|
2166
|
+
declare const NcdIdentifyGuidelineInputSchema: z.ZodEffects<z.ZodObject<{
|
|
2167
|
+
id: z.ZodOptional<z.ZodString>;
|
|
2168
|
+
section: z.ZodOptional<z.ZodString>;
|
|
2169
|
+
}, "strip", z.ZodTypeAny, {
|
|
2170
|
+
section?: string | undefined;
|
|
2171
|
+
id?: string | undefined;
|
|
2172
|
+
}, {
|
|
2173
|
+
section?: string | undefined;
|
|
2174
|
+
id?: string | undefined;
|
|
2175
|
+
}>, {
|
|
2176
|
+
section?: string | undefined;
|
|
2177
|
+
id?: string | undefined;
|
|
2178
|
+
}, {
|
|
2179
|
+
section?: string | undefined;
|
|
2180
|
+
id?: string | undefined;
|
|
2181
|
+
}>;
|
|
2182
|
+
type NcdSearchGuidelinesInput = z.infer<typeof NcdSearchGuidelinesInputSchema>;
|
|
2183
|
+
type NcdIdentifyGuidelineInput = z.infer<typeof NcdIdentifyGuidelineInputSchema>;
|
|
2184
|
+
/**
|
|
2185
|
+
* NCD (National Coverage Determination) guidelines.
|
|
2186
|
+
* - searchGuidelines(): Search NCD guidelines by text
|
|
2187
|
+
* - identifyGuideline(): Lookup a specific NCD by ID or section
|
|
2188
|
+
*/
|
|
2189
|
+
declare class NcdCategory {
|
|
2190
|
+
private request;
|
|
2191
|
+
constructor(request: RequestFunction$1);
|
|
2192
|
+
searchGuidelines(input: NcdSearchGuidelinesInput): Promise<NcdSearchOutput>;
|
|
2193
|
+
identifyGuideline(input: NcdIdentifyGuidelineInput): Promise<NcdGetOutput>;
|
|
2194
|
+
}
|
|
2195
|
+
|
|
2196
|
+
declare const DiagnosisToProceduresInputSchema: z.ZodObject<{
|
|
2197
|
+
snomed_id: z.ZodOptional<z.ZodString>;
|
|
2198
|
+
icd10_code: z.ZodOptional<z.ZodString>;
|
|
2199
|
+
query: z.ZodOptional<z.ZodString>;
|
|
2200
|
+
}, "strip", z.ZodTypeAny, {
|
|
2201
|
+
icd10_code?: string | undefined;
|
|
2202
|
+
query?: string | undefined;
|
|
2203
|
+
snomed_id?: string | undefined;
|
|
2204
|
+
}, {
|
|
2205
|
+
icd10_code?: string | undefined;
|
|
2206
|
+
query?: string | undefined;
|
|
2207
|
+
snomed_id?: string | undefined;
|
|
2208
|
+
}>;
|
|
2209
|
+
declare const CoverageCheckInputSchema: z.ZodObject<{
|
|
2210
|
+
cpt_code: z.ZodString;
|
|
2211
|
+
icd10_code: z.ZodOptional<z.ZodString>;
|
|
2212
|
+
}, "strip", z.ZodTypeAny, {
|
|
2213
|
+
cpt_code: string;
|
|
2214
|
+
icd10_code?: string | undefined;
|
|
2215
|
+
}, {
|
|
2216
|
+
cpt_code: string;
|
|
2217
|
+
icd10_code?: string | undefined;
|
|
2218
|
+
}>;
|
|
2219
|
+
/** diagnosis_to_procedures output */
|
|
2220
|
+
declare const DiagnosisToProceduresOutputSchema: z.ZodObject<{
|
|
2221
|
+
snomed_id: z.ZodOptional<z.ZodString>;
|
|
2222
|
+
icd10_code: z.ZodOptional<z.ZodString>;
|
|
2223
|
+
icd10_mappings: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">>;
|
|
2224
|
+
procedures: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">>;
|
|
2225
|
+
}, "strip", z.ZodTypeAny, {
|
|
2226
|
+
icd10_code?: string | undefined;
|
|
2227
|
+
snomed_id?: string | undefined;
|
|
2228
|
+
icd10_mappings?: Record<string, unknown>[] | undefined;
|
|
2229
|
+
procedures?: Record<string, unknown>[] | undefined;
|
|
2230
|
+
}, {
|
|
2231
|
+
icd10_code?: string | undefined;
|
|
2232
|
+
snomed_id?: string | undefined;
|
|
2233
|
+
icd10_mappings?: Record<string, unknown>[] | undefined;
|
|
2234
|
+
procedures?: Record<string, unknown>[] | undefined;
|
|
2235
|
+
}>;
|
|
2236
|
+
/** coverage_check output */
|
|
2237
|
+
declare const CoverageCheckOutputSchema: z.ZodObject<{
|
|
2238
|
+
cpt_code: z.ZodString;
|
|
2239
|
+
icd10_code: z.ZodOptional<z.ZodString>;
|
|
2240
|
+
lcd: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
2241
|
+
has_guidelines: z.ZodBoolean;
|
|
2242
|
+
diagnosis_covered: z.ZodOptional<z.ZodBoolean>;
|
|
2243
|
+
}, "strip", z.ZodTypeAny, {
|
|
2244
|
+
cpt_code: string;
|
|
2245
|
+
has_guidelines: boolean;
|
|
2246
|
+
icd10_code?: string | undefined;
|
|
2247
|
+
lcd?: Record<string, unknown> | undefined;
|
|
2248
|
+
diagnosis_covered?: boolean | undefined;
|
|
2249
|
+
}, {
|
|
2250
|
+
cpt_code: string;
|
|
2251
|
+
has_guidelines: boolean;
|
|
2252
|
+
icd10_code?: string | undefined;
|
|
2253
|
+
lcd?: Record<string, unknown> | undefined;
|
|
2254
|
+
diagnosis_covered?: boolean | undefined;
|
|
2255
|
+
}>;
|
|
2256
|
+
/** get_categories output */
|
|
2257
|
+
declare const GetCategoriesOutputSchema: z.ZodObject<{
|
|
2258
|
+
snomed_semantic_tags: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
2259
|
+
icd10_chapters: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">>;
|
|
2260
|
+
cpt_categories: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">>;
|
|
2261
|
+
}, "strip", z.ZodTypeAny, {
|
|
2262
|
+
snomed_semantic_tags?: Record<string, unknown> | undefined;
|
|
2263
|
+
icd10_chapters?: Record<string, unknown>[] | undefined;
|
|
2264
|
+
cpt_categories?: Record<string, unknown>[] | undefined;
|
|
2265
|
+
}, {
|
|
2266
|
+
snomed_semantic_tags?: Record<string, unknown> | undefined;
|
|
2267
|
+
icd10_chapters?: Record<string, unknown>[] | undefined;
|
|
2268
|
+
cpt_categories?: Record<string, unknown>[] | undefined;
|
|
2269
|
+
}>;
|
|
2270
|
+
type DiagnosisToProceduresInput = z.infer<typeof DiagnosisToProceduresInputSchema>;
|
|
2271
|
+
type DiagnosisToProceduresOutput = z.infer<typeof DiagnosisToProceduresOutputSchema>;
|
|
2272
|
+
type CoverageCheckInput = z.infer<typeof CoverageCheckInputSchema>;
|
|
2273
|
+
type CoverageCheckOutput = z.infer<typeof CoverageCheckOutputSchema>;
|
|
2274
|
+
type GetCategoriesOutput = z.infer<typeof GetCategoriesOutputSchema>;
|
|
2275
|
+
|
|
2276
|
+
declare const GetResultInputSchema: z.ZodObject<{
|
|
2277
|
+
request_id: z.ZodString;
|
|
2278
|
+
}, "strip", z.ZodTypeAny, {
|
|
2279
|
+
request_id: string;
|
|
2280
|
+
}, {
|
|
2281
|
+
request_id: string;
|
|
2282
|
+
}>;
|
|
2283
|
+
/** get_result output */
|
|
2284
|
+
declare const GetResultOutputSchema: z.ZodObject<{
|
|
2285
|
+
request_id: z.ZodString;
|
|
2286
|
+
status: z.ZodEnum<["pending", "running", "completed", "failed"]>;
|
|
2287
|
+
query: z.ZodOptional<z.ZodString>;
|
|
2288
|
+
result: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
2289
|
+
error: z.ZodOptional<z.ZodString>;
|
|
2290
|
+
}, "strip", z.ZodTypeAny, {
|
|
2291
|
+
status: "pending" | "running" | "completed" | "failed";
|
|
2292
|
+
request_id: string;
|
|
2293
|
+
query?: string | undefined;
|
|
2294
|
+
result?: Record<string, unknown> | undefined;
|
|
2295
|
+
error?: string | undefined;
|
|
2296
|
+
}, {
|
|
2297
|
+
status: "pending" | "running" | "completed" | "failed";
|
|
2298
|
+
request_id: string;
|
|
2299
|
+
query?: string | undefined;
|
|
2300
|
+
result?: Record<string, unknown> | undefined;
|
|
2301
|
+
error?: string | undefined;
|
|
2302
|
+
}>;
|
|
2303
|
+
/** Engine status record */
|
|
2304
|
+
declare const EngineStatusSchema: z.ZodRecord<z.ZodString, z.ZodEnum<["ok", "error", "unknown"]>>;
|
|
2305
|
+
/** health output */
|
|
2306
|
+
declare const HealthOutputSchema: z.ZodObject<{
|
|
2307
|
+
status: z.ZodEnum<["ok", "degraded"]>;
|
|
2308
|
+
version: z.ZodOptional<z.ZodString>;
|
|
2309
|
+
environment: z.ZodOptional<z.ZodString>;
|
|
2310
|
+
engines: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<["ok", "error", "unknown"]>>>;
|
|
2311
|
+
}, "strip", z.ZodTypeAny, {
|
|
2312
|
+
status: "ok" | "degraded";
|
|
2313
|
+
version?: string | undefined;
|
|
2314
|
+
environment?: string | undefined;
|
|
2315
|
+
engines?: Record<string, "unknown" | "error" | "ok"> | undefined;
|
|
2316
|
+
}, {
|
|
2317
|
+
status: "ok" | "degraded";
|
|
2318
|
+
version?: string | undefined;
|
|
2319
|
+
environment?: string | undefined;
|
|
2320
|
+
engines?: Record<string, "unknown" | "error" | "ok"> | undefined;
|
|
2321
|
+
}>;
|
|
2322
|
+
type GetResultInput = z.infer<typeof GetResultInputSchema>;
|
|
2323
|
+
type GetResultOutput = z.infer<typeof GetResultOutputSchema>;
|
|
2324
|
+
type EngineStatus = z.infer<typeof EngineStatusSchema>;
|
|
2325
|
+
type HealthOutput = z.infer<typeof HealthOutputSchema>;
|
|
2326
|
+
|
|
2327
|
+
type RequestFunction = <TResult>(path: string, params?: Record<string, unknown>, method?: "GET" | "POST") => Promise<TResult>;
|
|
2328
|
+
/**
|
|
2329
|
+
* Clinical orchestrator - cross-engine operations
|
|
2330
|
+
* - checkCoverage(): Check LCD coverage for CPT + ICD-10 pair
|
|
2331
|
+
* - getProceduresForDiagnosis(): Map diagnosis to relevant procedures
|
|
2332
|
+
* - getMetadata(): Get metadata from all engines
|
|
2333
|
+
*/
|
|
2334
|
+
declare class ClinicalCategory {
|
|
2335
|
+
private request;
|
|
2336
|
+
constructor(request: RequestFunction);
|
|
2337
|
+
/** Check LCD coverage for a CPT code + optional ICD-10 pair */
|
|
2338
|
+
checkCoverage(input: CoverageCheckInput): Promise<CoverageCheckOutput>;
|
|
2339
|
+
/** Map a diagnosis (SNOMED or ICD-10) to relevant procedures */
|
|
2340
|
+
getProceduresForDiagnosis(input: DiagnosisToProceduresInput): Promise<DiagnosisToProceduresOutput>;
|
|
2341
|
+
/** Get metadata/categories from all engines (semantic tags, chapters, etc.) */
|
|
2342
|
+
getMetadata(): Promise<GetCategoriesOutput>;
|
|
2343
|
+
}
|
|
2344
|
+
/** System actions: get async result, health check */
|
|
2345
|
+
declare class SystemCategory {
|
|
2346
|
+
private request;
|
|
2347
|
+
constructor(request: RequestFunction);
|
|
2348
|
+
/** Get async request result by ID */
|
|
2349
|
+
getResult(input: GetResultInput): Promise<GetResultOutput>;
|
|
2350
|
+
/** Health check all engines */
|
|
2351
|
+
health(): Promise<HealthOutput>;
|
|
2352
|
+
}
|
|
2353
|
+
/**
|
|
2354
|
+
* Public TypeScript client for the Sequoia Medical Codes API.
|
|
2355
|
+
* Provides fully-typed access to all API endpoints via category namespaces.
|
|
2356
|
+
*
|
|
2357
|
+
* @example
|
|
2358
|
+
* ```typescript
|
|
2359
|
+
* const client = new SequoiaCodesClient({
|
|
2360
|
+
* apiKey: process.env.SEQUOIA_CODES_API_KEY!,
|
|
2361
|
+
* });
|
|
2362
|
+
*
|
|
2363
|
+
* // Coding system searches
|
|
2364
|
+
* const icd10 = await client.icd10.searchCode({ query: "diabetes" });
|
|
2365
|
+
* const cpt = await client.cpt.searchCode({ query: "surgery" });
|
|
2366
|
+
* const snomed = await client.snomed.identifyCode({ code: "73211009" });
|
|
2367
|
+
*
|
|
2368
|
+
* // Guideline searches
|
|
2369
|
+
* const lcd = await client.lcd.searchGuidelines({ query: "MRI" });
|
|
2370
|
+
* const ncd = await client.ncd.identifyGuideline({ section: "220.6" });
|
|
2371
|
+
*
|
|
2372
|
+
* // Orchestrator endpoints
|
|
2373
|
+
* const coverage = await client.clinical.checkCoverage({ cpt_code: "99213" });
|
|
2374
|
+
* const procedures = await client.clinical.getProceduresForDiagnosis({ icd10_code: "E11.9" });
|
|
2375
|
+
* ```
|
|
2376
|
+
*/
|
|
2377
|
+
declare class SequoiaCodesClient {
|
|
2378
|
+
private apiKey;
|
|
2379
|
+
private baseUrl;
|
|
2380
|
+
private version;
|
|
2381
|
+
/** Clinical orchestrator: coverage check, diagnosis-to-procedures, metadata */
|
|
2382
|
+
readonly clinical: ClinicalCategory;
|
|
2383
|
+
/** System actions: get async result, health check */
|
|
2384
|
+
readonly system: SystemCategory;
|
|
2385
|
+
/** SNOMED CT coding system */
|
|
2386
|
+
readonly snomed: SnomedCategory;
|
|
2387
|
+
/** ICD-10 diagnosis codes */
|
|
2388
|
+
readonly icd10: Icd10Category;
|
|
2389
|
+
/** CPT procedure codes */
|
|
2390
|
+
readonly cpt: CptCategory;
|
|
2391
|
+
/** HCPCS procedure codes */
|
|
2392
|
+
readonly hcpcs: HcpcsCategory;
|
|
2393
|
+
/** LOINC laboratory test codes */
|
|
2394
|
+
readonly loinc: LoincCategory;
|
|
2395
|
+
/** RxNorm drug/medication codes */
|
|
2396
|
+
readonly rxnorm: RxnormCategory;
|
|
2397
|
+
/** LCD (Local Coverage Determination) guidelines */
|
|
2398
|
+
readonly lcd: LcdCategory;
|
|
2399
|
+
/** NCD (National Coverage Determination) guidelines */
|
|
2400
|
+
readonly ncd: NcdCategory;
|
|
2401
|
+
constructor(config: SequoiaCodesClientConfig);
|
|
2402
|
+
/**
|
|
2403
|
+
* Make an HTTP request to the Codes API Gateway.
|
|
2404
|
+
*/
|
|
2405
|
+
private request;
|
|
2406
|
+
}
|
|
2407
|
+
|
|
2408
|
+
/**
|
|
2409
|
+
* Error class for Codes API errors
|
|
2410
|
+
*/
|
|
2411
|
+
declare class CodesApiError extends Error {
|
|
2412
|
+
status: number;
|
|
2413
|
+
action?: string | undefined;
|
|
2414
|
+
constructor(status: number, message: string, action?: string | undefined);
|
|
2415
|
+
toJSON(): {
|
|
2416
|
+
name: string;
|
|
2417
|
+
status: number;
|
|
2418
|
+
message: string;
|
|
2419
|
+
action: string | undefined;
|
|
2420
|
+
};
|
|
2421
|
+
}
|
|
2422
|
+
|
|
2423
|
+
export { type ApiResponse, type CPTCode, CodesApiError, type CoverageCheckInput, type CoverageCheckOutput, CptCategory, type CptGetCodeOutput, type CptGetCostInput, type CptGetCostOutput, type CptIdentifyCodeInput, type CptLinkIcd10Input, type CptLinkIcd10Output, type CptSearchCodeInput, type CptSearchOutput, type DiagnosisToProceduresInput, type DiagnosisToProceduresOutput, type EngineStatus, type GetCategoriesOutput, type GetResultInput, type GetResultOutput, HcpcsCategory, type HcpcsGetCostInput, type HcpcsIdentifyCodeInput, type HcpcsSearchCodeInput, type HealthOutput, Icd10Category, type Icd10Chapter, type Icd10Code, type Icd10GetChaptersOutput, type Icd10IdentifyCodeInput, type Icd10LookupOutput, type Icd10Mapping, type Icd10SearchCodeInput, type Icd10SearchOutput, LcdCategory, type LcdGetOutput, type LcdIdentifyGuidelineInput, type LcdSearchGuidelinesInput, type LcdSearchOutput, LoincCategory, type LoincCode, type LoincGetPanelMembersInput, type LoincGetPanelMembersOutput, type LoincIdentifyCodeInput, type LoincLookupOutput, type LoincSearchCodeInput, type LoincSearchOutput, NcdCategory, type NcdGetOutput, type NcdIdentifyGuidelineInput, type NcdSearchGuidelinesInput, type NcdSearchOutput, type NdcResult, type PanelInfo, type PanelMember, RxnormCategory, type RxnormDrug, type RxnormGetIngredientsInput, type RxnormGetIngredientsOutput, type RxnormIdentifyCodeInput, type RxnormLookupNdcOutput, type RxnormLookupRxcuiOutput, type RxnormSearchCodeInput, type RxnormSearchOutput, SequoiaCodesClient, type SequoiaCodesClientConfig, SnomedCategory, type SnomedConcept, type SnomedIdentifyCodeInput, type SnomedLookupOutput, type SnomedRelationship, type SnomedSearchCodeInput, type SnomedSearchOutput };
|