@aws-sdk/client-transcribe-streaming 3.50.0 → 3.53.0

package/dist-types/ts3.4/commands/StartStreamTranscriptionCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { StartStreamTranscriptionRequest, StartStreamTranscriptionResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TranscribeStreamingClientResolvedConfig } from "../TranscribeStreamingClient";
+export interface StartStreamTranscriptionCommandInput extends StartStreamTranscriptionRequest {
+}
+export interface StartStreamTranscriptionCommandOutput extends StartStreamTranscriptionResponse, __MetadataBearer {
+}
+
+export declare class StartStreamTranscriptionCommand extends $Command<StartStreamTranscriptionCommandInput, StartStreamTranscriptionCommandOutput, TranscribeStreamingClientResolvedConfig> {
+    readonly input: StartStreamTranscriptionCommandInput;
+    constructor(input: StartStreamTranscriptionCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TranscribeStreamingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartStreamTranscriptionCommandInput, StartStreamTranscriptionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./StartMedicalStreamTranscriptionCommand";
+export * from "./StartStreamTranscriptionCommand";

package/dist-types/ts3.4/endpoints.d.ts

@@ -0,0 +1,2 @@
+import { RegionInfoProvider } from "@aws-sdk/types";
+export declare const defaultRegionInfoProvider: RegionInfoProvider;

package/dist-types/ts3.4/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./TranscribeStreaming";
+export * from "./TranscribeStreamingClient";
+export * from "./commands";
+export * from "./models";
+export { TranscribeStreamingServiceException } from "./models/TranscribeStreamingServiceException";

package/dist-types/ts3.4/models/TranscribeStreamingServiceException.d.ts

@@ -0,0 +1,6 @@
+import { ServiceException as __ServiceException, ServiceExceptionOptions as __ServiceExceptionOptions } from "@aws-sdk/smithy-client";
+
+export declare class TranscribeStreamingServiceException extends __ServiceException {
+    
+    constructor(options: __ServiceExceptionOptions);
+}

package/dist-types/ts3.4/models/index.d.ts

@@ -0,0 +1 @@
+export * from "./models_0";

package/dist-types/ts3.4/models/models_0.d.ts

@@ -0,0 +1,653 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { TranscribeStreamingServiceException as __BaseException } from "./TranscribeStreamingServiceException";
+
+export interface Entity {
+    
+    StartTime?: number;
+    
+    EndTime?: number;
+    
+    Category?: string;
+    
+    Type?: string;
+    
+    Content?: string;
+    
+    Confidence?: number;
+}
+export declare namespace Entity {
+    
+    const filterSensitiveLog: (obj: Entity) => any;
+}
+export declare enum ItemType {
+    PRONUNCIATION = "pronunciation",
+    PUNCTUATION = "punctuation"
+}
+
+export interface Item {
+    
+    StartTime?: number;
+    
+    EndTime?: number;
+    
+    Type?: ItemType | string;
+    
+    Content?: string;
+    
+    VocabularyFilterMatch?: boolean;
+    
+    Speaker?: string;
+    
+    Confidence?: number;
+    
+    Stable?: boolean;
+}
+export declare namespace Item {
+    
+    const filterSensitiveLog: (obj: Item) => any;
+}
+
+export interface Alternative {
+    
+    Transcript?: string;
+    
+    Items?: Item[];
+    
+    Entities?: Entity[];
+}
+export declare namespace Alternative {
+    
+    const filterSensitiveLog: (obj: Alternative) => any;
+}
+
+export interface AudioEvent {
+    
+    AudioChunk?: Uint8Array;
+}
+export declare namespace AudioEvent {
+    
+    const filterSensitiveLog: (obj: AudioEvent) => any;
+}
+
+export declare type AudioStream = AudioStream.AudioEventMember | AudioStream.$UnknownMember;
+export declare namespace AudioStream {
+    
+    interface AudioEventMember {
+        AudioEvent: AudioEvent;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        AudioEvent?: never;
+        $unknown: [
+            string,
+            any
+        ];
+    }
+    interface Visitor<T> {
+        AudioEvent: (value: AudioEvent) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: AudioStream, visitor: Visitor<T>) => T;
+    
+    const filterSensitiveLog: (obj: AudioStream) => any;
+}
+
+export declare class BadRequestException extends __BaseException {
+    readonly name: "BadRequestException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<BadRequestException, __BaseException>);
+}
+
+export declare class ConflictException extends __BaseException {
+    readonly name: "ConflictException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ConflictException, __BaseException>);
+}
+export declare enum ContentIdentificationType {
+    PII = "PII"
+}
+export declare enum ContentRedactionType {
+    PII = "PII"
+}
+
+export declare class InternalFailureException extends __BaseException {
+    readonly name: "InternalFailureException";
+    readonly $fault: "server";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InternalFailureException, __BaseException>);
+}
+export declare enum LanguageCode {
+    DE_DE = "de-DE",
+    EN_AU = "en-AU",
+    EN_GB = "en-GB",
+    EN_US = "en-US",
+    ES_US = "es-US",
+    FR_CA = "fr-CA",
+    FR_FR = "fr-FR",
+    IT_IT = "it-IT",
+    JA_JP = "ja-JP",
+    KO_KR = "ko-KR",
+    PT_BR = "pt-BR",
+    ZH_CN = "zh-CN"
+}
+
+export interface LanguageWithScore {
+    
+    LanguageCode?: LanguageCode | string;
+    
+    Score?: number;
+}
+export declare namespace LanguageWithScore {
+    
+    const filterSensitiveLog: (obj: LanguageWithScore) => any;
+}
+
+export declare class LimitExceededException extends __BaseException {
+    readonly name: "LimitExceededException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<LimitExceededException, __BaseException>);
+}
+export declare enum MediaEncoding {
+    FLAC = "flac",
+    OGG_OPUS = "ogg-opus",
+    PCM = "pcm"
+}
+
+export interface MedicalEntity {
+    
+    StartTime?: number;
+    
+    EndTime?: number;
+    
+    Category?: string;
+    
+    Content?: string;
+    
+    Confidence?: number;
+}
+export declare namespace MedicalEntity {
+    
+    const filterSensitiveLog: (obj: MedicalEntity) => any;
+}
+
+export interface MedicalItem {
+    
+    StartTime?: number;
+    
+    EndTime?: number;
+    
+    Type?: ItemType | string;
+    
+    Content?: string;
+    
+    Confidence?: number;
+    
+    Speaker?: string;
+}
+export declare namespace MedicalItem {
+    
+    const filterSensitiveLog: (obj: MedicalItem) => any;
+}
+
+export interface MedicalAlternative {
+    
+    Transcript?: string;
+    
+    Items?: MedicalItem[];
+    
+    Entities?: MedicalEntity[];
+}
+export declare namespace MedicalAlternative {
+    
+    const filterSensitiveLog: (obj: MedicalAlternative) => any;
+}
+export declare enum MedicalContentIdentificationType {
+    PHI = "PHI"
+}
+
+export interface MedicalResult {
+    
+    ResultId?: string;
+    
+    StartTime?: number;
+    
+    EndTime?: number;
+    
+    IsPartial?: boolean;
+    
+    Alternatives?: MedicalAlternative[];
+    
+    ChannelId?: string;
+}
+export declare namespace MedicalResult {
+    
+    const filterSensitiveLog: (obj: MedicalResult) => any;
+}
+
+export interface MedicalTranscript {
+    
+    Results?: MedicalResult[];
+}
+export declare namespace MedicalTranscript {
+    
+    const filterSensitiveLog: (obj: MedicalTranscript) => any;
+}
+
+export interface MedicalTranscriptEvent {
+    
+    Transcript?: MedicalTranscript;
+}
+export declare namespace MedicalTranscriptEvent {
+    
+    const filterSensitiveLog: (obj: MedicalTranscriptEvent) => any;
+}
+
+export declare class ServiceUnavailableException extends __BaseException {
+    readonly name: "ServiceUnavailableException";
+    readonly $fault: "server";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ServiceUnavailableException, __BaseException>);
+}
+
+export declare type MedicalTranscriptResultStream = MedicalTranscriptResultStream.BadRequestExceptionMember | MedicalTranscriptResultStream.ConflictExceptionMember | MedicalTranscriptResultStream.InternalFailureExceptionMember | MedicalTranscriptResultStream.LimitExceededExceptionMember | MedicalTranscriptResultStream.ServiceUnavailableExceptionMember | MedicalTranscriptResultStream.TranscriptEventMember | MedicalTranscriptResultStream.$UnknownMember;
+export declare namespace MedicalTranscriptResultStream {
+    
+    interface TranscriptEventMember {
+        TranscriptEvent: MedicalTranscriptEvent;
+        BadRequestException?: never;
+        LimitExceededException?: never;
+        InternalFailureException?: never;
+        ConflictException?: never;
+        ServiceUnavailableException?: never;
+        $unknown?: never;
+    }
+    
+    interface BadRequestExceptionMember {
+        TranscriptEvent?: never;
+        BadRequestException: BadRequestException;
+        LimitExceededException?: never;
+        InternalFailureException?: never;
+        ConflictException?: never;
+        ServiceUnavailableException?: never;
+        $unknown?: never;
+    }
+    
+    interface LimitExceededExceptionMember {
+        TranscriptEvent?: never;
+        BadRequestException?: never;
+        LimitExceededException: LimitExceededException;
+        InternalFailureException?: never;
+        ConflictException?: never;
+        ServiceUnavailableException?: never;
+        $unknown?: never;
+    }
+    
+    interface InternalFailureExceptionMember {
+        TranscriptEvent?: never;
+        BadRequestException?: never;
+        LimitExceededException?: never;
+        InternalFailureException: InternalFailureException;
+        ConflictException?: never;
+        ServiceUnavailableException?: never;
+        $unknown?: never;
+    }
+    
+    interface ConflictExceptionMember {
+        TranscriptEvent?: never;
+        BadRequestException?: never;
+        LimitExceededException?: never;
+        InternalFailureException?: never;
+        ConflictException: ConflictException;
+        ServiceUnavailableException?: never;
+        $unknown?: never;
+    }
+    
+    interface ServiceUnavailableExceptionMember {
+        TranscriptEvent?: never;
+        BadRequestException?: never;
+        LimitExceededException?: never;
+        InternalFailureException?: never;
+        ConflictException?: never;
+        ServiceUnavailableException: ServiceUnavailableException;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        TranscriptEvent?: never;
+        BadRequestException?: never;
+        LimitExceededException?: never;
+        InternalFailureException?: never;
+        ConflictException?: never;
+        ServiceUnavailableException?: never;
+        $unknown: [
+            string,
+            any
+        ];
+    }
+    interface Visitor<T> {
+        TranscriptEvent: (value: MedicalTranscriptEvent) => T;
+        BadRequestException: (value: BadRequestException) => T;
+        LimitExceededException: (value: LimitExceededException) => T;
+        InternalFailureException: (value: InternalFailureException) => T;
+        ConflictException: (value: ConflictException) => T;
+        ServiceUnavailableException: (value: ServiceUnavailableException) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: MedicalTranscriptResultStream, visitor: Visitor<T>) => T;
+    
+    const filterSensitiveLog: (obj: MedicalTranscriptResultStream) => any;
+}
+export declare enum PartialResultsStability {
+    HIGH = "high",
+    LOW = "low",
+    MEDIUM = "medium"
+}
+
+export interface Result {
+    
+    ResultId?: string;
+    
+    StartTime?: number;
+    
+    EndTime?: number;
+    
+    IsPartial?: boolean;
+    
+    Alternatives?: Alternative[];
+    
+    ChannelId?: string;
+    
+    LanguageCode?: LanguageCode | string;
+    
+    LanguageIdentification?: LanguageWithScore[];
+}
+export declare namespace Result {
+    
+    const filterSensitiveLog: (obj: Result) => any;
+}
+export declare enum Specialty {
+    CARDIOLOGY = "CARDIOLOGY",
+    NEUROLOGY = "NEUROLOGY",
+    ONCOLOGY = "ONCOLOGY",
+    PRIMARYCARE = "PRIMARYCARE",
+    RADIOLOGY = "RADIOLOGY",
+    UROLOGY = "UROLOGY"
+}
+export declare enum Type {
+    CONVERSATION = "CONVERSATION",
+    DICTATION = "DICTATION"
+}
+export interface StartMedicalStreamTranscriptionRequest {
+    
+    LanguageCode: LanguageCode | string | undefined;
+    
+    MediaSampleRateHertz: number | undefined;
+    
+    MediaEncoding: MediaEncoding | string | undefined;
+    
+    VocabularyName?: string;
+    
+    Specialty: Specialty | string | undefined;
+    
+    Type: Type | string | undefined;
+    
+    ShowSpeakerLabel?: boolean;
+    
+    SessionId?: string;
+    
+    AudioStream: AsyncIterable<AudioStream> | undefined;
+    
+    EnableChannelIdentification?: boolean;
+    
+    NumberOfChannels?: number;
+    
+    ContentIdentificationType?: MedicalContentIdentificationType | string;
+}
+export declare namespace StartMedicalStreamTranscriptionRequest {
+    
+    const filterSensitiveLog: (obj: StartMedicalStreamTranscriptionRequest) => any;
+}
+export interface StartMedicalStreamTranscriptionResponse {
+    
+    RequestId?: string;
+    
+    LanguageCode?: LanguageCode | string;
+    
+    MediaSampleRateHertz?: number;
+    
+    MediaEncoding?: MediaEncoding | string;
+    
+    VocabularyName?: string;
+    
+    Specialty?: Specialty | string;
+    
+    Type?: Type | string;
+    
+    ShowSpeakerLabel?: boolean;
+    
+    SessionId?: string;
+    
+    TranscriptResultStream?: AsyncIterable<MedicalTranscriptResultStream>;
+    
+    EnableChannelIdentification?: boolean;
+    
+    NumberOfChannels?: number;
+    
+    ContentIdentificationType?: MedicalContentIdentificationType | string;
+}
+export declare namespace StartMedicalStreamTranscriptionResponse {
+    
+    const filterSensitiveLog: (obj: StartMedicalStreamTranscriptionResponse) => any;
+}
+export declare enum VocabularyFilterMethod {
+    MASK = "mask",
+    REMOVE = "remove",
+    TAG = "tag"
+}
+export interface StartStreamTranscriptionRequest {
+    
+    LanguageCode?: LanguageCode | string;
+    
+    MediaSampleRateHertz: number | undefined;
+    
+    MediaEncoding: MediaEncoding | string | undefined;
+    
+    VocabularyName?: string;
+    
+    SessionId?: string;
+    
+    AudioStream: AsyncIterable<AudioStream> | undefined;
+    
+    VocabularyFilterName?: string;
+    
+    VocabularyFilterMethod?: VocabularyFilterMethod | string;
+    
+    ShowSpeakerLabel?: boolean;
+    
+    EnableChannelIdentification?: boolean;
+    
+    NumberOfChannels?: number;
+    
+    EnablePartialResultsStabilization?: boolean;
+    
+    PartialResultsStability?: PartialResultsStability | string;
+    
+    ContentIdentificationType?: ContentIdentificationType | string;
+    
+    ContentRedactionType?: ContentRedactionType | string;
+    
+    PiiEntityTypes?: string;
+    
+    LanguageModelName?: string;
+    
+    IdentifyLanguage?: boolean;
+    
+    LanguageOptions?: string;
+    
+    PreferredLanguage?: LanguageCode | string;
+}
+export declare namespace StartStreamTranscriptionRequest {
+    
+    const filterSensitiveLog: (obj: StartStreamTranscriptionRequest) => any;
+}
+
+export interface Transcript {
+    
+    Results?: Result[];
+}
+export declare namespace Transcript {
+    
+    const filterSensitiveLog: (obj: Transcript) => any;
+}
+
+export interface TranscriptEvent {
+    
+    Transcript?: Transcript;
+}
+export declare namespace TranscriptEvent {
+    
+    const filterSensitiveLog: (obj: TranscriptEvent) => any;
+}
+
+export declare type TranscriptResultStream = TranscriptResultStream.BadRequestExceptionMember | TranscriptResultStream.ConflictExceptionMember | TranscriptResultStream.InternalFailureExceptionMember | TranscriptResultStream.LimitExceededExceptionMember | TranscriptResultStream.ServiceUnavailableExceptionMember | TranscriptResultStream.TranscriptEventMember | TranscriptResultStream.$UnknownMember;
+export declare namespace TranscriptResultStream {
+    
+    interface TranscriptEventMember {
+        TranscriptEvent: TranscriptEvent;
+        BadRequestException?: never;
+        LimitExceededException?: never;
+        InternalFailureException?: never;
+        ConflictException?: never;
+        ServiceUnavailableException?: never;
+        $unknown?: never;
+    }
+    
+    interface BadRequestExceptionMember {
+        TranscriptEvent?: never;
+        BadRequestException: BadRequestException;
+        LimitExceededException?: never;
+        InternalFailureException?: never;
+        ConflictException?: never;
+        ServiceUnavailableException?: never;
+        $unknown?: never;
+    }
+    
+    interface LimitExceededExceptionMember {
+        TranscriptEvent?: never;
+        BadRequestException?: never;
+        LimitExceededException: LimitExceededException;
+        InternalFailureException?: never;
+        ConflictException?: never;
+        ServiceUnavailableException?: never;
+        $unknown?: never;
+    }
+    
+    interface InternalFailureExceptionMember {
+        TranscriptEvent?: never;
+        BadRequestException?: never;
+        LimitExceededException?: never;
+        InternalFailureException: InternalFailureException;
+        ConflictException?: never;
+        ServiceUnavailableException?: never;
+        $unknown?: never;
+    }
+    
+    interface ConflictExceptionMember {
+        TranscriptEvent?: never;
+        BadRequestException?: never;
+        LimitExceededException?: never;
+        InternalFailureException?: never;
+        ConflictException: ConflictException;
+        ServiceUnavailableException?: never;
+        $unknown?: never;
+    }
+    
+    interface ServiceUnavailableExceptionMember {
+        TranscriptEvent?: never;
+        BadRequestException?: never;
+        LimitExceededException?: never;
+        InternalFailureException?: never;
+        ConflictException?: never;
+        ServiceUnavailableException: ServiceUnavailableException;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        TranscriptEvent?: never;
+        BadRequestException?: never;
+        LimitExceededException?: never;
+        InternalFailureException?: never;
+        ConflictException?: never;
+        ServiceUnavailableException?: never;
+        $unknown: [
+            string,
+            any
+        ];
+    }
+    interface Visitor<T> {
+        TranscriptEvent: (value: TranscriptEvent) => T;
+        BadRequestException: (value: BadRequestException) => T;
+        LimitExceededException: (value: LimitExceededException) => T;
+        InternalFailureException: (value: InternalFailureException) => T;
+        ConflictException: (value: ConflictException) => T;
+        ServiceUnavailableException: (value: ServiceUnavailableException) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: TranscriptResultStream, visitor: Visitor<T>) => T;
+    
+    const filterSensitiveLog: (obj: TranscriptResultStream) => any;
+}
+export interface StartStreamTranscriptionResponse {
+    
+    RequestId?: string;
+    
+    LanguageCode?: LanguageCode | string;
+    
+    MediaSampleRateHertz?: number;
+    
+    MediaEncoding?: MediaEncoding | string;
+    
+    VocabularyName?: string;
+    
+    SessionId?: string;
+    
+    TranscriptResultStream?: AsyncIterable<TranscriptResultStream>;
+    
+    VocabularyFilterName?: string;
+    
+    VocabularyFilterMethod?: VocabularyFilterMethod | string;
+    
+    ShowSpeakerLabel?: boolean;
+    
+    EnableChannelIdentification?: boolean;
+    
+    NumberOfChannels?: number;
+    
+    EnablePartialResultsStabilization?: boolean;
+    
+    PartialResultsStability?: PartialResultsStability | string;
+    
+    ContentIdentificationType?: ContentIdentificationType | string;
+    
+    ContentRedactionType?: ContentRedactionType | string;
+    
+    PiiEntityTypes?: string;
+    
+    LanguageModelName?: string;
+    
+    IdentifyLanguage?: boolean;
+    
+    LanguageOptions?: string;
+    
+    PreferredLanguage?: LanguageCode | string;
+}
+export declare namespace StartStreamTranscriptionResponse {
+    
+    const filterSensitiveLog: (obj: StartStreamTranscriptionResponse) => any;
+}

