import * as HttpClient from "effect/unstable/http/HttpClient";
import * as S from "effect/Schema";
import * as stream from "effect/Stream";
import * as API from "../client/api.js";
import * as T from "../traits.js";
import * as C from "../category.js";
const svc = T.AwsApiService({
    sdkId: "Transcribe Streaming",
    serviceShapeName: "Transcribe",
});
const auth = T.AwsAuthSigv4({ name: "transcribe" });
const ver = T.ServiceVersion("2017-10-26");
const proto = T.AwsProtocolsRestJson1();
const rules = T.EndpointResolver((p, _) => {
    const { Region, UseDualStack = false, UseFIPS = false, Endpoint } = p;
    const e = (u, p = {}, h = {}) => ({
        type: "endpoint",
        endpoint: { url: u, properties: p, headers: h },
    });
    const err = (m) => ({
        type: "error",
        message: m,
    });
    if (Endpoint != null) {
        if (UseFIPS === true) {
            return err("Invalid Configuration: FIPS and custom endpoint are not supported");
        }
        if (UseDualStack === true) {
            return err("Invalid Configuration: Dualstack and custom endpoint are not supported");
        }
        return e(Endpoint);
    }
    if (Region != null) {
        {
            const PartitionResult = _.partition(Region);
            if (PartitionResult != null && PartitionResult !== false) {
                if (UseFIPS === true && UseDualStack === true) {
                    if (true === _.getAttr(PartitionResult, "supportsFIPS") &&
                        true === _.getAttr(PartitionResult, "supportsDualStack")) {
                        return e(`https://transcribestreaming-fips.${Region}.${_.getAttr(PartitionResult, "dualStackDnsSuffix")}`);
                    }
                    return err("FIPS and DualStack are enabled, but this partition does not support one or both");
                }
                if (UseFIPS === true) {
                    if (_.getAttr(PartitionResult, "supportsFIPS") === true) {
                        return e(`https://transcribestreaming-fips.${Region}.${_.getAttr(PartitionResult, "dnsSuffix")}`);
                    }
                    return err("FIPS is enabled but this partition does not support FIPS");
                }
                if (UseDualStack === true) {
                    if (true === _.getAttr(PartitionResult, "supportsDualStack")) {
                        return e(`https://transcribestreaming.${Region}.${_.getAttr(PartitionResult, "dualStackDnsSuffix")}`);
                    }
                    return err("DualStack is enabled but this partition does not support DualStack");
                }
                return e(`https://transcribestreaming.${Region}.${_.getAttr(PartitionResult, "dnsSuffix")}`);
            }
        }
    }
    return err("Invalid Configuration: Missing Region");
});
export const GetMedicalScribeStreamRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ SessionId: S.String.pipe(T.HttpLabel("SessionId")) }).pipe(T.all(T.Http({ method: "GET", uri: "/medical-scribe-stream/{SessionId}" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetMedicalScribeStreamRequest",
});
export const MedicalScribeLanguageCode = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const MedicalScribeMediaEncoding = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const MedicalScribeVocabularyFilterMethod = 
/*@__PURE__*/ /*#__PURE__*/ S.String;
export const MedicalScribeParticipantRole = 
/*@__PURE__*/ /*#__PURE__*/ S.String;
export const MedicalScribeChannelDefinition = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ChannelId: S.Number,
    ParticipantRole: MedicalScribeParticipantRole,
})).annotate({
    identifier: "MedicalScribeChannelDefinition",
});
export const MedicalScribeChannelDefinitions = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(MedicalScribeChannelDefinition);
export const KMSEncryptionContextMap = /*@__PURE__*/ /*#__PURE__*/ S.Record(S.String, S.String.pipe(S.optional));
export const MedicalScribeEncryptionSettings = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    KmsEncryptionContext: S.optional(KMSEncryptionContextMap),
    KmsKeyId: S.String,
})).annotate({
    identifier: "MedicalScribeEncryptionSettings",
});
export const MedicalScribeStreamStatus = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const MedicalScribeNoteTemplate = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const ClinicalNoteGenerationSettings = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    OutputBucketName: S.String,
    NoteTemplate: S.optional(MedicalScribeNoteTemplate),
})).annotate({
    identifier: "ClinicalNoteGenerationSettings",
});
export const MedicalScribePostStreamAnalyticsSettings = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ClinicalNoteGenerationSettings: ClinicalNoteGenerationSettings,
})).annotate({
    identifier: "MedicalScribePostStreamAnalyticsSettings",
});
export const ClinicalNoteGenerationStatus = 
/*@__PURE__*/ /*#__PURE__*/ S.String;
export const ClinicalNoteGenerationResult = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ClinicalNoteOutputLocation: S.optional(S.String),
    TranscriptOutputLocation: S.optional(S.String),
    Status: S.optional(ClinicalNoteGenerationStatus),
    FailureReason: S.optional(S.String),
})).annotate({
    identifier: "ClinicalNoteGenerationResult",
});
export const MedicalScribePostStreamAnalyticsResult = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ClinicalNoteGenerationResult: S.optional(ClinicalNoteGenerationResult),
})).annotate({
    identifier: "MedicalScribePostStreamAnalyticsResult",
});
export const MedicalScribeStreamDetails = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    SessionId: S.optional(S.String),
    StreamCreatedAt: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    StreamEndedAt: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    LanguageCode: S.optional(MedicalScribeLanguageCode),
    MediaSampleRateHertz: S.optional(S.Number),
    MediaEncoding: S.optional(MedicalScribeMediaEncoding),
    VocabularyName: S.optional(S.String),
    VocabularyFilterName: S.optional(S.String),
    VocabularyFilterMethod: S.optional(MedicalScribeVocabularyFilterMethod),
    ResourceAccessRoleArn: S.optional(S.String),
    ChannelDefinitions: S.optional(MedicalScribeChannelDefinitions),
    EncryptionSettings: S.optional(MedicalScribeEncryptionSettings),
    StreamStatus: S.optional(MedicalScribeStreamStatus),
    PostStreamAnalyticsSettings: S.optional(MedicalScribePostStreamAnalyticsSettings),
    PostStreamAnalyticsResult: S.optional(MedicalScribePostStreamAnalyticsResult),
    MedicalScribeContextProvided: S.optional(S.Boolean),
})).annotate({
    identifier: "MedicalScribeStreamDetails",
});
export const GetMedicalScribeStreamResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    MedicalScribeStreamDetails: S.optional(MedicalScribeStreamDetails),
})).annotate({
    identifier: "GetMedicalScribeStreamResponse",
});
export const CallAnalyticsLanguageCode = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const MediaEncoding = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const AudioEvent = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ AudioChunk: S.optional(T.Blob).pipe(T.EventPayload()) })).annotate({ identifier: "AudioEvent" });
export const ParticipantRole = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const ChannelDefinition = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ChannelId: S.Number, ParticipantRole: ParticipantRole })).annotate({
    identifier: "ChannelDefinition",
});
export const ChannelDefinitions = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(ChannelDefinition);
export const ContentRedactionOutput = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const PostCallAnalyticsSettings = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    OutputLocation: S.String,
    DataAccessRoleArn: S.String,
    ContentRedactionOutput: S.optional(ContentRedactionOutput),
    OutputEncryptionKMSKeyId: S.optional(S.String),
})).annotate({
    identifier: "PostCallAnalyticsSettings",
});
export const ConfigurationEvent = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ChannelDefinitions: S.optional(ChannelDefinitions),
    PostCallAnalyticsSettings: S.optional(PostCallAnalyticsSettings),
})).annotate({
    identifier: "ConfigurationEvent",
});
export const AudioStream = /*@__PURE__*/ /*#__PURE__*/ T.InputEventStream(S.Union([
    S.Struct({ AudioEvent: AudioEvent }),
    S.Struct({ ConfigurationEvent: ConfigurationEvent }),
]));
export const VocabularyFilterMethod = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const PartialResultsStability = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const ContentIdentificationType = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const ContentRedactionType = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const StartCallAnalyticsStreamTranscriptionRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    LanguageCode: S.optional(CallAnalyticsLanguageCode).pipe(T.HttpHeader("x-amzn-transcribe-language-code")),
    MediaSampleRateHertz: S.Number.pipe(T.HttpHeader("x-amzn-transcribe-sample-rate")),
    MediaEncoding: MediaEncoding.pipe(T.HttpHeader("x-amzn-transcribe-media-encoding")),
    VocabularyName: S.optional(S.String).pipe(T.HttpHeader("x-amzn-transcribe-vocabulary-name")),
    SessionId: S.optional(S.String).pipe(T.HttpHeader("x-amzn-transcribe-session-id")),
    AudioStream: AudioStream.pipe(T.HttpPayload()),
    VocabularyFilterName: S.optional(S.String).pipe(T.HttpHeader("x-amzn-transcribe-vocabulary-filter-name")),
    VocabularyFilterMethod: S.optional(VocabularyFilterMethod).pipe(T.HttpHeader("x-amzn-transcribe-vocabulary-filter-method")),
    LanguageModelName: S.optional(S.String).pipe(T.HttpHeader("x-amzn-transcribe-language-model-name")),
    IdentifyLanguage: S.optional(S.Boolean).pipe(T.HttpHeader("x-amzn-transcribe-identify-language")),
    LanguageOptions: S.optional(S.String).pipe(T.HttpHeader("x-amzn-transcribe-language-options")),
    PreferredLanguage: S.optional(CallAnalyticsLanguageCode).pipe(T.HttpHeader("x-amzn-transcribe-preferred-language")),
    VocabularyNames: S.optional(S.String).pipe(T.HttpHeader("x-amzn-transcribe-vocabulary-names")),
    VocabularyFilterNames: S.optional(S.String).pipe(T.HttpHeader("x-amzn-transcribe-vocabulary-filter-names")),
    EnablePartialResultsStabilization: S.optional(S.Boolean).pipe(T.HttpHeader("x-amzn-transcribe-enable-partial-results-stabilization")),
    PartialResultsStability: S.optional(PartialResultsStability).pipe(T.HttpHeader("x-amzn-transcribe-partial-results-stability")),
    ContentIdentificationType: S.optional(ContentIdentificationType).pipe(T.HttpHeader("x-amzn-transcribe-content-identification-type")),
    ContentRedactionType: S.optional(ContentRedactionType).pipe(T.HttpHeader("x-amzn-transcribe-content-redaction-type")),
    PiiEntityTypes: S.optional(S.String).pipe(T.HttpHeader("x-amzn-transcribe-pii-entity-types")),
}).pipe(T.all(T.Http({ method: "POST", uri: "/call-analytics-stream-transcription" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "StartCallAnalyticsStreamTranscriptionRequest",
});
export const ItemType = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const CallAnalyticsItem = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    BeginOffsetMillis: S.optional(S.Number),
    EndOffsetMillis: S.optional(S.Number),
    Type: S.optional(ItemType),
    Content: S.optional(S.String),
    Confidence: S.optional(S.Number),
    VocabularyFilterMatch: S.optional(S.Boolean),
    Stable: S.optional(S.Boolean),
})).annotate({
    identifier: "CallAnalyticsItem",
});
export const CallAnalyticsItemList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(CallAnalyticsItem);
export const CallAnalyticsEntity = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    BeginOffsetMillis: S.optional(S.Number),
    EndOffsetMillis: S.optional(S.Number),
    Category: S.optional(S.String),
    Type: S.optional(S.String),
    Content: S.optional(S.String),
    Confidence: S.optional(S.Number),
})).annotate({
    identifier: "CallAnalyticsEntity",
});
export const CallAnalyticsEntityList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(CallAnalyticsEntity);
export const Sentiment = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const CharacterOffsets = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Begin: S.optional(S.Number), End: S.optional(S.Number) })).annotate({
    identifier: "CharacterOffsets",
});
export const IssueDetected = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ CharacterOffsets: S.optional(CharacterOffsets) })).annotate({ identifier: "IssueDetected" });
export const IssuesDetected = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(IssueDetected);
export const CallAnalyticsLanguageWithScore = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    LanguageCode: S.optional(CallAnalyticsLanguageCode),
    Score: S.optional(S.Number),
})).annotate({
    identifier: "CallAnalyticsLanguageWithScore",
});
export const CallAnalyticsLanguageIdentification = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(CallAnalyticsLanguageWithScore);
export const UtteranceEvent = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    UtteranceId: S.optional(S.String),
    IsPartial: S.optional(S.Boolean),
    ParticipantRole: S.optional(ParticipantRole),
    BeginOffsetMillis: S.optional(S.Number),
    EndOffsetMillis: S.optional(S.Number),
    Transcript: S.optional(S.String),
    Items: S.optional(CallAnalyticsItemList),
    Entities: S.optional(CallAnalyticsEntityList),
    Sentiment: S.optional(Sentiment),
    IssuesDetected: S.optional(IssuesDetected),
    LanguageCode: S.optional(CallAnalyticsLanguageCode),
    LanguageIdentification: S.optional(CallAnalyticsLanguageIdentification),
})).annotate({ identifier: "UtteranceEvent" });
export const StringList = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const TimestampRange = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    BeginOffsetMillis: S.optional(S.Number),
    EndOffsetMillis: S.optional(S.Number),
})).annotate({ identifier: "TimestampRange" });
export const TimestampRanges = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(TimestampRange);
export const PointsOfInterest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ TimestampRanges: S.optional(TimestampRanges) })).annotate({
    identifier: "PointsOfInterest",
});
export const MatchedCategoryDetails = /*@__PURE__*/ /*#__PURE__*/ S.Record(S.String, PointsOfInterest.pipe(S.optional));
export const CategoryEvent = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    MatchedCategories: S.optional(StringList),
    MatchedDetails: S.optional(MatchedCategoryDetails),
})).annotate({ identifier: "CategoryEvent" });
export const CallAnalyticsTranscriptResultStream = 
/*@__PURE__*/ /*#__PURE__*/ T.EventStream(S.Union([
    S.Struct({ UtteranceEvent: UtteranceEvent }),
    S.Struct({ CategoryEvent: CategoryEvent }),
    S.Struct({
        BadRequestException: S.suspend(() => BadRequestException).annotate({
            identifier: "BadRequestException",
        }),
    }),
    S.Struct({
        LimitExceededException: S.suspend(() => LimitExceededException).annotate({ identifier: "LimitExceededException" }),
    }),
    S.Struct({
        InternalFailureException: S.suspend(() => InternalFailureException).annotate({ identifier: "InternalFailureException" }),
    }),
    S.Struct({
        ConflictException: S.suspend(() => ConflictException).annotate({
            identifier: "ConflictException",
        }),
    }),
    S.Struct({
        ServiceUnavailableException: S.suspend(() => ServiceUnavailableException).annotate({ identifier: "ServiceUnavailableException" }),
    }),
]));
export const StartCallAnalyticsStreamTranscriptionResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    RequestId: S.optional(S.String).pipe(T.HttpHeader("x-amzn-request-id")),
    LanguageCode: S.optional(CallAnalyticsLanguageCode).pipe(T.HttpHeader("x-amzn-transcribe-language-code")),
    MediaSampleRateHertz: S.optional(S.Number).pipe(T.HttpHeader("x-amzn-transcribe-sample-rate")),
    MediaEncoding: S.optional(MediaEncoding).pipe(T.HttpHeader("x-amzn-transcribe-media-encoding")),
    VocabularyName: S.optional(S.String).pipe(T.HttpHeader("x-amzn-transcribe-vocabulary-name")),
    SessionId: S.optional(S.String).pipe(T.HttpHeader("x-amzn-transcribe-session-id")),
    CallAnalyticsTranscriptResultStream: S.optional(CallAnalyticsTranscriptResultStream).pipe(T.HttpPayload()),
    VocabularyFilterName: S.optional(S.String).pipe(T.HttpHeader("x-amzn-transcribe-vocabulary-filter-name")),
    VocabularyFilterMethod: S.optional(VocabularyFilterMethod).pipe(T.HttpHeader("x-amzn-transcribe-vocabulary-filter-method")),
    LanguageModelName: S.optional(S.String).pipe(T.HttpHeader("x-amzn-transcribe-language-model-name")),
    IdentifyLanguage: S.optional(S.Boolean).pipe(T.HttpHeader("x-amzn-transcribe-identify-language")),
    LanguageOptions: S.optional(S.String).pipe(T.HttpHeader("x-amzn-transcribe-language-options")),
    PreferredLanguage: S.optional(CallAnalyticsLanguageCode).pipe(T.HttpHeader("x-amzn-transcribe-preferred-language")),
    VocabularyNames: S.optional(S.String).pipe(T.HttpHeader("x-amzn-transcribe-vocabulary-names")),
    VocabularyFilterNames: S.optional(S.String).pipe(T.HttpHeader("x-amzn-transcribe-vocabulary-filter-names")),
    EnablePartialResultsStabilization: S.optional(S.Boolean).pipe(T.HttpHeader("x-amzn-transcribe-enable-partial-results-stabilization")),
    PartialResultsStability: S.optional(PartialResultsStability).pipe(T.HttpHeader("x-amzn-transcribe-partial-results-stability")),
    ContentIdentificationType: S.optional(ContentIdentificationType).pipe(T.HttpHeader("x-amzn-transcribe-content-identification-type")),
    ContentRedactionType: S.optional(ContentRedactionType).pipe(T.HttpHeader("x-amzn-transcribe-content-redaction-type")),
    PiiEntityTypes: S.optional(S.String).pipe(T.HttpHeader("x-amzn-transcribe-pii-entity-types")),
})).annotate({
    identifier: "StartCallAnalyticsStreamTranscriptionResponse",
});
export const MedicalScribeAudioEvent = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ AudioChunk: T.Blob.pipe(T.EventPayload()) })).annotate({
    identifier: "MedicalScribeAudioEvent",
});
export const MedicalScribeSessionControlEventType = 
/*@__PURE__*/ /*#__PURE__*/ S.String;
export const MedicalScribeSessionControlEvent = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Type: MedicalScribeSessionControlEventType })).annotate({
    identifier: "MedicalScribeSessionControlEvent",
});
export const Pronouns = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const MedicalScribePatientContext = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Pronouns: S.optional(Pronouns) })).annotate({
    identifier: "MedicalScribePatientContext",
});
export const MedicalScribeContext = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ PatientContext: S.optional(MedicalScribePatientContext) })).annotate({
    identifier: "MedicalScribeContext",
});
export const MedicalScribeConfigurationEvent = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    VocabularyName: S.optional(S.String),
    VocabularyFilterName: S.optional(S.String),
    VocabularyFilterMethod: S.optional(MedicalScribeVocabularyFilterMethod),
    ResourceAccessRoleArn: S.String,
    ChannelDefinitions: S.optional(MedicalScribeChannelDefinitions),
    EncryptionSettings: S.optional(MedicalScribeEncryptionSettings),
    PostStreamAnalyticsSettings: MedicalScribePostStreamAnalyticsSettings,
    MedicalScribeContext: S.optional(MedicalScribeContext),
})).annotate({
    identifier: "MedicalScribeConfigurationEvent",
});
export const MedicalScribeInputStream = 
/*@__PURE__*/ /*#__PURE__*/ T.InputEventStream(S.Union([
    S.Struct({ AudioEvent: MedicalScribeAudioEvent }),
    S.Struct({ SessionControlEvent: MedicalScribeSessionControlEvent }),
    S.Struct({ ConfigurationEvent: MedicalScribeConfigurationEvent }),
]));
export const StartMedicalScribeStreamRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    SessionId: S.optional(S.String).pipe(T.HttpHeader("x-amzn-transcribe-session-id")),
    LanguageCode: MedicalScribeLanguageCode.pipe(T.HttpHeader("x-amzn-transcribe-language-code")),
    MediaSampleRateHertz: S.Number.pipe(T.HttpHeader("x-amzn-transcribe-sample-rate")),
    MediaEncoding: MedicalScribeMediaEncoding.pipe(T.HttpHeader("x-amzn-transcribe-media-encoding")),
    InputStream: MedicalScribeInputStream.pipe(T.HttpPayload()),
}).pipe(T.all(T.Http({ method: "POST", uri: "/medical-scribe-stream" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "StartMedicalScribeStreamRequest",
});
export const MedicalScribeTranscriptItemType = 
/*@__PURE__*/ /*#__PURE__*/ S.String;
export const MedicalScribeTranscriptItem = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    BeginAudioTime: S.optional(S.Number),
    EndAudioTime: S.optional(S.Number),
    Type: S.optional(MedicalScribeTranscriptItemType),
    Confidence: S.optional(S.Number),
    Content: S.optional(S.String),
    VocabularyFilterMatch: S.optional(S.Boolean),
})).annotate({
    identifier: "MedicalScribeTranscriptItem",
});
export const MedicalScribeTranscriptItemList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(MedicalScribeTranscriptItem);
export const MedicalScribeTranscriptSegment = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    SegmentId: S.optional(S.String),
    BeginAudioTime: S.optional(S.Number),
    EndAudioTime: S.optional(S.Number),
    Content: S.optional(S.String),
    Items: S.optional(MedicalScribeTranscriptItemList),
    IsPartial: S.optional(S.Boolean),
    ChannelId: S.optional(S.String),
})).annotate({
    identifier: "MedicalScribeTranscriptSegment",
});
export const MedicalScribeTranscriptEvent = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ TranscriptSegment: S.optional(MedicalScribeTranscriptSegment) })).annotate({
    identifier: "MedicalScribeTranscriptEvent",
});
export const MedicalScribeResultStream = 
/*@__PURE__*/ /*#__PURE__*/ T.EventStream(S.Union([
    S.Struct({ TranscriptEvent: MedicalScribeTranscriptEvent }),
    S.Struct({
        BadRequestException: S.suspend(() => BadRequestException).annotate({
            identifier: "BadRequestException",
        }),
    }),
    S.Struct({
        LimitExceededException: S.suspend(() => LimitExceededException).annotate({ identifier: "LimitExceededException" }),
    }),
    S.Struct({
        InternalFailureException: S.suspend(() => InternalFailureException).annotate({ identifier: "InternalFailureException" }),
    }),
    S.Struct({
        ConflictException: S.suspend(() => ConflictException).annotate({
            identifier: "ConflictException",
        }),
    }),
    S.Struct({
        ServiceUnavailableException: S.suspend(() => ServiceUnavailableException).annotate({ identifier: "ServiceUnavailableException" }),
    }),
]));
export const StartMedicalScribeStreamResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    SessionId: S.optional(S.String).pipe(T.HttpHeader("x-amzn-transcribe-session-id")),
    RequestId: S.optional(S.String).pipe(T.HttpHeader("x-amzn-request-id")),
    LanguageCode: S.optional(MedicalScribeLanguageCode).pipe(T.HttpHeader("x-amzn-transcribe-language-code")),
    MediaSampleRateHertz: S.optional(S.Number).pipe(T.HttpHeader("x-amzn-transcribe-sample-rate")),
    MediaEncoding: S.optional(MedicalScribeMediaEncoding).pipe(T.HttpHeader("x-amzn-transcribe-media-encoding")),
    ResultStream: S.optional(MedicalScribeResultStream).pipe(T.HttpPayload()),
})).annotate({
    identifier: "StartMedicalScribeStreamResponse",
});
export const LanguageCode = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const Specialty = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const Type = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const MedicalContentIdentificationType = 
/*@__PURE__*/ /*#__PURE__*/ S.String;
export const StartMedicalStreamTranscriptionRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    LanguageCode: LanguageCode.pipe(T.HttpHeader("x-amzn-transcribe-language-code")),
    MediaSampleRateHertz: S.Number.pipe(T.HttpHeader("x-amzn-transcribe-sample-rate")),
    MediaEncoding: MediaEncoding.pipe(T.HttpHeader("x-amzn-transcribe-media-encoding")),
    VocabularyName: S.optional(S.String).pipe(T.HttpHeader("x-amzn-transcribe-vocabulary-name")),
    Specialty: Specialty.pipe(T.HttpHeader("x-amzn-transcribe-specialty")),
    Type: Type.pipe(T.HttpHeader("x-amzn-transcribe-type")),
    ShowSpeakerLabel: S.optional(S.Boolean).pipe(T.HttpHeader("x-amzn-transcribe-show-speaker-label")),
    SessionId: S.optional(S.String).pipe(T.HttpHeader("x-amzn-transcribe-session-id")),
    AudioStream: AudioStream.pipe(T.HttpPayload()),
    EnableChannelIdentification: S.optional(S.Boolean).pipe(T.HttpHeader("x-amzn-transcribe-enable-channel-identification")),
    NumberOfChannels: S.optional(S.Number).pipe(T.HttpHeader("x-amzn-transcribe-number-of-channels")),
    ContentIdentificationType: S.optional(MedicalContentIdentificationType).pipe(T.HttpHeader("x-amzn-transcribe-content-identification-type")),
}).pipe(T.all(T.Http({ method: "POST", uri: "/medical-stream-transcription" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "StartMedicalStreamTranscriptionRequest",
});
export const MedicalItem = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    StartTime: S.optional(S.Number),
    EndTime: S.optional(S.Number),
    Type: S.optional(ItemType),
    Content: S.optional(S.String),
    Confidence: S.optional(S.Number),
    Speaker: S.optional(S.String),
})).annotate({ identifier: "MedicalItem" });
export const MedicalItemList = /*@__PURE__*/ /*#__PURE__*/ S.Array(MedicalItem);
export const MedicalEntity = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    StartTime: S.optional(S.Number),
    EndTime: S.optional(S.Number),
    Category: S.optional(S.String),
    Content: S.optional(S.String),
    Confidence: S.optional(S.Number),
})).annotate({ identifier: "MedicalEntity" });
export const MedicalEntityList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(MedicalEntity);
export const MedicalAlternative = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Transcript: S.optional(S.String),
    Items: S.optional(MedicalItemList),
    Entities: S.optional(MedicalEntityList),
})).annotate({
    identifier: "MedicalAlternative",
});
export const MedicalAlternativeList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(MedicalAlternative);
export const MedicalResult = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ResultId: S.optional(S.String),
    StartTime: S.optional(S.Number),
    EndTime: S.optional(S.Number),
    IsPartial: S.optional(S.Boolean),
    Alternatives: S.optional(MedicalAlternativeList),
    ChannelId: S.optional(S.String),
})).annotate({ identifier: "MedicalResult" });
export const MedicalResultList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(MedicalResult);
export const MedicalTranscript = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Results: S.optional(MedicalResultList) })).annotate({
    identifier: "MedicalTranscript",
});
export const MedicalTranscriptEvent = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Transcript: S.optional(MedicalTranscript) })).annotate({
    identifier: "MedicalTranscriptEvent",
});
export const MedicalTranscriptResultStream = 
/*@__PURE__*/ /*#__PURE__*/ T.EventStream(S.Union([
    S.Struct({ TranscriptEvent: MedicalTranscriptEvent }),
    S.Struct({
        BadRequestException: S.suspend(() => BadRequestException).annotate({
            identifier: "BadRequestException",
        }),
    }),
    S.Struct({
        LimitExceededException: S.suspend(() => LimitExceededException).annotate({ identifier: "LimitExceededException" }),
    }),
    S.Struct({
        InternalFailureException: S.suspend(() => InternalFailureException).annotate({ identifier: "InternalFailureException" }),
    }),
    S.Struct({
        ConflictException: S.suspend(() => ConflictException).annotate({
            identifier: "ConflictException",
        }),
    }),
    S.Struct({
        ServiceUnavailableException: S.suspend(() => ServiceUnavailableException).annotate({ identifier: "ServiceUnavailableException" }),
    }),
]));
export const StartMedicalStreamTranscriptionResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    RequestId: S.optional(S.String).pipe(T.HttpHeader("x-amzn-request-id")),
    LanguageCode: S.optional(LanguageCode).pipe(T.HttpHeader("x-amzn-transcribe-language-code")),
    MediaSampleRateHertz: S.optional(S.Number).pipe(T.HttpHeader("x-amzn-transcribe-sample-rate")),
    MediaEncoding: S.optional(MediaEncoding).pipe(T.HttpHeader("x-amzn-transcribe-media-encoding")),
    VocabularyName: S.optional(S.String).pipe(T.HttpHeader("x-amzn-transcribe-vocabulary-name")),
    Specialty: S.optional(Specialty).pipe(T.HttpHeader("x-amzn-transcribe-specialty")),
    Type: S.optional(Type).pipe(T.HttpHeader("x-amzn-transcribe-type")),
    ShowSpeakerLabel: S.optional(S.Boolean).pipe(T.HttpHeader("x-amzn-transcribe-show-speaker-label")),
    SessionId: S.optional(S.String).pipe(T.HttpHeader("x-amzn-transcribe-session-id")),
    TranscriptResultStream: S.optional(MedicalTranscriptResultStream).pipe(T.HttpPayload()),
    EnableChannelIdentification: S.optional(S.Boolean).pipe(T.HttpHeader("x-amzn-transcribe-enable-channel-identification")),
    NumberOfChannels: S.optional(S.Number).pipe(T.HttpHeader("x-amzn-transcribe-number-of-channels")),
    ContentIdentificationType: S.optional(MedicalContentIdentificationType).pipe(T.HttpHeader("x-amzn-transcribe-content-identification-type")),
})).annotate({
    identifier: "StartMedicalStreamTranscriptionResponse",
});
export const StartStreamTranscriptionRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    LanguageCode: S.optional(LanguageCode).pipe(T.HttpHeader("x-amzn-transcribe-language-code")),
    MediaSampleRateHertz: S.Number.pipe(T.HttpHeader("x-amzn-transcribe-sample-rate")),
    MediaEncoding: MediaEncoding.pipe(T.HttpHeader("x-amzn-transcribe-media-encoding")),
    VocabularyName: S.optional(S.String).pipe(T.HttpHeader("x-amzn-transcribe-vocabulary-name")),
    SessionId: S.optional(S.String).pipe(T.HttpHeader("x-amzn-transcribe-session-id")),
    AudioStream: AudioStream.pipe(T.HttpPayload()),
    VocabularyFilterName: S.optional(S.String).pipe(T.HttpHeader("x-amzn-transcribe-vocabulary-filter-name")),
    VocabularyFilterMethod: S.optional(VocabularyFilterMethod).pipe(T.HttpHeader("x-amzn-transcribe-vocabulary-filter-method")),
    ShowSpeakerLabel: S.optional(S.Boolean).pipe(T.HttpHeader("x-amzn-transcribe-show-speaker-label")),
    EnableChannelIdentification: S.optional(S.Boolean).pipe(T.HttpHeader("x-amzn-transcribe-enable-channel-identification")),
    NumberOfChannels: S.optional(S.Number).pipe(T.HttpHeader("x-amzn-transcribe-number-of-channels")),
    EnablePartialResultsStabilization: S.optional(S.Boolean).pipe(T.HttpHeader("x-amzn-transcribe-enable-partial-results-stabilization")),
    PartialResultsStability: S.optional(PartialResultsStability).pipe(T.HttpHeader("x-amzn-transcribe-partial-results-stability")),
    ContentIdentificationType: S.optional(ContentIdentificationType).pipe(T.HttpHeader("x-amzn-transcribe-content-identification-type")),
    ContentRedactionType: S.optional(ContentRedactionType).pipe(T.HttpHeader("x-amzn-transcribe-content-redaction-type")),
    PiiEntityTypes: S.optional(S.String).pipe(T.HttpHeader("x-amzn-transcribe-pii-entity-types")),
    LanguageModelName: S.optional(S.String).pipe(T.HttpHeader("x-amzn-transcribe-language-model-name")),
    IdentifyLanguage: S.optional(S.Boolean).pipe(T.HttpHeader("x-amzn-transcribe-identify-language")),
    LanguageOptions: S.optional(S.String).pipe(T.HttpHeader("x-amzn-transcribe-language-options")),
    PreferredLanguage: S.optional(LanguageCode).pipe(T.HttpHeader("x-amzn-transcribe-preferred-language")),
    IdentifyMultipleLanguages: S.optional(S.Boolean).pipe(T.HttpHeader("x-amzn-transcribe-identify-multiple-languages")),
    VocabularyNames: S.optional(S.String).pipe(T.HttpHeader("x-amzn-transcribe-vocabulary-names")),
    VocabularyFilterNames: S.optional(S.String).pipe(T.HttpHeader("x-amzn-transcribe-vocabulary-filter-names")),
    SessionResumeWindow: S.optional(S.Number).pipe(T.HttpHeader("x-amzn-transcribe-session-resume-window")),
}).pipe(T.all(T.Http({ method: "POST", uri: "/stream-transcription" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "StartStreamTranscriptionRequest",
});
export const Item = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    StartTime: S.optional(S.Number),
    EndTime: S.optional(S.Number),
    Type: S.optional(ItemType),
    Content: S.optional(S.String),
    VocabularyFilterMatch: S.optional(S.Boolean),
    Speaker: S.optional(S.String),
    Confidence: S.optional(S.Number),
    Stable: S.optional(S.Boolean),
})).annotate({ identifier: "Item" });
export const ItemList = /*@__PURE__*/ /*#__PURE__*/ S.Array(Item);
export const Entity = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    StartTime: S.optional(S.Number),
    EndTime: S.optional(S.Number),
    Category: S.optional(S.String),
    Type: S.optional(S.String),
    Content: S.optional(S.String),
    Confidence: S.optional(S.Number),
})).annotate({ identifier: "Entity" });
export const EntityList = /*@__PURE__*/ /*#__PURE__*/ S.Array(Entity);
export const Alternative = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Transcript: S.optional(S.String),
    Items: S.optional(ItemList),
    Entities: S.optional(EntityList),
})).annotate({ identifier: "Alternative" });
export const AlternativeList = /*@__PURE__*/ /*#__PURE__*/ S.Array(Alternative);
export const LanguageWithScore = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    LanguageCode: S.optional(LanguageCode),
    Score: S.optional(S.Number),
})).annotate({
    identifier: "LanguageWithScore",
});
export const LanguageIdentification = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(LanguageWithScore);
export const Result = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ResultId: S.optional(S.String),
    StartTime: S.optional(S.Number),
    EndTime: S.optional(S.Number),
    IsPartial: S.optional(S.Boolean),
    Alternatives: S.optional(AlternativeList),
    ChannelId: S.optional(S.String),
    LanguageCode: S.optional(LanguageCode),
    LanguageIdentification: S.optional(LanguageIdentification),
})).annotate({ identifier: "Result" });
export const ResultList = /*@__PURE__*/ /*#__PURE__*/ S.Array(Result);
export const Transcript = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Results: S.optional(ResultList) })).annotate({ identifier: "Transcript" });
export const TranscriptEvent = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Transcript: S.optional(Transcript) })).annotate({
    identifier: "TranscriptEvent",
});
export const TranscriptResultStream = /*@__PURE__*/ /*#__PURE__*/ T.EventStream(S.Union([
    S.Struct({ TranscriptEvent: TranscriptEvent }),
    S.Struct({
        BadRequestException: S.suspend(() => BadRequestException).annotate({
            identifier: "BadRequestException",
        }),
    }),
    S.Struct({
        LimitExceededException: S.suspend(() => LimitExceededException).annotate({
            identifier: "LimitExceededException",
        }),
    }),
    S.Struct({
        InternalFailureException: S.suspend(() => InternalFailureException).annotate({ identifier: "InternalFailureException" }),
    }),
    S.Struct({
        ConflictException: S.suspend(() => ConflictException).annotate({
            identifier: "ConflictException",
        }),
    }),
    S.Struct({
        ServiceUnavailableException: S.suspend(() => ServiceUnavailableException).annotate({ identifier: "ServiceUnavailableException" }),
    }),
]));
export const StartStreamTranscriptionResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    RequestId: S.optional(S.String).pipe(T.HttpHeader("x-amzn-request-id")),
    LanguageCode: S.optional(LanguageCode).pipe(T.HttpHeader("x-amzn-transcribe-language-code")),
    MediaSampleRateHertz: S.optional(S.Number).pipe(T.HttpHeader("x-amzn-transcribe-sample-rate")),
    MediaEncoding: S.optional(MediaEncoding).pipe(T.HttpHeader("x-amzn-transcribe-media-encoding")),
    VocabularyName: S.optional(S.String).pipe(T.HttpHeader("x-amzn-transcribe-vocabulary-name")),
    SessionId: S.optional(S.String).pipe(T.HttpHeader("x-amzn-transcribe-session-id")),
    TranscriptResultStream: S.optional(TranscriptResultStream).pipe(T.HttpPayload()),
    VocabularyFilterName: S.optional(S.String).pipe(T.HttpHeader("x-amzn-transcribe-vocabulary-filter-name")),
    VocabularyFilterMethod: S.optional(VocabularyFilterMethod).pipe(T.HttpHeader("x-amzn-transcribe-vocabulary-filter-method")),
    ShowSpeakerLabel: S.optional(S.Boolean).pipe(T.HttpHeader("x-amzn-transcribe-show-speaker-label")),
    EnableChannelIdentification: S.optional(S.Boolean).pipe(T.HttpHeader("x-amzn-transcribe-enable-channel-identification")),
    NumberOfChannels: S.optional(S.Number).pipe(T.HttpHeader("x-amzn-transcribe-number-of-channels")),
    EnablePartialResultsStabilization: S.optional(S.Boolean).pipe(T.HttpHeader("x-amzn-transcribe-enable-partial-results-stabilization")),
    PartialResultsStability: S.optional(PartialResultsStability).pipe(T.HttpHeader("x-amzn-transcribe-partial-results-stability")),
    ContentIdentificationType: S.optional(ContentIdentificationType).pipe(T.HttpHeader("x-amzn-transcribe-content-identification-type")),
    ContentRedactionType: S.optional(ContentRedactionType).pipe(T.HttpHeader("x-amzn-transcribe-content-redaction-type")),
    PiiEntityTypes: S.optional(S.String).pipe(T.HttpHeader("x-amzn-transcribe-pii-entity-types")),
    LanguageModelName: S.optional(S.String).pipe(T.HttpHeader("x-amzn-transcribe-language-model-name")),
    IdentifyLanguage: S.optional(S.Boolean).pipe(T.HttpHeader("x-amzn-transcribe-identify-language")),
    LanguageOptions: S.optional(S.String).pipe(T.HttpHeader("x-amzn-transcribe-language-options")),
    PreferredLanguage: S.optional(LanguageCode).pipe(T.HttpHeader("x-amzn-transcribe-preferred-language")),
    IdentifyMultipleLanguages: S.optional(S.Boolean).pipe(T.HttpHeader("x-amzn-transcribe-identify-multiple-languages")),
    VocabularyNames: S.optional(S.String).pipe(T.HttpHeader("x-amzn-transcribe-vocabulary-names")),
    VocabularyFilterNames: S.optional(S.String).pipe(T.HttpHeader("x-amzn-transcribe-vocabulary-filter-names")),
    SessionResumeWindow: S.optional(S.Number).pipe(T.HttpHeader("x-amzn-transcribe-session-resume-window")),
})).annotate({
    identifier: "StartStreamTranscriptionResponse",
});
//# Errors
export class BadRequestException extends S.TaggedErrorClass()("BadRequestException", { Message: S.optional(S.String) }).pipe(C.withBadRequestError) {
}
export class InternalFailureException extends S.TaggedErrorClass()("InternalFailureException", { Message: S.optional(S.String) }).pipe(C.withServerError) {
}
export class LimitExceededException extends S.TaggedErrorClass()("LimitExceededException", { Message: S.optional(S.String) }).pipe(C.withThrottlingError) {
}
export class ResourceNotFoundException extends S.TaggedErrorClass()("ResourceNotFoundException", { Message: S.optional(S.String) }).pipe(C.withBadRequestError) {
}
export class ConflictException extends S.TaggedErrorClass()("ConflictException", { Message: S.optional(S.String) }).pipe(C.withConflictError) {
}
export class ServiceUnavailableException extends S.TaggedErrorClass()("ServiceUnavailableException", { Message: S.optional(S.String) }).pipe(C.withServerError) {
}
/**
 * Provides details about the specified Amazon Web Services HealthScribe streaming session.
 * To view the status of the streaming session, check the `StreamStatus` field in the response. To get the
 * details of post-stream analytics, including its status, check the `PostStreamAnalyticsResult` field in the response.
 */
