UNPKG

42.3 kBTypeScriptView Raw
1import {Request} from '../lib/request';
2import {Response} from '../lib/response';
3import {AWSError} from '../lib/error';
4import {Service} from '../lib/service';
5import {ServiceConfigurationOptions} from '../lib/service';
6import {ConfigBase as Config} from '../lib/config';
7interface Blob {}
8declare class ComprehendMedical extends Service {
9 /**
10 * Constructs a service object. This object has one method for each API operation.
11 */
12 constructor(options?: ComprehendMedical.Types.ClientConfiguration)
13 config: Config & ComprehendMedical.Types.ClientConfiguration;
14 /**
15 * Gets the properties associated with a medical entities detection job. Use this operation to get the status of a detection job.
16 */
17 describeEntitiesDetectionV2Job(params: ComprehendMedical.Types.DescribeEntitiesDetectionV2JobRequest, callback?: (err: AWSError, data: ComprehendMedical.Types.DescribeEntitiesDetectionV2JobResponse) => void): Request<ComprehendMedical.Types.DescribeEntitiesDetectionV2JobResponse, AWSError>;
18 /**
19 * Gets the properties associated with a medical entities detection job. Use this operation to get the status of a detection job.
20 */
21 describeEntitiesDetectionV2Job(callback?: (err: AWSError, data: ComprehendMedical.Types.DescribeEntitiesDetectionV2JobResponse) => void): Request<ComprehendMedical.Types.DescribeEntitiesDetectionV2JobResponse, AWSError>;
22 /**
23 * Gets the properties associated with a protected health information (PHI) detection job. Use this operation to get the status of a detection job.
24 */
25 describePHIDetectionJob(params: ComprehendMedical.Types.DescribePHIDetectionJobRequest, callback?: (err: AWSError, data: ComprehendMedical.Types.DescribePHIDetectionJobResponse) => void): Request<ComprehendMedical.Types.DescribePHIDetectionJobResponse, AWSError>;
26 /**
27 * Gets the properties associated with a protected health information (PHI) detection job. Use this operation to get the status of a detection job.
28 */
29 describePHIDetectionJob(callback?: (err: AWSError, data: ComprehendMedical.Types.DescribePHIDetectionJobResponse) => void): Request<ComprehendMedical.Types.DescribePHIDetectionJobResponse, AWSError>;
30 /**
31 * The DetectEntities operation is deprecated. You should use the DetectEntitiesV2 operation instead. Inspects the clinical text for a variety of medical entities and returns specific information about them such as entity category, location, and confidence score on that information .
32 */
33 detectEntities(params: ComprehendMedical.Types.DetectEntitiesRequest, callback?: (err: AWSError, data: ComprehendMedical.Types.DetectEntitiesResponse) => void): Request<ComprehendMedical.Types.DetectEntitiesResponse, AWSError>;
34 /**
35 * The DetectEntities operation is deprecated. You should use the DetectEntitiesV2 operation instead. Inspects the clinical text for a variety of medical entities and returns specific information about them such as entity category, location, and confidence score on that information .
36 */
37 detectEntities(callback?: (err: AWSError, data: ComprehendMedical.Types.DetectEntitiesResponse) => void): Request<ComprehendMedical.Types.DetectEntitiesResponse, AWSError>;
38 /**
39 * Inspects the clinical text for a variety of medical entities and returns specific information about them such as entity category, location, and confidence score on that information. Amazon Comprehend Medical only detects medical entities in English language texts. The DetectEntitiesV2 operation replaces the DetectEntities operation. This new action uses a different model for determining the entities in your medical text and changes the way that some entities are returned in the output. You should use the DetectEntitiesV2 operation in all new applications. The DetectEntitiesV2 operation returns the Acuity and Direction entities as attributes instead of types.
40 */
41 detectEntitiesV2(params: ComprehendMedical.Types.DetectEntitiesV2Request, callback?: (err: AWSError, data: ComprehendMedical.Types.DetectEntitiesV2Response) => void): Request<ComprehendMedical.Types.DetectEntitiesV2Response, AWSError>;
42 /**
43 * Inspects the clinical text for a variety of medical entities and returns specific information about them such as entity category, location, and confidence score on that information. Amazon Comprehend Medical only detects medical entities in English language texts. The DetectEntitiesV2 operation replaces the DetectEntities operation. This new action uses a different model for determining the entities in your medical text and changes the way that some entities are returned in the output. You should use the DetectEntitiesV2 operation in all new applications. The DetectEntitiesV2 operation returns the Acuity and Direction entities as attributes instead of types.
44 */
45 detectEntitiesV2(callback?: (err: AWSError, data: ComprehendMedical.Types.DetectEntitiesV2Response) => void): Request<ComprehendMedical.Types.DetectEntitiesV2Response, AWSError>;
46 /**
47 * Inspects the clinical text for protected health information (PHI) entities and returns the entity category, location, and confidence score for each entity. Amazon Comprehend Medical only detects entities in English language texts.
48 */
49 detectPHI(params: ComprehendMedical.Types.DetectPHIRequest, callback?: (err: AWSError, data: ComprehendMedical.Types.DetectPHIResponse) => void): Request<ComprehendMedical.Types.DetectPHIResponse, AWSError>;
50 /**
51 * Inspects the clinical text for protected health information (PHI) entities and returns the entity category, location, and confidence score for each entity. Amazon Comprehend Medical only detects entities in English language texts.
52 */
53 detectPHI(callback?: (err: AWSError, data: ComprehendMedical.Types.DetectPHIResponse) => void): Request<ComprehendMedical.Types.DetectPHIResponse, AWSError>;
54 /**
55 * InferICD10CM detects medical conditions as entities listed in a patient record and links those entities to normalized concept identifiers in the ICD-10-CM knowledge base from the Centers for Disease Control. Amazon Comprehend Medical only detects medical entities in English language texts.
56 */
57 inferICD10CM(params: ComprehendMedical.Types.InferICD10CMRequest, callback?: (err: AWSError, data: ComprehendMedical.Types.InferICD10CMResponse) => void): Request<ComprehendMedical.Types.InferICD10CMResponse, AWSError>;
58 /**
59 * InferICD10CM detects medical conditions as entities listed in a patient record and links those entities to normalized concept identifiers in the ICD-10-CM knowledge base from the Centers for Disease Control. Amazon Comprehend Medical only detects medical entities in English language texts.
60 */
61 inferICD10CM(callback?: (err: AWSError, data: ComprehendMedical.Types.InferICD10CMResponse) => void): Request<ComprehendMedical.Types.InferICD10CMResponse, AWSError>;
62 /**
63 * InferRxNorm detects medications as entities listed in a patient record and links to the normalized concept identifiers in the RxNorm database from the National Library of Medicine. Amazon Comprehend Medical only detects medical entities in English language texts.
64 */
65 inferRxNorm(params: ComprehendMedical.Types.InferRxNormRequest, callback?: (err: AWSError, data: ComprehendMedical.Types.InferRxNormResponse) => void): Request<ComprehendMedical.Types.InferRxNormResponse, AWSError>;
66 /**
67 * InferRxNorm detects medications as entities listed in a patient record and links to the normalized concept identifiers in the RxNorm database from the National Library of Medicine. Amazon Comprehend Medical only detects medical entities in English language texts.
68 */
69 inferRxNorm(callback?: (err: AWSError, data: ComprehendMedical.Types.InferRxNormResponse) => void): Request<ComprehendMedical.Types.InferRxNormResponse, AWSError>;
70 /**
71 * Gets a list of medical entity detection jobs that you have submitted.
72 */
73 listEntitiesDetectionV2Jobs(params: ComprehendMedical.Types.ListEntitiesDetectionV2JobsRequest, callback?: (err: AWSError, data: ComprehendMedical.Types.ListEntitiesDetectionV2JobsResponse) => void): Request<ComprehendMedical.Types.ListEntitiesDetectionV2JobsResponse, AWSError>;
74 /**
75 * Gets a list of medical entity detection jobs that you have submitted.
76 */
77 listEntitiesDetectionV2Jobs(callback?: (err: AWSError, data: ComprehendMedical.Types.ListEntitiesDetectionV2JobsResponse) => void): Request<ComprehendMedical.Types.ListEntitiesDetectionV2JobsResponse, AWSError>;
78 /**
79 * Gets a list of protected health information (PHI) detection jobs that you have submitted.
80 */
81 listPHIDetectionJobs(params: ComprehendMedical.Types.ListPHIDetectionJobsRequest, callback?: (err: AWSError, data: ComprehendMedical.Types.ListPHIDetectionJobsResponse) => void): Request<ComprehendMedical.Types.ListPHIDetectionJobsResponse, AWSError>;
82 /**
83 * Gets a list of protected health information (PHI) detection jobs that you have submitted.
84 */
85 listPHIDetectionJobs(callback?: (err: AWSError, data: ComprehendMedical.Types.ListPHIDetectionJobsResponse) => void): Request<ComprehendMedical.Types.ListPHIDetectionJobsResponse, AWSError>;
86 /**
87 * Starts an asynchronous medical entity detection job for a collection of documents. Use the DescribeEntitiesDetectionV2Job operation to track the status of a job.
88 */
89 startEntitiesDetectionV2Job(params: ComprehendMedical.Types.StartEntitiesDetectionV2JobRequest, callback?: (err: AWSError, data: ComprehendMedical.Types.StartEntitiesDetectionV2JobResponse) => void): Request<ComprehendMedical.Types.StartEntitiesDetectionV2JobResponse, AWSError>;
90 /**
91 * Starts an asynchronous medical entity detection job for a collection of documents. Use the DescribeEntitiesDetectionV2Job operation to track the status of a job.
92 */
93 startEntitiesDetectionV2Job(callback?: (err: AWSError, data: ComprehendMedical.Types.StartEntitiesDetectionV2JobResponse) => void): Request<ComprehendMedical.Types.StartEntitiesDetectionV2JobResponse, AWSError>;
94 /**
95 * Starts an asynchronous job to detect protected health information (PHI). Use the DescribePHIDetectionJob operation to track the status of a job.
96 */
97 startPHIDetectionJob(params: ComprehendMedical.Types.StartPHIDetectionJobRequest, callback?: (err: AWSError, data: ComprehendMedical.Types.StartPHIDetectionJobResponse) => void): Request<ComprehendMedical.Types.StartPHIDetectionJobResponse, AWSError>;
98 /**
99 * Starts an asynchronous job to detect protected health information (PHI). Use the DescribePHIDetectionJob operation to track the status of a job.
100 */
101 startPHIDetectionJob(callback?: (err: AWSError, data: ComprehendMedical.Types.StartPHIDetectionJobResponse) => void): Request<ComprehendMedical.Types.StartPHIDetectionJobResponse, AWSError>;
102 /**
103 * Stops a medical entities detection job in progress.
104 */
105 stopEntitiesDetectionV2Job(params: ComprehendMedical.Types.StopEntitiesDetectionV2JobRequest, callback?: (err: AWSError, data: ComprehendMedical.Types.StopEntitiesDetectionV2JobResponse) => void): Request<ComprehendMedical.Types.StopEntitiesDetectionV2JobResponse, AWSError>;
106 /**
107 * Stops a medical entities detection job in progress.
108 */
109 stopEntitiesDetectionV2Job(callback?: (err: AWSError, data: ComprehendMedical.Types.StopEntitiesDetectionV2JobResponse) => void): Request<ComprehendMedical.Types.StopEntitiesDetectionV2JobResponse, AWSError>;
110 /**
111 * Stops a protected health information (PHI) detection job in progress.
112 */
113 stopPHIDetectionJob(params: ComprehendMedical.Types.StopPHIDetectionJobRequest, callback?: (err: AWSError, data: ComprehendMedical.Types.StopPHIDetectionJobResponse) => void): Request<ComprehendMedical.Types.StopPHIDetectionJobResponse, AWSError>;
114 /**
115 * Stops a protected health information (PHI) detection job in progress.
116 */
117 stopPHIDetectionJob(callback?: (err: AWSError, data: ComprehendMedical.Types.StopPHIDetectionJobResponse) => void): Request<ComprehendMedical.Types.StopPHIDetectionJobResponse, AWSError>;
118}
119declare namespace ComprehendMedical {
120 export type AnyLengthString = string;
121 export interface Attribute {
122 /**
123 * The type of attribute.
124 */
125 Type?: EntitySubType;
126 /**
127 * The level of confidence that Amazon Comprehend Medical has that the segment of text is correctly recognized as an attribute.
128 */
129 Score?: Float;
130 /**
131 * The level of confidence that Amazon Comprehend Medical has that this attribute is correctly related to this entity.
132 */
133 RelationshipScore?: Float;
134 /**
135 * The type of relationship between the entity and attribute. Type for the relationship is OVERLAP, indicating that the entity occurred at the same time as the Date_Expression.
136 */
137 RelationshipType?: RelationshipType;
138 /**
139 * The numeric identifier for this attribute. This is a monotonically increasing id unique within this response rather than a global unique identifier.
140 */
141 Id?: Integer;
142 /**
143 * The 0-based character offset in the input text that shows where the attribute begins. The offset returns the UTF-8 code point in the string.
144 */
145 BeginOffset?: Integer;
146 /**
147 * The 0-based character offset in the input text that shows where the attribute ends. The offset returns the UTF-8 code point in the string.
148 */
149 EndOffset?: Integer;
150 /**
151 * The segment of input text extracted as this attribute.
152 */
153 Text?: String;
154 /**
155 * The category of attribute.
156 */
157 Category?: EntityType;
158 /**
159 * Contextual information for this attribute.
160 */
161 Traits?: TraitList;
162 }
163 export type AttributeList = Attribute[];
164 export type AttributeName = "SIGN"|"SYMPTOM"|"DIAGNOSIS"|"NEGATION"|string;
165 export type BoundedLengthString = string;
166 export type ClientRequestTokenString = string;
167 export interface ComprehendMedicalAsyncJobFilter {
168 /**
169 * Filters on the name of the job.
170 */
171 JobName?: JobName;
172 /**
173 * Filters the list of jobs based on job status. Returns only jobs with the specified status.
174 */
175 JobStatus?: JobStatus;
176 /**
177 * Filters the list of jobs based on the time that the job was submitted for processing. Returns only jobs submitted before the specified time. Jobs are returned in ascending order, oldest to newest.
178 */
179 SubmitTimeBefore?: Timestamp;
180 /**
181 * Filters the list of jobs based on the time that the job was submitted for processing. Returns only jobs submitted after the specified time. Jobs are returned in descending order, newest to oldest.
182 */
183 SubmitTimeAfter?: Timestamp;
184 }
185 export interface ComprehendMedicalAsyncJobProperties {
186 /**
187 * The identifier assigned to the detection job.
188 */
189 JobId?: JobId;
190 /**
191 * The name that you assigned to the detection job.
192 */
193 JobName?: JobName;
194 /**
195 * The current status of the detection job. If the status is FAILED, the Message field shows the reason for the failure.
196 */
197 JobStatus?: JobStatus;
198 /**
199 * A description of the status of a job.
200 */
201 Message?: AnyLengthString;
202 /**
203 * The time that the detection job was submitted for processing.
204 */
205 SubmitTime?: Timestamp;
206 /**
207 * The time that the detection job completed.
208 */
209 EndTime?: Timestamp;
210 /**
211 * The date and time that job metadata is deleted from the server. Output files in your S3 bucket will not be deleted. After the metadata is deleted, the job will no longer appear in the results of the ListEntitiesDetectionV2Job or the ListPHIDetectionJobs operation.
212 */
213 ExpirationTime?: Timestamp;
214 /**
215 * The input data configuration that you supplied when you created the detection job.
216 */
217 InputDataConfig?: InputDataConfig;
218 /**
219 * The output data configuration that you supplied when you created the detection job.
220 */
221 OutputDataConfig?: OutputDataConfig;
222 /**
223 * The language code of the input documents.
224 */
225 LanguageCode?: LanguageCode;
226 /**
227 * The Amazon Resource Name (ARN) that gives Amazon Comprehend Medical read access to your input data.
228 */
229 DataAccessRoleArn?: IamRoleArn;
230 /**
231 * The path to the file that describes the results of a batch job.
232 */
233 ManifestFilePath?: ManifestFilePath;
234 /**
235 * The AWS Key Management Service key, if any, used to encrypt the output files.
236 */
237 KMSKey?: KMSKey;
238 /**
239 * The version of the model used to analyze the documents. The version number looks like X.X.X. You can use this information to track the model used for a particular batch of documents.
240 */
241 ModelVersion?: ModelVersion;
242 }
243 export type ComprehendMedicalAsyncJobPropertiesList = ComprehendMedicalAsyncJobProperties[];
244 export interface DescribeEntitiesDetectionV2JobRequest {
245 /**
246 * The identifier that Amazon Comprehend Medical generated for the job. The StartEntitiesDetectionV2Job operation returns this identifier in its response.
247 */
248 JobId: JobId;
249 }
250 export interface DescribeEntitiesDetectionV2JobResponse {
251 /**
252 * An object that contains the properties associated with a detection job.
253 */
254 ComprehendMedicalAsyncJobProperties?: ComprehendMedicalAsyncJobProperties;
255 }
256 export interface DescribePHIDetectionJobRequest {
257 /**
258 * The identifier that Amazon Comprehend Medical generated for the job. The StartPHIDetectionJob operation returns this identifier in its response.
259 */
260 JobId: JobId;
261 }
262 export interface DescribePHIDetectionJobResponse {
263 /**
264 * An object that contains the properties associated with a detection job.
265 */
266 ComprehendMedicalAsyncJobProperties?: ComprehendMedicalAsyncJobProperties;
267 }
268 export interface DetectEntitiesRequest {
269 /**
270 * A UTF-8 text string containing the clinical content being examined for entities. Each string must contain fewer than 20,000 bytes of characters.
271 */
272 Text: BoundedLengthString;
273 }
274 export interface DetectEntitiesResponse {
275 /**
276 * The collection of medical entities extracted from the input text and their associated information. For each entity, the response provides the entity text, the entity category, where the entity text begins and ends, and the level of confidence that Amazon Comprehend Medical has in the detection and analysis. Attributes and traits of the entity are also returned.
277 */
278 Entities: EntityList;
279 /**
280 * Attributes extracted from the input text that we were unable to relate to an entity.
281 */
282 UnmappedAttributes?: UnmappedAttributeList;
283 /**
284 * If the result of the previous request to DetectEntities was truncated, include the PaginationToken to fetch the next page of entities.
285 */
286 PaginationToken?: String;
287 /**
288 * The version of the model used to analyze the documents. The version number looks like X.X.X. You can use this information to track the model used for a particular batch of documents.
289 */
290 ModelVersion: String;
291 }
292 export interface DetectEntitiesV2Request {
293 /**
294 * A UTF-8 string containing the clinical content being examined for entities. Each string must contain fewer than 20,000 bytes of characters.
295 */
296 Text: BoundedLengthString;
297 }
298 export interface DetectEntitiesV2Response {
299 /**
300 * The collection of medical entities extracted from the input text and their associated information. For each entity, the response provides the entity text, the entity category, where the entity text begins and ends, and the level of confidence in the detection and analysis. Attributes and traits of the entity are also returned.
301 */
302 Entities: EntityList;
303 /**
304 * Attributes extracted from the input text that couldn't be related to an entity.
305 */
306 UnmappedAttributes?: UnmappedAttributeList;
307 /**
308 * If the result to the DetectEntitiesV2 operation was truncated, include the PaginationToken to fetch the next page of entities.
309 */
310 PaginationToken?: String;
311 /**
312 * The version of the model used to analyze the documents. The version number looks like X.X.X. You can use this information to track the model used for a particular batch of documents.
313 */
314 ModelVersion: String;
315 }
316 export interface DetectPHIRequest {
317 /**
318 * A UTF-8 text string containing the clinical content being examined for PHI entities. Each string must contain fewer than 20,000 bytes of characters.
319 */
320 Text: BoundedLengthString;
321 }
322 export interface DetectPHIResponse {
323 /**
324 * The collection of PHI entities extracted from the input text and their associated information. For each entity, the response provides the entity text, the entity category, where the entity text begins and ends, and the level of confidence that Amazon Comprehend Medical has in its detection.
325 */
326 Entities: EntityList;
327 /**
328 * If the result of the previous request to DetectPHI was truncated, include the PaginationToken to fetch the next page of PHI entities.
329 */
330 PaginationToken?: String;
331 /**
332 * The version of the model used to analyze the documents. The version number looks like X.X.X. You can use this information to track the model used for a particular batch of documents.
333 */
334 ModelVersion: String;
335 }
336 export interface Entity {
337 /**
338 * The numeric identifier for the entity. This is a monotonically increasing id unique within this response rather than a global unique identifier.
339 */
340 Id?: Integer;
341 /**
342 * The 0-based character offset in the input text that shows where the entity begins. The offset returns the UTF-8 code point in the string.
343 */
344 BeginOffset?: Integer;
345 /**
346 * The 0-based character offset in the input text that shows where the entity ends. The offset returns the UTF-8 code point in the string.
347 */
348 EndOffset?: Integer;
349 /**
350 * The level of confidence that Amazon Comprehend Medical has in the accuracy of the detection.
351 */
352 Score?: Float;
353 /**
354 * The segment of input text extracted as this entity.
355 */
356 Text?: String;
357 /**
358 * The category of the entity.
359 */
360 Category?: EntityType;
361 /**
362 * Describes the specific type of entity with category of entities.
363 */
364 Type?: EntitySubType;
365 /**
366 * Contextual information for the entity.
367 */
368 Traits?: TraitList;
369 /**
370 * The extracted attributes that relate to this entity.
371 */
372 Attributes?: AttributeList;
373 }
374 export type EntityList = Entity[];
375 export type EntitySubType = "NAME"|"DOSAGE"|"ROUTE_OR_MODE"|"FORM"|"FREQUENCY"|"DURATION"|"GENERIC_NAME"|"BRAND_NAME"|"STRENGTH"|"RATE"|"ACUITY"|"TEST_NAME"|"TEST_VALUE"|"TEST_UNITS"|"PROCEDURE_NAME"|"TREATMENT_NAME"|"DATE"|"AGE"|"CONTACT_POINT"|"EMAIL"|"IDENTIFIER"|"URL"|"ADDRESS"|"PROFESSION"|"SYSTEM_ORGAN_SITE"|"DIRECTION"|"QUALITY"|"QUANTITY"|"TIME_EXPRESSION"|"TIME_TO_MEDICATION_NAME"|"TIME_TO_DX_NAME"|"TIME_TO_TEST_NAME"|"TIME_TO_PROCEDURE_NAME"|"TIME_TO_TREATMENT_NAME"|string;
376 export type EntityType = "MEDICATION"|"MEDICAL_CONDITION"|"PROTECTED_HEALTH_INFORMATION"|"TEST_TREATMENT_PROCEDURE"|"ANATOMY"|"TIME_EXPRESSION"|string;
377 export type Float = number;
378 export interface ICD10CMAttribute {
379 /**
380 * The type of attribute. InferICD10CM detects entities of the type DX_NAME.
381 */
382 Type?: ICD10CMAttributeType;
383 /**
384 * The level of confidence that Amazon Comprehend Medical has that the segment of text is correctly recognized as an attribute.
385 */
386 Score?: Float;
387 /**
388 * The level of confidence that Amazon Comprehend Medical has that this attribute is correctly related to this entity.
389 */
390 RelationshipScore?: Float;
391 /**
392 * The numeric identifier for this attribute. This is a monotonically increasing id unique within this response rather than a global unique identifier.
393 */
394 Id?: Integer;
395 /**
396 * The 0-based character offset in the input text that shows where the attribute begins. The offset returns the UTF-8 code point in the string.
397 */
398 BeginOffset?: Integer;
399 /**
400 * The 0-based character offset in the input text that shows where the attribute ends. The offset returns the UTF-8 code point in the string.
401 */
402 EndOffset?: Integer;
403 /**
404 * The segment of input text which contains the detected attribute.
405 */
406 Text?: String;
407 /**
408 * The contextual information for the attribute. The traits recognized by InferICD10CM are DIAGNOSIS, SIGN, SYMPTOM, and NEGATION.
409 */
410 Traits?: ICD10CMTraitList;
411 }
412 export type ICD10CMAttributeList = ICD10CMAttribute[];
413 export type ICD10CMAttributeType = "ACUITY"|"DIRECTION"|"SYSTEM_ORGAN_SITE"|"QUALITY"|"QUANTITY"|string;
414 export interface ICD10CMConcept {
415 /**
416 * The long description of the ICD-10-CM code in the ontology.
417 */
418 Description?: String;
419 /**
420 * The ICD-10-CM code that identifies the concept found in the knowledge base from the Centers for Disease Control.
421 */
422 Code?: String;
423 /**
424 * The level of confidence that Amazon Comprehend Medical has that the entity is accurately linked to an ICD-10-CM concept.
425 */
426 Score?: Float;
427 }
428 export type ICD10CMConceptList = ICD10CMConcept[];
429 export interface ICD10CMEntity {
430 /**
431 * The numeric identifier for the entity. This is a monotonically increasing id unique within this response rather than a global unique identifier.
432 */
433 Id?: Integer;
434 /**
435 * The segment of input text that is matched to the detected entity.
436 */
437 Text?: OntologyLinkingBoundedLengthString;
438 /**
439 * The category of the entity. InferICD10CM detects entities in the MEDICAL_CONDITION category.
440 */
441 Category?: ICD10CMEntityCategory;
442 /**
443 * Describes the specific type of entity with category of entities. InferICD10CM detects entities of the type DX_NAME.
444 */
445 Type?: ICD10CMEntityType;
446 /**
447 * The level of confidence that Amazon Comprehend Medical has in the accuracy of the detection.
448 */
449 Score?: Float;
450 /**
451 * The 0-based character offset in the input text that shows where the entity begins. The offset returns the UTF-8 code point in the string.
452 */
453 BeginOffset?: Integer;
454 /**
455 * The 0-based character offset in the input text that shows where the entity ends. The offset returns the UTF-8 code point in the string.
456 */
457 EndOffset?: Integer;
458 /**
459 * The detected attributes that relate to the entity. An extracted segment of the text that is an attribute of an entity, or otherwise related to an entity, such as the nature of a medical condition.
460 */
461 Attributes?: ICD10CMAttributeList;
462 /**
463 * Provides Contextual information for the entity. The traits recognized by InferICD10CM are DIAGNOSIS, SIGN, SYMPTOM, and NEGATION.
464 */
465 Traits?: ICD10CMTraitList;
466 /**
467 * The ICD-10-CM concepts that the entity could refer to, along with a score indicating the likelihood of the match.
468 */
469 ICD10CMConcepts?: ICD10CMConceptList;
470 }
471 export type ICD10CMEntityCategory = "MEDICAL_CONDITION"|string;
472 export type ICD10CMEntityList = ICD10CMEntity[];
473 export type ICD10CMEntityType = "DX_NAME"|string;
474 export interface ICD10CMTrait {
475 /**
476 * Provides a name or contextual description about the trait.
477 */
478 Name?: ICD10CMTraitName;
479 /**
480 * The level of confidence that Amazon Comprehend Medical has that the segment of text is correctly recognized as a trait.
481 */
482 Score?: Float;
483 }
484 export type ICD10CMTraitList = ICD10CMTrait[];
485 export type ICD10CMTraitName = "NEGATION"|"DIAGNOSIS"|"SIGN"|"SYMPTOM"|string;
486 export type IamRoleArn = string;
487 export interface InferICD10CMRequest {
488 /**
489 * The input text used for analysis. The input for InferICD10CM is a string from 1 to 10000 characters.
490 */
491 Text: OntologyLinkingBoundedLengthString;
492 }
493 export interface InferICD10CMResponse {
494 /**
495 * The medical conditions detected in the text linked to ICD-10-CM concepts. If the action is successful, the service sends back an HTTP 200 response, as well as the entities detected.
496 */
497 Entities: ICD10CMEntityList;
498 /**
499 * If the result of the previous request to InferICD10CM was truncated, include the PaginationToken to fetch the next page of medical condition entities.
500 */
501 PaginationToken?: String;
502 /**
503 * The version of the model used to analyze the documents, in the format n.n.n You can use this information to track the model used for a particular batch of documents.
504 */
505 ModelVersion?: String;
506 }
507 export interface InferRxNormRequest {
508 /**
509 * The input text used for analysis. The input for InferRxNorm is a string from 1 to 10000 characters.
510 */
511 Text: OntologyLinkingBoundedLengthString;
512 }
513 export interface InferRxNormResponse {
514 /**
515 * The medication entities detected in the text linked to RxNorm concepts. If the action is successful, the service sends back an HTTP 200 response, as well as the entities detected.
516 */
517 Entities: RxNormEntityList;
518 /**
519 * If the result of the previous request to InferRxNorm was truncated, include the PaginationToken to fetch the next page of medication entities.
520 */
521 PaginationToken?: String;
522 /**
523 * The version of the model used to analyze the documents, in the format n.n.n You can use this information to track the model used for a particular batch of documents.
524 */
525 ModelVersion?: String;
526 }
527 export interface InputDataConfig {
528 /**
529 * The URI of the S3 bucket that contains the input data. The bucket must be in the same region as the API endpoint that you are calling. Each file in the document collection must be less than 40 KB. You can store a maximum of 30 GB in the bucket.
530 */
531 S3Bucket: S3Bucket;
532 /**
533 * The path to the input data files in the S3 bucket.
534 */
535 S3Key?: S3Key;
536 }
537 export type Integer = number;
538 export type JobId = string;
539 export type JobName = string;
540 export type JobStatus = "SUBMITTED"|"IN_PROGRESS"|"COMPLETED"|"PARTIAL_SUCCESS"|"FAILED"|"STOP_REQUESTED"|"STOPPED"|string;
541 export type KMSKey = string;
542 export type LanguageCode = "en"|string;
543 export interface ListEntitiesDetectionV2JobsRequest {
544 /**
545 * Filters the jobs that are returned. You can filter jobs based on their names, status, or the date and time that they were submitted. You can only set one filter at a time.
546 */
547 Filter?: ComprehendMedicalAsyncJobFilter;
548 /**
549 * Identifies the next page of results to return.
550 */
551 NextToken?: String;
552 /**
553 * The maximum number of results to return in each page. The default is 100.
554 */
555 MaxResults?: MaxResultsInteger;
556 }
557 export interface ListEntitiesDetectionV2JobsResponse {
558 /**
559 * A list containing the properties of each job returned.
560 */
561 ComprehendMedicalAsyncJobPropertiesList?: ComprehendMedicalAsyncJobPropertiesList;
562 /**
563 * Identifies the next page of results to return.
564 */
565 NextToken?: String;
566 }
567 export interface ListPHIDetectionJobsRequest {
568 /**
569 * Filters the jobs that are returned. You can filter jobs based on their names, status, or the date and time that they were submitted. You can only set one filter at a time.
570 */
571 Filter?: ComprehendMedicalAsyncJobFilter;
572 /**
573 * Identifies the next page of results to return.
574 */
575 NextToken?: String;
576 /**
577 * The maximum number of results to return in each page. The default is 100.
578 */
579 MaxResults?: MaxResultsInteger;
580 }
581 export interface ListPHIDetectionJobsResponse {
582 /**
583 * A list containing the properties of each job returned.
584 */
585 ComprehendMedicalAsyncJobPropertiesList?: ComprehendMedicalAsyncJobPropertiesList;
586 /**
587 * Identifies the next page of results to return.
588 */
589 NextToken?: String;
590 }
591 export type ManifestFilePath = string;
592 export type MaxResultsInteger = number;
593 export type ModelVersion = string;
594 export type OntologyLinkingBoundedLengthString = string;
595 export interface OutputDataConfig {
596 /**
597 * When you use the OutputDataConfig object with asynchronous operations, you specify the Amazon S3 location where you want to write the output data. The URI must be in the same region as the API endpoint that you are calling. The location is used as the prefix for the actual location of the output.
598 */
599 S3Bucket: S3Bucket;
600 /**
601 * The path to the output data files in the S3 bucket. Amazon Comprehend Medical creates an output directory using the job ID so that the output from one job does not overwrite the output of another.
602 */
603 S3Key?: S3Key;
604 }
605 export type RelationshipType = "EVERY"|"WITH_DOSAGE"|"ADMINISTERED_VIA"|"FOR"|"NEGATIVE"|"OVERLAP"|"DOSAGE"|"ROUTE_OR_MODE"|"FORM"|"FREQUENCY"|"DURATION"|"STRENGTH"|"RATE"|"ACUITY"|"TEST_VALUE"|"TEST_UNITS"|"DIRECTION"|string;
606 export interface RxNormAttribute {
607 /**
608 * The type of attribute. The types of attributes recognized by InferRxNorm are BRAND_NAME and GENERIC_NAME.
609 */
610 Type?: RxNormAttributeType;
611 /**
612 * The level of confidence that Comprehend Medical has that the segment of text is correctly recognized as an attribute.
613 */
614 Score?: Float;
615 /**
616 * The level of confidence that Amazon Comprehend Medical has that the attribute is accurately linked to an entity.
617 */
618 RelationshipScore?: Float;
619 /**
620 * The numeric identifier for this attribute. This is a monotonically increasing id unique within this response rather than a global unique identifier.
621 */
622 Id?: Integer;
623 /**
624 * The 0-based character offset in the input text that shows where the attribute begins. The offset returns the UTF-8 code point in the string.
625 */
626 BeginOffset?: Integer;
627 /**
628 * The 0-based character offset in the input text that shows where the attribute ends. The offset returns the UTF-8 code point in the string.
629 */
630 EndOffset?: Integer;
631 /**
632 * The segment of input text which corresponds to the detected attribute.
633 */
634 Text?: String;
635 /**
636 * Contextual information for the attribute. InferRxNorm recognizes the trait NEGATION for attributes, i.e. that the patient is not taking a specific dose or form of a medication.
637 */
638 Traits?: RxNormTraitList;
639 }
640 export type RxNormAttributeList = RxNormAttribute[];
641 export type RxNormAttributeType = "DOSAGE"|"DURATION"|"FORM"|"FREQUENCY"|"RATE"|"ROUTE_OR_MODE"|"STRENGTH"|string;
642 export interface RxNormConcept {
643 /**
644 * The description of the RxNorm concept.
645 */
646 Description?: String;
647 /**
648 * RxNorm concept ID, also known as the RxCUI.
649 */
650 Code?: String;
651 /**
652 * The level of confidence that Amazon Comprehend Medical has that the entity is accurately linked to the reported RxNorm concept.
653 */
654 Score?: Float;
655 }
656 export type RxNormConceptList = RxNormConcept[];
657 export interface RxNormEntity {
658 /**
659 * The numeric identifier for the entity. This is a monotonically increasing id unique within this response rather than a global unique identifier.
660 */
661 Id?: Integer;
662 /**
663 * The segment of input text extracted from which the entity was detected.
664 */
665 Text?: OntologyLinkingBoundedLengthString;
666 /**
667 * The category of the entity. The recognized categories are GENERIC or BRAND_NAME.
668 */
669 Category?: RxNormEntityCategory;
670 /**
671 * Describes the specific type of entity. For InferRxNorm, the recognized entity type is MEDICATION.
672 */
673 Type?: RxNormEntityType;
674 /**
675 * The level of confidence that Amazon Comprehend Medical has in the accuracy of the detected entity.
676 */
677 Score?: Float;
678 /**
679 * The 0-based character offset in the input text that shows where the entity begins. The offset returns the UTF-8 code point in the string.
680 */
681 BeginOffset?: Integer;
682 /**
683 * The 0-based character offset in the input text that shows where the entity ends. The offset returns the UTF-8 code point in the string.
684 */
685 EndOffset?: Integer;
686 /**
687 * The extracted attributes that relate to the entity. The attributes recognized by InferRxNorm are DOSAGE, DURATION, FORM, FREQUENCY, RATE, ROUTE_OR_MODE, and STRENGTH.
688 */
689 Attributes?: RxNormAttributeList;
690 /**
691 * Contextual information for the entity.
692 */
693 Traits?: RxNormTraitList;
694 /**
695 * The RxNorm concepts that the entity could refer to, along with a score indicating the likelihood of the match.
696 */
697 RxNormConcepts?: RxNormConceptList;
698 }
699 export type RxNormEntityCategory = "MEDICATION"|string;
700 export type RxNormEntityList = RxNormEntity[];
701 export type RxNormEntityType = "BRAND_NAME"|"GENERIC_NAME"|string;
702 export interface RxNormTrait {
703 /**
704 * Provides a name or contextual description about the trait.
705 */
706 Name?: RxNormTraitName;
707 /**
708 * The level of confidence that Amazon Comprehend Medical has in the accuracy of the detected trait.
709 */
710 Score?: Float;
711 }
712 export type RxNormTraitList = RxNormTrait[];
713 export type RxNormTraitName = "NEGATION"|string;
714 export type S3Bucket = string;
715 export type S3Key = string;
716 export interface StartEntitiesDetectionV2JobRequest {
717 /**
718 * Specifies the format and location of the input data for the job.
719 */
720 InputDataConfig: InputDataConfig;
721 /**
722 * Specifies where to send the output files.
723 */
724 OutputDataConfig: OutputDataConfig;
725 /**
726 * The Amazon Resource Name (ARN) of the AWS Identity and Access Management (IAM) role that grants Amazon Comprehend Medical read access to your input data. For more information, see Role-Based Permissions Required for Asynchronous Operations.
727 */
728 DataAccessRoleArn: IamRoleArn;
729 /**
730 * The identifier of the job.
731 */
732 JobName?: JobName;
733 /**
734 * A unique identifier for the request. If you don't set the client request token, Amazon Comprehend Medical generates one.
735 */
736 ClientRequestToken?: ClientRequestTokenString;
737 /**
738 * An AWS Key Management Service key to encrypt your output files. If you do not specify a key, the files are written in plain text.
739 */
740 KMSKey?: KMSKey;
741 /**
742 * The language of the input documents. All documents must be in the same language.
743 */
744 LanguageCode: LanguageCode;
745 }
746 export interface StartEntitiesDetectionV2JobResponse {
747 /**
748 * The identifier generated for the job. To get the status of a job, use this identifier with the DescribeEntitiesDetectionV2Job operation.
749 */
750 JobId?: JobId;
751 }
752 export interface StartPHIDetectionJobRequest {
753 /**
754 * Specifies the format and location of the input data for the job.
755 */
756 InputDataConfig: InputDataConfig;
757 /**
758 * Specifies where to send the output files.
759 */
760 OutputDataConfig: OutputDataConfig;
761 /**
762 * The Amazon Resource Name (ARN) of the AWS Identity and Access Management (IAM) role that grants Amazon Comprehend Medical read access to your input data. For more information, see Role-Based Permissions Required for Asynchronous Operations.
763 */
764 DataAccessRoleArn: IamRoleArn;
765 /**
766 * The identifier of the job.
767 */
768 JobName?: JobName;
769 /**
770 * A unique identifier for the request. If you don't set the client request token, Amazon Comprehend Medical generates one.
771 */
772 ClientRequestToken?: ClientRequestTokenString;
773 /**
774 * An AWS Key Management Service key to encrypt your output files. If you do not specify a key, the files are written in plain text.
775 */
776 KMSKey?: KMSKey;
777 /**
778 * The language of the input documents. All documents must be in the same language.
779 */
780 LanguageCode: LanguageCode;
781 }
782 export interface StartPHIDetectionJobResponse {
783 /**
784 * The identifier generated for the job. To get the status of a job, use this identifier with the DescribePHIDetectionJob operation.
785 */
786 JobId?: JobId;
787 }
788 export interface StopEntitiesDetectionV2JobRequest {
789 /**
790 * The identifier of the medical entities job to stop.
791 */
792 JobId: JobId;
793 }
794 export interface StopEntitiesDetectionV2JobResponse {
795 /**
796 * The identifier of the medical entities detection job that was stopped.
797 */
798 JobId?: JobId;
799 }
800 export interface StopPHIDetectionJobRequest {
801 /**
802 * The identifier of the PHI detection job to stop.
803 */
804 JobId: JobId;
805 }
806 export interface StopPHIDetectionJobResponse {
807 /**
808 * The identifier of the PHI detection job that was stopped.
809 */
810 JobId?: JobId;
811 }
812 export type String = string;
813 export type Timestamp = Date;
814 export interface Trait {
815 /**
816 * Provides a name or contextual description about the trait.
817 */
818 Name?: AttributeName;
819 /**
820 * The level of confidence that Amazon Comprehend Medical has in the accuracy of this trait.
821 */
822 Score?: Float;
823 }
824 export type TraitList = Trait[];
825 export interface UnmappedAttribute {
826 /**
827 * The type of the attribute, could be one of the following values: "MEDICATION", "MEDICAL_CONDITION", "ANATOMY", "TEST_AND_TREATMENT_PROCEDURE" or "PROTECTED_HEALTH_INFORMATION".
828 */
829 Type?: EntityType;
830 /**
831 * The specific attribute that has been extracted but not mapped to an entity.
832 */
833 Attribute?: Attribute;
834 }
835 export type UnmappedAttributeList = UnmappedAttribute[];
836 /**
837 * A string in YYYY-MM-DD format that represents the latest possible API version that can be used in this service. Specify 'latest' to use the latest possible version.
838 */
839 export type apiVersion = "2018-10-30"|"latest"|string;
840 export interface ClientApiVersions {
841 /**
842 * A string in YYYY-MM-DD format that represents the latest possible API version that can be used in this service. Specify 'latest' to use the latest possible version.
843 */
844 apiVersion?: apiVersion;
845 }
846 export type ClientConfiguration = ServiceConfigurationOptions & ClientApiVersions;
847 /**
848 * Contains interfaces for use with the ComprehendMedical client.
849 */
850 export import Types = ComprehendMedical;
851}
852export = ComprehendMedical;