@aws-sdk/client-transcribe-streaming 3.168.0 → 3.170.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.
@@ -1,625 +1,648 @@
1
- import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
2
- import { TranscribeStreamingServiceException as __BaseException } from "./TranscribeStreamingServiceException";
3
-
4
- export interface Entity {
5
-
6
- StartTime?: number;
7
-
8
- EndTime?: number;
9
-
10
- Category?: string;
11
-
12
- Type?: string;
13
-
14
- Content?: string;
15
-
16
- Confidence?: number;
17
- }
18
- export declare enum ItemType {
19
- PRONUNCIATION = "pronunciation",
20
- PUNCTUATION = "punctuation"
21
- }
22
-
23
- export interface Item {
24
-
25
- StartTime?: number;
26
-
27
- EndTime?: number;
28
-
29
- Type?: ItemType | string;
30
-
31
- Content?: string;
32
-
33
- VocabularyFilterMatch?: boolean;
34
-
35
- Speaker?: string;
36
-
37
- Confidence?: number;
38
-
39
- Stable?: boolean;
40
- }
41
-
42
- export interface Alternative {
43
-
44
- Transcript?: string;
45
-
46
- Items?: Item[];
47
-
48
- Entities?: Entity[];
49
- }
50
-
51
- export interface AudioEvent {
52
-
53
- AudioChunk?: Uint8Array;
54
- }
55
-
56
- export declare type AudioStream = AudioStream.AudioEventMember | AudioStream.$UnknownMember;
57
- export declare namespace AudioStream {
58
-
59
- interface AudioEventMember {
60
- AudioEvent: AudioEvent;
61
- $unknown?: never;
62
- }
63
- interface $UnknownMember {
64
- AudioEvent?: never;
65
- $unknown: [
66
- string,
67
- any
68
- ];
69
- }
70
- interface Visitor<T> {
71
- AudioEvent: (value: AudioEvent) => T;
72
- _: (name: string, value: any) => T;
73
- }
74
- const visit: <T>(value: AudioStream, visitor: Visitor<T>) => T;
75
- }
76
-
77
- export declare class BadRequestException extends __BaseException {
78
- readonly name: "BadRequestException";
79
- readonly $fault: "client";
80
- Message?: string;
81
-
82
- constructor(opts: __ExceptionOptionType<BadRequestException, __BaseException>);
83
- }
84
-
85
- export declare class ConflictException extends __BaseException {
86
- readonly name: "ConflictException";
87
- readonly $fault: "client";
88
- Message?: string;
89
-
90
- constructor(opts: __ExceptionOptionType<ConflictException, __BaseException>);
91
- }
92
- export declare enum ContentIdentificationType {
93
- PII = "PII"
94
- }
95
- export declare enum ContentRedactionType {
96
- PII = "PII"
97
- }
98
-
99
- export declare class InternalFailureException extends __BaseException {
100
- readonly name: "InternalFailureException";
101
- readonly $fault: "server";
102
- Message?: string;
103
-
104
- constructor(opts: __ExceptionOptionType<InternalFailureException, __BaseException>);
105
- }
106
- export declare enum LanguageCode {
107
- DE_DE = "de-DE",
108
- EN_AU = "en-AU",
109
- EN_GB = "en-GB",
110
- EN_US = "en-US",
111
- ES_US = "es-US",
112
- FR_CA = "fr-CA",
113
- FR_FR = "fr-FR",
114
- IT_IT = "it-IT",
115
- JA_JP = "ja-JP",
116
- KO_KR = "ko-KR",
117
- PT_BR = "pt-BR",
118
- ZH_CN = "zh-CN"
119
- }
120
-
121
- export interface LanguageWithScore {
122
-
123
- LanguageCode?: LanguageCode | string;
124
-
125
- Score?: number;
126
- }
127
-
128
- export declare class LimitExceededException extends __BaseException {
129
- readonly name: "LimitExceededException";
130
- readonly $fault: "client";
131
- Message?: string;
132
-
133
- constructor(opts: __ExceptionOptionType<LimitExceededException, __BaseException>);
134
- }
135
- export declare enum MediaEncoding {
136
- FLAC = "flac",
137
- OGG_OPUS = "ogg-opus",
138
- PCM = "pcm"
139
- }
140
-
141
- export interface MedicalEntity {
142
-
143
- StartTime?: number;
144
-
145
- EndTime?: number;
146
-
147
- Category?: string;
148
-
149
- Content?: string;
150
-
151
- Confidence?: number;
152
- }
153
-
154
- export interface MedicalItem {
155
-
156
- StartTime?: number;
157
-
158
- EndTime?: number;
159
-
160
- Type?: ItemType | string;
161
-
162
- Content?: string;
163
-
164
- Confidence?: number;
165
-
166
- Speaker?: string;
167
- }
168
-
169
- export interface MedicalAlternative {
170
-
171
- Transcript?: string;
172
-
173
- Items?: MedicalItem[];
174
-
175
- Entities?: MedicalEntity[];
176
- }
177
- export declare enum MedicalContentIdentificationType {
178
- PHI = "PHI"
179
- }
180
-
181
- export interface MedicalResult {
182
-
183
- ResultId?: string;
184
-
185
- StartTime?: number;
186
-
187
- EndTime?: number;
188
-
189
- IsPartial?: boolean;
190
-
191
- Alternatives?: MedicalAlternative[];
192
-
193
- ChannelId?: string;
194
- }
195
-
196
- export interface MedicalTranscript {
197
-
198
- Results?: MedicalResult[];
199
- }
200
-
201
- export interface MedicalTranscriptEvent {
202
-
203
- Transcript?: MedicalTranscript;
204
- }
205
-
206
- export declare class ServiceUnavailableException extends __BaseException {
207
- readonly name: "ServiceUnavailableException";
208
- readonly $fault: "server";
209
- Message?: string;
210
-
211
- constructor(opts: __ExceptionOptionType<ServiceUnavailableException, __BaseException>);
212
- }
213
-
214
- export declare type MedicalTranscriptResultStream = MedicalTranscriptResultStream.BadRequestExceptionMember | MedicalTranscriptResultStream.ConflictExceptionMember | MedicalTranscriptResultStream.InternalFailureExceptionMember | MedicalTranscriptResultStream.LimitExceededExceptionMember | MedicalTranscriptResultStream.ServiceUnavailableExceptionMember | MedicalTranscriptResultStream.TranscriptEventMember | MedicalTranscriptResultStream.$UnknownMember;
215
- export declare namespace MedicalTranscriptResultStream {
216
-
217
- interface TranscriptEventMember {
218
- TranscriptEvent: MedicalTranscriptEvent;
219
- BadRequestException?: never;
220
- LimitExceededException?: never;
221
- InternalFailureException?: never;
222
- ConflictException?: never;
223
- ServiceUnavailableException?: never;
224
- $unknown?: never;
225
- }
226
-
227
- interface BadRequestExceptionMember {
228
- TranscriptEvent?: never;
229
- BadRequestException: BadRequestException;
230
- LimitExceededException?: never;
231
- InternalFailureException?: never;
232
- ConflictException?: never;
233
- ServiceUnavailableException?: never;
234
- $unknown?: never;
235
- }
236
-
237
- interface LimitExceededExceptionMember {
238
- TranscriptEvent?: never;
239
- BadRequestException?: never;
240
- LimitExceededException: LimitExceededException;
241
- InternalFailureException?: never;
242
- ConflictException?: never;
243
- ServiceUnavailableException?: never;
244
- $unknown?: never;
245
- }
246
-
247
- interface InternalFailureExceptionMember {
248
- TranscriptEvent?: never;
249
- BadRequestException?: never;
250
- LimitExceededException?: never;
251
- InternalFailureException: InternalFailureException;
252
- ConflictException?: never;
253
- ServiceUnavailableException?: never;
254
- $unknown?: never;
255
- }
256
-
257
- interface ConflictExceptionMember {
258
- TranscriptEvent?: never;
259
- BadRequestException?: never;
260
- LimitExceededException?: never;
261
- InternalFailureException?: never;
262
- ConflictException: ConflictException;
263
- ServiceUnavailableException?: never;
264
- $unknown?: never;
265
- }
266
-
267
- interface ServiceUnavailableExceptionMember {
268
- TranscriptEvent?: never;
269
- BadRequestException?: never;
270
- LimitExceededException?: never;
271
- InternalFailureException?: never;
272
- ConflictException?: never;
273
- ServiceUnavailableException: ServiceUnavailableException;
274
- $unknown?: never;
275
- }
276
- interface $UnknownMember {
277
- TranscriptEvent?: never;
278
- BadRequestException?: never;
279
- LimitExceededException?: never;
280
- InternalFailureException?: never;
281
- ConflictException?: never;
282
- ServiceUnavailableException?: never;
283
- $unknown: [
284
- string,
285
- any
286
- ];
287
- }
288
- interface Visitor<T> {
289
- TranscriptEvent: (value: MedicalTranscriptEvent) => T;
290
- BadRequestException: (value: BadRequestException) => T;
291
- LimitExceededException: (value: LimitExceededException) => T;
292
- InternalFailureException: (value: InternalFailureException) => T;
293
- ConflictException: (value: ConflictException) => T;
294
- ServiceUnavailableException: (value: ServiceUnavailableException) => T;
295
- _: (name: string, value: any) => T;
296
- }
297
- const visit: <T>(value: MedicalTranscriptResultStream, visitor: Visitor<T>) => T;
298
- }
299
- export declare enum PartialResultsStability {
300
- HIGH = "high",
301
- LOW = "low",
302
- MEDIUM = "medium"
303
- }
304
-
305
- export interface Result {
306
-
307
- ResultId?: string;
308
-
309
- StartTime?: number;
310
-
311
- EndTime?: number;
312
-
313
- IsPartial?: boolean;
314
-
315
- Alternatives?: Alternative[];
316
-
317
- ChannelId?: string;
318
-
319
- LanguageCode?: LanguageCode | string;
320
-
321
- LanguageIdentification?: LanguageWithScore[];
322
- }
323
- export declare enum Specialty {
324
- CARDIOLOGY = "CARDIOLOGY",
325
- NEUROLOGY = "NEUROLOGY",
326
- ONCOLOGY = "ONCOLOGY",
327
- PRIMARYCARE = "PRIMARYCARE",
328
- RADIOLOGY = "RADIOLOGY",
329
- UROLOGY = "UROLOGY"
330
- }
331
- export declare enum Type {
332
- CONVERSATION = "CONVERSATION",
333
- DICTATION = "DICTATION"
334
- }
335
- export interface StartMedicalStreamTranscriptionRequest {
336
-
337
- LanguageCode: LanguageCode | string | undefined;
338
-
339
- MediaSampleRateHertz: number | undefined;
340
-
341
- MediaEncoding: MediaEncoding | string | undefined;
342
-
343
- VocabularyName?: string;
344
-
345
- Specialty: Specialty | string | undefined;
346
-
347
- Type: Type | string | undefined;
348
-
349
- ShowSpeakerLabel?: boolean;
350
-
351
- SessionId?: string;
352
-
353
- AudioStream: AsyncIterable<AudioStream> | undefined;
354
-
355
- EnableChannelIdentification?: boolean;
356
-
357
- NumberOfChannels?: number;
358
-
359
- ContentIdentificationType?: MedicalContentIdentificationType | string;
360
- }
361
- export interface StartMedicalStreamTranscriptionResponse {
362
-
363
- RequestId?: string;
364
-
365
- LanguageCode?: LanguageCode | string;
366
-
367
- MediaSampleRateHertz?: number;
368
-
369
- MediaEncoding?: MediaEncoding | string;
370
-
371
- VocabularyName?: string;
372
-
373
- Specialty?: Specialty | string;
374
-
375
- Type?: Type | string;
376
-
377
- ShowSpeakerLabel?: boolean;
378
-
379
- SessionId?: string;
380
-
381
- TranscriptResultStream?: AsyncIterable<MedicalTranscriptResultStream>;
382
-
383
- EnableChannelIdentification?: boolean;
384
-
385
- NumberOfChannels?: number;
386
-
387
- ContentIdentificationType?: MedicalContentIdentificationType | string;
388
- }
389
- export declare enum VocabularyFilterMethod {
390
- MASK = "mask",
391
- REMOVE = "remove",
392
- TAG = "tag"
393
- }
394
- export interface StartStreamTranscriptionRequest {
395
-
396
- LanguageCode?: LanguageCode | string;
397
-
398
- MediaSampleRateHertz: number | undefined;
399
-
400
- MediaEncoding: MediaEncoding | string | undefined;
401
-
402
- VocabularyName?: string;
403
-
404
- SessionId?: string;
405
-
406
- AudioStream: AsyncIterable<AudioStream> | undefined;
407
-
408
- VocabularyFilterName?: string;
409
-
410
- VocabularyFilterMethod?: VocabularyFilterMethod | string;
411
-
412
- ShowSpeakerLabel?: boolean;
413
-
414
- EnableChannelIdentification?: boolean;
415
-
416
- NumberOfChannels?: number;
417
-
418
- EnablePartialResultsStabilization?: boolean;
419
-
420
- PartialResultsStability?: PartialResultsStability | string;
421
-
422
- ContentIdentificationType?: ContentIdentificationType | string;
423
-
424
- ContentRedactionType?: ContentRedactionType | string;
425
-
426
- PiiEntityTypes?: string;
427
-
428
- LanguageModelName?: string;
429
-
430
- IdentifyLanguage?: boolean;
431
-
432
- LanguageOptions?: string;
433
-
434
- PreferredLanguage?: LanguageCode | string;
435
-
436
- VocabularyNames?: string;
437
-
438
- VocabularyFilterNames?: string;
439
- }
440
-
441
- export interface Transcript {
442
-
443
- Results?: Result[];
444
- }
445
-
446
- export interface TranscriptEvent {
447
-
448
- Transcript?: Transcript;
449
- }
450
-
451
- export declare type TranscriptResultStream = TranscriptResultStream.BadRequestExceptionMember | TranscriptResultStream.ConflictExceptionMember | TranscriptResultStream.InternalFailureExceptionMember | TranscriptResultStream.LimitExceededExceptionMember | TranscriptResultStream.ServiceUnavailableExceptionMember | TranscriptResultStream.TranscriptEventMember | TranscriptResultStream.$UnknownMember;
452
- export declare namespace TranscriptResultStream {
453
-
454
- interface TranscriptEventMember {
455
- TranscriptEvent: TranscriptEvent;
456
- BadRequestException?: never;
457
- LimitExceededException?: never;
458
- InternalFailureException?: never;
459
- ConflictException?: never;
460
- ServiceUnavailableException?: never;
461
- $unknown?: never;
462
- }
463
-
464
- interface BadRequestExceptionMember {
465
- TranscriptEvent?: never;
466
- BadRequestException: BadRequestException;
467
- LimitExceededException?: never;
468
- InternalFailureException?: never;
469
- ConflictException?: never;
470
- ServiceUnavailableException?: never;
471
- $unknown?: never;
472
- }
473
-
474
- interface LimitExceededExceptionMember {
475
- TranscriptEvent?: never;
476
- BadRequestException?: never;
477
- LimitExceededException: LimitExceededException;
478
- InternalFailureException?: never;
479
- ConflictException?: never;
480
- ServiceUnavailableException?: never;
481
- $unknown?: never;
482
- }
483
-
484
- interface InternalFailureExceptionMember {
485
- TranscriptEvent?: never;
486
- BadRequestException?: never;
487
- LimitExceededException?: never;
488
- InternalFailureException: InternalFailureException;
489
- ConflictException?: never;
490
- ServiceUnavailableException?: never;
491
- $unknown?: never;
492
- }
493
-
494
- interface ConflictExceptionMember {
495
- TranscriptEvent?: never;
496
- BadRequestException?: never;
497
- LimitExceededException?: never;
498
- InternalFailureException?: never;
499
- ConflictException: ConflictException;
500
- ServiceUnavailableException?: never;
501
- $unknown?: never;
502
- }
503
-
504
- interface ServiceUnavailableExceptionMember {
505
- TranscriptEvent?: never;
506
- BadRequestException?: never;
507
- LimitExceededException?: never;
508
- InternalFailureException?: never;
509
- ConflictException?: never;
510
- ServiceUnavailableException: ServiceUnavailableException;
511
- $unknown?: never;
512
- }
513
- interface $UnknownMember {
514
- TranscriptEvent?: never;
515
- BadRequestException?: never;
516
- LimitExceededException?: never;
517
- InternalFailureException?: never;
518
- ConflictException?: never;
519
- ServiceUnavailableException?: never;
520
- $unknown: [
521
- string,
522
- any
523
- ];
524
- }
525
- interface Visitor<T> {
526
- TranscriptEvent: (value: TranscriptEvent) => T;
527
- BadRequestException: (value: BadRequestException) => T;
528
- LimitExceededException: (value: LimitExceededException) => T;
529
- InternalFailureException: (value: InternalFailureException) => T;
530
- ConflictException: (value: ConflictException) => T;
531
- ServiceUnavailableException: (value: ServiceUnavailableException) => T;
532
- _: (name: string, value: any) => T;
533
- }
534
- const visit: <T>(value: TranscriptResultStream, visitor: Visitor<T>) => T;
535
- }
536
- export interface StartStreamTranscriptionResponse {
537
-
538
- RequestId?: string;
539
-
540
- LanguageCode?: LanguageCode | string;
541
-
542
- MediaSampleRateHertz?: number;
543
-
544
- MediaEncoding?: MediaEncoding | string;
545
-
546
- VocabularyName?: string;
547
-
548
- SessionId?: string;
549
-
550
- TranscriptResultStream?: AsyncIterable<TranscriptResultStream>;
551
-
552
- VocabularyFilterName?: string;
553
-
554
- VocabularyFilterMethod?: VocabularyFilterMethod | string;
555
-
556
- ShowSpeakerLabel?: boolean;
557
-
558
- EnableChannelIdentification?: boolean;
559
-
560
- NumberOfChannels?: number;
561
-
562
- EnablePartialResultsStabilization?: boolean;
563
-
564
- PartialResultsStability?: PartialResultsStability | string;
565
-
566
- ContentIdentificationType?: ContentIdentificationType | string;
567
-
568
- ContentRedactionType?: ContentRedactionType | string;
569
-
570
- PiiEntityTypes?: string;
571
-
572
- LanguageModelName?: string;
573
-
574
- IdentifyLanguage?: boolean;
575
-
576
- LanguageOptions?: string;
577
-
578
- PreferredLanguage?: LanguageCode | string;
579
-
580
- VocabularyNames?: string;
581
-
582
- VocabularyFilterNames?: string;
583
- }
584
-
585
- export declare const EntityFilterSensitiveLog: (obj: Entity) => any;
586
-
587
- export declare const ItemFilterSensitiveLog: (obj: Item) => any;
588
-
589
- export declare const AlternativeFilterSensitiveLog: (obj: Alternative) => any;
590
-
591
- export declare const AudioEventFilterSensitiveLog: (obj: AudioEvent) => any;
592
-
593
- export declare const AudioStreamFilterSensitiveLog: (obj: AudioStream) => any;
594
-
595
- export declare const LanguageWithScoreFilterSensitiveLog: (obj: LanguageWithScore) => any;
596
-
597
- export declare const MedicalEntityFilterSensitiveLog: (obj: MedicalEntity) => any;
598
-
599
- export declare const MedicalItemFilterSensitiveLog: (obj: MedicalItem) => any;
600
-
601
- export declare const MedicalAlternativeFilterSensitiveLog: (obj: MedicalAlternative) => any;
602
-
603
- export declare const MedicalResultFilterSensitiveLog: (obj: MedicalResult) => any;
604
-
605
- export declare const MedicalTranscriptFilterSensitiveLog: (obj: MedicalTranscript) => any;
606
-
607
- export declare const MedicalTranscriptEventFilterSensitiveLog: (obj: MedicalTranscriptEvent) => any;
608
-
609
- export declare const MedicalTranscriptResultStreamFilterSensitiveLog: (obj: MedicalTranscriptResultStream) => any;
610
-
611
- export declare const ResultFilterSensitiveLog: (obj: Result) => any;
612
-
613
- export declare const StartMedicalStreamTranscriptionRequestFilterSensitiveLog: (obj: StartMedicalStreamTranscriptionRequest) => any;
614
-
615
- export declare const StartMedicalStreamTranscriptionResponseFilterSensitiveLog: (obj: StartMedicalStreamTranscriptionResponse) => any;
616
-
617
- export declare const StartStreamTranscriptionRequestFilterSensitiveLog: (obj: StartStreamTranscriptionRequest) => any;
618
-
619
- export declare const TranscriptFilterSensitiveLog: (obj: Transcript) => any;
620
-
621
- export declare const TranscriptEventFilterSensitiveLog: (obj: TranscriptEvent) => any;
622
-
623
- export declare const TranscriptResultStreamFilterSensitiveLog: (obj: TranscriptResultStream) => any;
624
-
625
- export declare const StartStreamTranscriptionResponseFilterSensitiveLog: (obj: StartStreamTranscriptionResponse) => any;
1
+ import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
2
+ import { TranscribeStreamingServiceException as __BaseException } from "./TranscribeStreamingServiceException";
3
+
4
+ export interface Entity {
5
+ StartTime?: number;
6
+
7
+ EndTime?: number;
8
+
9
+ Category?: string;
10
+
11
+ Type?: string;
12
+
13
+ Content?: string;
14
+
15
+ Confidence?: number;
16
+ }
17
+ export declare enum ItemType {
18
+ PRONUNCIATION = "pronunciation",
19
+ PUNCTUATION = "punctuation",
20
+ }
21
+
22
+ export interface Item {
23
+ StartTime?: number;
24
+
25
+ EndTime?: number;
26
+
27
+ Type?: ItemType | string;
28
+
29
+ Content?: string;
30
+
31
+ VocabularyFilterMatch?: boolean;
32
+
33
+ Speaker?: string;
34
+
35
+ Confidence?: number;
36
+
37
+ Stable?: boolean;
38
+ }
39
+
40
+ export interface Alternative {
41
+ Transcript?: string;
42
+
43
+ Items?: Item[];
44
+
45
+ Entities?: Entity[];
46
+ }
47
+
48
+ export interface AudioEvent {
49
+ AudioChunk?: Uint8Array;
50
+ }
51
+
52
+ export declare type AudioStream =
53
+ | AudioStream.AudioEventMember
54
+ | AudioStream.$UnknownMember;
55
+ export declare namespace AudioStream {
56
+ interface AudioEventMember {
57
+ AudioEvent: AudioEvent;
58
+ $unknown?: never;
59
+ }
60
+ interface $UnknownMember {
61
+ AudioEvent?: never;
62
+ $unknown: [string, any];
63
+ }
64
+ interface Visitor<T> {
65
+ AudioEvent: (value: AudioEvent) => T;
66
+ _: (name: string, value: any) => T;
67
+ }
68
+ const visit: <T>(value: AudioStream, visitor: Visitor<T>) => T;
69
+ }
70
+
71
+ export declare class BadRequestException extends __BaseException {
72
+ readonly name: "BadRequestException";
73
+ readonly $fault: "client";
74
+ Message?: string;
75
+
76
+ constructor(
77
+ opts: __ExceptionOptionType<BadRequestException, __BaseException>
78
+ );
79
+ }
80
+
81
+ export declare class ConflictException extends __BaseException {
82
+ readonly name: "ConflictException";
83
+ readonly $fault: "client";
84
+ Message?: string;
85
+
86
+ constructor(opts: __ExceptionOptionType<ConflictException, __BaseException>);
87
+ }
88
+ export declare enum ContentIdentificationType {
89
+ PII = "PII",
90
+ }
91
+ export declare enum ContentRedactionType {
92
+ PII = "PII",
93
+ }
94
+
95
+ export declare class InternalFailureException extends __BaseException {
96
+ readonly name: "InternalFailureException";
97
+ readonly $fault: "server";
98
+ Message?: string;
99
+
100
+ constructor(
101
+ opts: __ExceptionOptionType<InternalFailureException, __BaseException>
102
+ );
103
+ }
104
+ export declare enum LanguageCode {
105
+ DE_DE = "de-DE",
106
+ EN_AU = "en-AU",
107
+ EN_GB = "en-GB",
108
+ EN_US = "en-US",
109
+ ES_US = "es-US",
110
+ FR_CA = "fr-CA",
111
+ FR_FR = "fr-FR",
112
+ IT_IT = "it-IT",
113
+ JA_JP = "ja-JP",
114
+ KO_KR = "ko-KR",
115
+ PT_BR = "pt-BR",
116
+ ZH_CN = "zh-CN",
117
+ }
118
+
119
+ export interface LanguageWithScore {
120
+ LanguageCode?: LanguageCode | string;
121
+
122
+ Score?: number;
123
+ }
124
+
125
+ export declare class LimitExceededException extends __BaseException {
126
+ readonly name: "LimitExceededException";
127
+ readonly $fault: "client";
128
+ Message?: string;
129
+
130
+ constructor(
131
+ opts: __ExceptionOptionType<LimitExceededException, __BaseException>
132
+ );
133
+ }
134
+ export declare enum MediaEncoding {
135
+ FLAC = "flac",
136
+ OGG_OPUS = "ogg-opus",
137
+ PCM = "pcm",
138
+ }
139
+
140
+ export interface MedicalEntity {
141
+ StartTime?: number;
142
+
143
+ EndTime?: number;
144
+
145
+ Category?: string;
146
+
147
+ Content?: string;
148
+
149
+ Confidence?: number;
150
+ }
151
+
152
+ export interface MedicalItem {
153
+ StartTime?: number;
154
+
155
+ EndTime?: number;
156
+
157
+ Type?: ItemType | string;
158
+
159
+ Content?: string;
160
+
161
+ Confidence?: number;
162
+
163
+ Speaker?: string;
164
+ }
165
+
166
+ export interface MedicalAlternative {
167
+ Transcript?: string;
168
+
169
+ Items?: MedicalItem[];
170
+
171
+ Entities?: MedicalEntity[];
172
+ }
173
+ export declare enum MedicalContentIdentificationType {
174
+ PHI = "PHI",
175
+ }
176
+
177
+ export interface MedicalResult {
178
+ ResultId?: string;
179
+
180
+ StartTime?: number;
181
+
182
+ EndTime?: number;
183
+
184
+ IsPartial?: boolean;
185
+
186
+ Alternatives?: MedicalAlternative[];
187
+
188
+ ChannelId?: string;
189
+ }
190
+
191
+ export interface MedicalTranscript {
192
+ Results?: MedicalResult[];
193
+ }
194
+
195
+ export interface MedicalTranscriptEvent {
196
+ Transcript?: MedicalTranscript;
197
+ }
198
+
199
+ export declare class ServiceUnavailableException extends __BaseException {
200
+ readonly name: "ServiceUnavailableException";
201
+ readonly $fault: "server";
202
+ Message?: string;
203
+
204
+ constructor(
205
+ opts: __ExceptionOptionType<ServiceUnavailableException, __BaseException>
206
+ );
207
+ }
208
+
209
+ export declare type MedicalTranscriptResultStream =
210
+ | MedicalTranscriptResultStream.BadRequestExceptionMember
211
+ | MedicalTranscriptResultStream.ConflictExceptionMember
212
+ | MedicalTranscriptResultStream.InternalFailureExceptionMember
213
+ | MedicalTranscriptResultStream.LimitExceededExceptionMember
214
+ | MedicalTranscriptResultStream.ServiceUnavailableExceptionMember
215
+ | MedicalTranscriptResultStream.TranscriptEventMember
216
+ | MedicalTranscriptResultStream.$UnknownMember;
217
+ export declare namespace MedicalTranscriptResultStream {
218
+ interface TranscriptEventMember {
219
+ TranscriptEvent: MedicalTranscriptEvent;
220
+ BadRequestException?: never;
221
+ LimitExceededException?: never;
222
+ InternalFailureException?: never;
223
+ ConflictException?: never;
224
+ ServiceUnavailableException?: never;
225
+ $unknown?: never;
226
+ }
227
+
228
+ interface BadRequestExceptionMember {
229
+ TranscriptEvent?: never;
230
+ BadRequestException: BadRequestException;
231
+ LimitExceededException?: never;
232
+ InternalFailureException?: never;
233
+ ConflictException?: never;
234
+ ServiceUnavailableException?: never;
235
+ $unknown?: never;
236
+ }
237
+
238
+ interface LimitExceededExceptionMember {
239
+ TranscriptEvent?: never;
240
+ BadRequestException?: never;
241
+ LimitExceededException: LimitExceededException;
242
+ InternalFailureException?: never;
243
+ ConflictException?: never;
244
+ ServiceUnavailableException?: never;
245
+ $unknown?: never;
246
+ }
247
+
248
+ interface InternalFailureExceptionMember {
249
+ TranscriptEvent?: never;
250
+ BadRequestException?: never;
251
+ LimitExceededException?: never;
252
+ InternalFailureException: InternalFailureException;
253
+ ConflictException?: never;
254
+ ServiceUnavailableException?: never;
255
+ $unknown?: never;
256
+ }
257
+
258
+ interface ConflictExceptionMember {
259
+ TranscriptEvent?: never;
260
+ BadRequestException?: never;
261
+ LimitExceededException?: never;
262
+ InternalFailureException?: never;
263
+ ConflictException: ConflictException;
264
+ ServiceUnavailableException?: never;
265
+ $unknown?: never;
266
+ }
267
+
268
+ interface ServiceUnavailableExceptionMember {
269
+ TranscriptEvent?: never;
270
+ BadRequestException?: never;
271
+ LimitExceededException?: never;
272
+ InternalFailureException?: never;
273
+ ConflictException?: never;
274
+ ServiceUnavailableException: ServiceUnavailableException;
275
+ $unknown?: never;
276
+ }
277
+ interface $UnknownMember {
278
+ TranscriptEvent?: never;
279
+ BadRequestException?: never;
280
+ LimitExceededException?: never;
281
+ InternalFailureException?: never;
282
+ ConflictException?: never;
283
+ ServiceUnavailableException?: never;
284
+ $unknown: [string, any];
285
+ }
286
+ interface Visitor<T> {
287
+ TranscriptEvent: (value: MedicalTranscriptEvent) => T;
288
+ BadRequestException: (value: BadRequestException) => T;
289
+ LimitExceededException: (value: LimitExceededException) => T;
290
+ InternalFailureException: (value: InternalFailureException) => T;
291
+ ConflictException: (value: ConflictException) => T;
292
+ ServiceUnavailableException: (value: ServiceUnavailableException) => T;
293
+ _: (name: string, value: any) => T;
294
+ }
295
+ const visit: <T>(
296
+ value: MedicalTranscriptResultStream,
297
+ visitor: Visitor<T>
298
+ ) => T;
299
+ }
300
+ export declare enum PartialResultsStability {
301
+ HIGH = "high",
302
+ LOW = "low",
303
+ MEDIUM = "medium",
304
+ }
305
+
306
+ export interface Result {
307
+ ResultId?: string;
308
+
309
+ StartTime?: number;
310
+
311
+ EndTime?: number;
312
+
313
+ IsPartial?: boolean;
314
+
315
+ Alternatives?: Alternative[];
316
+
317
+ ChannelId?: string;
318
+
319
+ LanguageCode?: LanguageCode | string;
320
+
321
+ LanguageIdentification?: LanguageWithScore[];
322
+ }
323
+ export declare enum Specialty {
324
+ CARDIOLOGY = "CARDIOLOGY",
325
+ NEUROLOGY = "NEUROLOGY",
326
+ ONCOLOGY = "ONCOLOGY",
327
+ PRIMARYCARE = "PRIMARYCARE",
328
+ RADIOLOGY = "RADIOLOGY",
329
+ UROLOGY = "UROLOGY",
330
+ }
331
+ export declare enum Type {
332
+ CONVERSATION = "CONVERSATION",
333
+ DICTATION = "DICTATION",
334
+ }
335
+ export interface StartMedicalStreamTranscriptionRequest {
336
+ LanguageCode: LanguageCode | string | undefined;
337
+
338
+ MediaSampleRateHertz: number | undefined;
339
+
340
+ MediaEncoding: MediaEncoding | string | undefined;
341
+
342
+ VocabularyName?: string;
343
+
344
+ Specialty: Specialty | string | undefined;
345
+
346
+ Type: Type | string | undefined;
347
+
348
+ ShowSpeakerLabel?: boolean;
349
+
350
+ SessionId?: string;
351
+
352
+ AudioStream: AsyncIterable<AudioStream> | undefined;
353
+
354
+ EnableChannelIdentification?: boolean;
355
+
356
+ NumberOfChannels?: number;
357
+
358
+ ContentIdentificationType?: MedicalContentIdentificationType | string;
359
+ }
360
+ export interface StartMedicalStreamTranscriptionResponse {
361
+ RequestId?: string;
362
+
363
+ LanguageCode?: LanguageCode | string;
364
+
365
+ MediaSampleRateHertz?: number;
366
+
367
+ MediaEncoding?: MediaEncoding | string;
368
+
369
+ VocabularyName?: string;
370
+
371
+ Specialty?: Specialty | string;
372
+
373
+ Type?: Type | string;
374
+
375
+ ShowSpeakerLabel?: boolean;
376
+
377
+ SessionId?: string;
378
+
379
+ TranscriptResultStream?: AsyncIterable<MedicalTranscriptResultStream>;
380
+
381
+ EnableChannelIdentification?: boolean;
382
+
383
+ NumberOfChannels?: number;
384
+
385
+ ContentIdentificationType?: MedicalContentIdentificationType | string;
386
+ }
387
+ export declare enum VocabularyFilterMethod {
388
+ MASK = "mask",
389
+ REMOVE = "remove",
390
+ TAG = "tag",
391
+ }
392
+ export interface StartStreamTranscriptionRequest {
393
+ LanguageCode?: LanguageCode | string;
394
+
395
+ MediaSampleRateHertz: number | undefined;
396
+
397
+ MediaEncoding: MediaEncoding | string | undefined;
398
+
399
+ VocabularyName?: string;
400
+
401
+ SessionId?: string;
402
+
403
+ AudioStream: AsyncIterable<AudioStream> | undefined;
404
+
405
+ VocabularyFilterName?: string;
406
+
407
+ VocabularyFilterMethod?: VocabularyFilterMethod | string;
408
+
409
+ ShowSpeakerLabel?: boolean;
410
+
411
+ EnableChannelIdentification?: boolean;
412
+
413
+ NumberOfChannels?: number;
414
+
415
+ EnablePartialResultsStabilization?: boolean;
416
+
417
+ PartialResultsStability?: PartialResultsStability | string;
418
+
419
+ ContentIdentificationType?: ContentIdentificationType | string;
420
+
421
+ ContentRedactionType?: ContentRedactionType | string;
422
+
423
+ PiiEntityTypes?: string;
424
+
425
+ LanguageModelName?: string;
426
+
427
+ IdentifyLanguage?: boolean;
428
+
429
+ LanguageOptions?: string;
430
+
431
+ PreferredLanguage?: LanguageCode | string;
432
+
433
+ VocabularyNames?: string;
434
+
435
+ VocabularyFilterNames?: string;
436
+ }
437
+
438
+ export interface Transcript {
439
+ Results?: Result[];
440
+ }
441
+
442
+ export interface TranscriptEvent {
443
+ Transcript?: Transcript;
444
+ }
445
+
446
+ export declare type TranscriptResultStream =
447
+ | TranscriptResultStream.BadRequestExceptionMember
448
+ | TranscriptResultStream.ConflictExceptionMember
449
+ | TranscriptResultStream.InternalFailureExceptionMember
450
+ | TranscriptResultStream.LimitExceededExceptionMember
451
+ | TranscriptResultStream.ServiceUnavailableExceptionMember
452
+ | TranscriptResultStream.TranscriptEventMember
453
+ | TranscriptResultStream.$UnknownMember;
454
+ export declare namespace TranscriptResultStream {
455
+ interface TranscriptEventMember {
456
+ TranscriptEvent: TranscriptEvent;
457
+ BadRequestException?: never;
458
+ LimitExceededException?: never;
459
+ InternalFailureException?: never;
460
+ ConflictException?: never;
461
+ ServiceUnavailableException?: never;
462
+ $unknown?: never;
463
+ }
464
+
465
+ interface BadRequestExceptionMember {
466
+ TranscriptEvent?: never;
467
+ BadRequestException: BadRequestException;
468
+ LimitExceededException?: never;
469
+ InternalFailureException?: never;
470
+ ConflictException?: never;
471
+ ServiceUnavailableException?: never;
472
+ $unknown?: never;
473
+ }
474
+
475
+ interface LimitExceededExceptionMember {
476
+ TranscriptEvent?: never;
477
+ BadRequestException?: never;
478
+ LimitExceededException: LimitExceededException;
479
+ InternalFailureException?: never;
480
+ ConflictException?: never;
481
+ ServiceUnavailableException?: never;
482
+ $unknown?: never;
483
+ }
484
+
485
+ interface InternalFailureExceptionMember {
486
+ TranscriptEvent?: never;
487
+ BadRequestException?: never;
488
+ LimitExceededException?: never;
489
+ InternalFailureException: InternalFailureException;
490
+ ConflictException?: never;
491
+ ServiceUnavailableException?: never;
492
+ $unknown?: never;
493
+ }
494
+
495
+ interface ConflictExceptionMember {
496
+ TranscriptEvent?: never;
497
+ BadRequestException?: never;
498
+ LimitExceededException?: never;
499
+ InternalFailureException?: never;
500
+ ConflictException: ConflictException;
501
+ ServiceUnavailableException?: never;
502
+ $unknown?: never;
503
+ }
504
+
505
+ interface ServiceUnavailableExceptionMember {
506
+ TranscriptEvent?: never;
507
+ BadRequestException?: never;
508
+ LimitExceededException?: never;
509
+ InternalFailureException?: never;
510
+ ConflictException?: never;
511
+ ServiceUnavailableException: ServiceUnavailableException;
512
+ $unknown?: never;
513
+ }
514
+ interface $UnknownMember {
515
+ TranscriptEvent?: never;
516
+ BadRequestException?: never;
517
+ LimitExceededException?: never;
518
+ InternalFailureException?: never;
519
+ ConflictException?: never;
520
+ ServiceUnavailableException?: never;
521
+ $unknown: [string, any];
522
+ }
523
+ interface Visitor<T> {
524
+ TranscriptEvent: (value: TranscriptEvent) => T;
525
+ BadRequestException: (value: BadRequestException) => T;
526
+ LimitExceededException: (value: LimitExceededException) => T;
527
+ InternalFailureException: (value: InternalFailureException) => T;
528
+ ConflictException: (value: ConflictException) => T;
529
+ ServiceUnavailableException: (value: ServiceUnavailableException) => T;
530
+ _: (name: string, value: any) => T;
531
+ }
532
+ const visit: <T>(value: TranscriptResultStream, visitor: Visitor<T>) => T;
533
+ }
534
+ export interface StartStreamTranscriptionResponse {
535
+ RequestId?: string;
536
+
537
+ LanguageCode?: LanguageCode | string;
538
+
539
+ MediaSampleRateHertz?: number;
540
+
541
+ MediaEncoding?: MediaEncoding | string;
542
+
543
+ VocabularyName?: string;
544
+
545
+ SessionId?: string;
546
+
547
+ TranscriptResultStream?: AsyncIterable<TranscriptResultStream>;
548
+
549
+ VocabularyFilterName?: string;
550
+
551
+ VocabularyFilterMethod?: VocabularyFilterMethod | string;
552
+
553
+ ShowSpeakerLabel?: boolean;
554
+
555
+ EnableChannelIdentification?: boolean;
556
+
557
+ NumberOfChannels?: number;
558
+
559
+ EnablePartialResultsStabilization?: boolean;
560
+
561
+ PartialResultsStability?: PartialResultsStability | string;
562
+
563
+ ContentIdentificationType?: ContentIdentificationType | string;
564
+
565
+ ContentRedactionType?: ContentRedactionType | string;
566
+
567
+ PiiEntityTypes?: string;
568
+
569
+ LanguageModelName?: string;
570
+
571
+ IdentifyLanguage?: boolean;
572
+
573
+ LanguageOptions?: string;
574
+
575
+ PreferredLanguage?: LanguageCode | string;
576
+
577
+ VocabularyNames?: string;
578
+
579
+ VocabularyFilterNames?: string;
580
+ }
581
+
582
+ export declare const EntityFilterSensitiveLog: (obj: Entity) => any;
583
+
584
+ export declare const ItemFilterSensitiveLog: (obj: Item) => any;
585
+
586
+ export declare const AlternativeFilterSensitiveLog: (obj: Alternative) => any;
587
+
588
+ export declare const AudioEventFilterSensitiveLog: (obj: AudioEvent) => any;
589
+
590
+ export declare const AudioStreamFilterSensitiveLog: (obj: AudioStream) => any;
591
+
592
+ export declare const LanguageWithScoreFilterSensitiveLog: (
593
+ obj: LanguageWithScore
594
+ ) => any;
595
+
596
+ export declare const MedicalEntityFilterSensitiveLog: (
597
+ obj: MedicalEntity
598
+ ) => any;
599
+
600
+ export declare const MedicalItemFilterSensitiveLog: (obj: MedicalItem) => any;
601
+
602
+ export declare const MedicalAlternativeFilterSensitiveLog: (
603
+ obj: MedicalAlternative
604
+ ) => any;
605
+
606
+ export declare const MedicalResultFilterSensitiveLog: (
607
+ obj: MedicalResult
608
+ ) => any;
609
+
610
+ export declare const MedicalTranscriptFilterSensitiveLog: (
611
+ obj: MedicalTranscript
612
+ ) => any;
613
+
614
+ export declare const MedicalTranscriptEventFilterSensitiveLog: (
615
+ obj: MedicalTranscriptEvent
616
+ ) => any;
617
+
618
+ export declare const MedicalTranscriptResultStreamFilterSensitiveLog: (
619
+ obj: MedicalTranscriptResultStream
620
+ ) => any;
621
+
622
+ export declare const ResultFilterSensitiveLog: (obj: Result) => any;
623
+
624
+ export declare const StartMedicalStreamTranscriptionRequestFilterSensitiveLog: (
625
+ obj: StartMedicalStreamTranscriptionRequest
626
+ ) => any;
627
+
628
+ export declare const StartMedicalStreamTranscriptionResponseFilterSensitiveLog: (
629
+ obj: StartMedicalStreamTranscriptionResponse
630
+ ) => any;
631
+
632
+ export declare const StartStreamTranscriptionRequestFilterSensitiveLog: (
633
+ obj: StartStreamTranscriptionRequest
634
+ ) => any;
635
+
636
+ export declare const TranscriptFilterSensitiveLog: (obj: Transcript) => any;
637
+
638
+ export declare const TranscriptEventFilterSensitiveLog: (
639
+ obj: TranscriptEvent
640
+ ) => any;
641
+
642
+ export declare const TranscriptResultStreamFilterSensitiveLog: (
643
+ obj: TranscriptResultStream
644
+ ) => any;
645
+
646
+ export declare const StartStreamTranscriptionResponseFilterSensitiveLog: (
647
+ obj: StartStreamTranscriptionResponse
648
+ ) => any;