package/dist-types/ts3.4/protocols/Aws_restJson1.d.ts

@@ -0,0 +1,8 @@
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { EventStreamSerdeContext as __EventStreamSerdeContext, SerdeContext as __SerdeContext } from "@aws-sdk/types";
+import { StartMedicalStreamTranscriptionCommandInput, StartMedicalStreamTranscriptionCommandOutput } from "../commands/StartMedicalStreamTranscriptionCommand";
+import { StartStreamTranscriptionCommandInput, StartStreamTranscriptionCommandOutput } from "../commands/StartStreamTranscriptionCommand";
+export declare const serializeAws_restJson1StartMedicalStreamTranscriptionCommand: (input: StartMedicalStreamTranscriptionCommandInput, context: __SerdeContext & __EventStreamSerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_restJson1StartStreamTranscriptionCommand: (input: StartStreamTranscriptionCommandInput, context: __SerdeContext & __EventStreamSerdeContext) => Promise<__HttpRequest>;
+export declare const deserializeAws_restJson1StartMedicalStreamTranscriptionCommand: (output: __HttpResponse, context: __SerdeContext & __EventStreamSerdeContext) => Promise<StartMedicalStreamTranscriptionCommandOutput>;
+export declare const deserializeAws_restJson1StartStreamTranscriptionCommand: (output: __HttpResponse, context: __SerdeContext & __EventStreamSerdeContext) => Promise<StartStreamTranscriptionCommandOutput>;