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