export const getMedicalScribeStream = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetMedicalScribeStreamRequest,
    output: GetMedicalScribeStreamResponse,
    errors: [
        BadRequestException,
        InternalFailureException,
        LimitExceededException,
        ResourceNotFoundException,
    ],
}));
/**
 * Starts a bidirectional HTTP/2 or WebSocket stream where audio is streamed to
 * Amazon Transcribe and the transcription results are streamed to your application. Use this operation
 * for Call Analytics transcriptions.
 *
 * The following parameters are required:
 *
 * - `language-code` or `identify-language`
 *
 * - `media-encoding`
 *
 * - `sample-rate`
 *
 * For more information on streaming with Amazon Transcribe, see Transcribing streaming audio.
 */
export const startCallAnalyticsStreamTranscription = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: StartCallAnalyticsStreamTranscriptionRequest,
    output: StartCallAnalyticsStreamTranscriptionResponse,
    errors: [
        BadRequestException,
        ConflictException,
        InternalFailureException,
        LimitExceededException,
        ServiceUnavailableException,
    ],
}));
/**
 * Starts a bidirectional HTTP/2 stream, where audio is streamed to
 * Amazon Web Services HealthScribe
 * and the transcription results are streamed to your application.
 *
 * When you start a stream, you first specify the stream configuration in a `MedicalScribeConfigurationEvent`.
 * This event includes channel definitions, encryption settings, medical scribe context, and post-stream analytics settings, such as the output configuration for aggregated transcript and clinical note generation. These are additional
 * streaming session configurations beyond those provided in your initial start request headers. Whether you are starting a new session or resuming an existing session,
 * your first event must be a `MedicalScribeConfigurationEvent`.
 *
 * After you send a `MedicalScribeConfigurationEvent`, you start `AudioEvents` and Amazon Web Services HealthScribe
 * responds with real-time transcription results. When you are finished, to start processing the results with the post-stream analytics, send a `MedicalScribeSessionControlEvent` with a `Type` of
 * `END_OF_SESSION` and Amazon Web Services HealthScribe starts the analytics.
 *
 * You can pause or resume streaming.
 * To pause streaming, complete the input stream without sending the
 * `MedicalScribeSessionControlEvent`.
 * To resume streaming, call the `StartMedicalScribeStream` and specify the same SessionId you used to start the stream.
 *
 * The following parameters are required:
 *
 * - `language-code`
 *
 * - `media-encoding`
 *
 * - `media-sample-rate-hertz`
 *
 * For more information on streaming with
 * Amazon Web Services HealthScribe,
 * see Amazon Web Services HealthScribe.
 */
export const startMedicalScribeStream = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: StartMedicalScribeStreamRequest,
    output: StartMedicalScribeStreamResponse,
    errors: [
        BadRequestException,
        ConflictException,
        InternalFailureException,
        LimitExceededException,
        ServiceUnavailableException,
    ],
}));
/**
 * Starts a bidirectional HTTP/2 or WebSocket stream where audio is streamed to
 * Amazon Transcribe Medical and the transcription results are streamed to your
 * application.
 *
 * The following parameters are required:
 *
 * - `language-code`
 *
 * - `media-encoding`
 *
 * - `sample-rate`
 *
 * For more information on streaming with Amazon Transcribe Medical, see
 * Transcribing
 * streaming audio.
 */
export const startMedicalStreamTranscription = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: StartMedicalStreamTranscriptionRequest,
    output: StartMedicalStreamTranscriptionResponse,
    errors: [
        BadRequestException,
        ConflictException,
        InternalFailureException,
        LimitExceededException,
        ServiceUnavailableException,
    ],
}));
/**
 * Starts a bidirectional HTTP/2 or WebSocket stream where audio is streamed to
 * Amazon Transcribe and the transcription results are streamed to your application.
 *
 * The following parameters are required:
 *
 * - `language-code` or `identify-language` or `identify-multiple-language`
 *
 * - `media-encoding`
 *
 * - `sample-rate`
 *
 * For more information on streaming with Amazon Transcribe, see Transcribing streaming audio.
 */
export const startStreamTranscription = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: StartStreamTranscriptionRequest,
    output: StartStreamTranscriptionResponse,
    errors: [
        BadRequestException,
        ConflictException,
        InternalFailureException,
        LimitExceededException,
        ServiceUnavailableException,
    ],
}));
//# sourceMappingURL=transcribe-streaming.js.map