@aws-sdk/client-transcribe-streaming 3.131.0 → 3.135.0

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [3.135.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.134.0...v3.135.0) (2022-07-21)
+
+**Note:** Version bump only for package @aws-sdk/client-transcribe-streaming
+
+
+
+
+
 # [3.131.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.130.0...v3.131.0) (2022-07-15)
 
 **Note:** Version bump only for package @aws-sdk/client-transcribe-streaming

package/dist-cjs/protocols/Aws_restJson1.js

@@ -35,7 +35,7 @@ const serializeAws_restJson1StartMedicalStreamTranscriptionCommand = async (inpu
     const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/medical-stream-transcription";
     let body;
     if (input.AudioStream !== undefined) {
-        body = context.eventStreamMarshaller.serialize(input.AudioStream, (event) => serializeAws_restJson1AudioStream_event(event, context));
+        body = serializeAws_restJson1AudioStream(input.AudioStream, context);
     }
     return new protocol_http_1.HttpRequest({
         protocol,
@@ -112,7 +112,7 @@ const serializeAws_restJson1StartStreamTranscriptionCommand = async (input, cont
     const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/stream-transcription";
     let body;
     if (input.AudioStream !== undefined) {
-        body = context.eventStreamMarshaller.serialize(input.AudioStream, (event) => serializeAws_restJson1AudioStream_event(event, context));
+        body = serializeAws_restJson1AudioStream(input.AudioStream, context);
     }
     return new protocol_http_1.HttpRequest({
         protocol,
@@ -181,22 +181,8 @@ const deserializeAws_restJson1StartMedicalStreamTranscriptionCommand = async (ou
     if (output.headers["x-amzn-transcribe-content-identification-type"] !== undefined) {
         contents.ContentIdentificationType = output.headers["x-amzn-transcribe-content-identification-type"];
     }
-    const data = context.eventStreamMarshaller.deserialize(output.body, async (event) => {
-        const eventName = Object.keys(event)[0];
-        const eventHeaders = Object.entries(event[eventName].headers).reduce((accummulator, curr) => {
-            accummulator[curr[0]] = curr[1].value;
-            return accummulator;
-        }, {});
-        const eventMessage = {
-            headers: eventHeaders,
-            body: event[eventName].body,
-        };
-        const parsedEvent = {
-            [eventName]: eventMessage,
-        };
-        return await deserializeAws_restJson1MedicalTranscriptResultStream_event(parsedEvent, context);
-    });
-    contents.TranscriptResultStream = data;
+    const data = output.body;
+    contents.TranscriptResultStream = deserializeAws_restJson1MedicalTranscriptResultStream(data, context);
     return Promise.resolve(contents);
 };
 exports.deserializeAws_restJson1StartMedicalStreamTranscriptionCommand = deserializeAws_restJson1StartMedicalStreamTranscriptionCommand;
@@ -331,22 +317,8 @@ const deserializeAws_restJson1StartStreamTranscriptionCommand = async (output, c
     if (output.headers["x-amzn-transcribe-vocabulary-filter-names"] !== undefined) {
         contents.VocabularyFilterNames = output.headers["x-amzn-transcribe-vocabulary-filter-names"];
     }
-    const data = context.eventStreamMarshaller.deserialize(output.body, async (event) => {
-        const eventName = Object.keys(event)[0];
-        const eventHeaders = Object.entries(event[eventName].headers).reduce((accummulator, curr) => {
-            accummulator[curr[0]] = curr[1].value;
-            return accummulator;
-        }, {});
-        const eventMessage = {
-            headers: eventHeaders,
-            body: event[eventName].body,
-        };
-        const parsedEvent = {
-            [eventName]: eventMessage,
-        };
-        return await deserializeAws_restJson1TranscriptResultStream_event(parsedEvent, context);
-    });
-    contents.TranscriptResultStream = data;
+    const data = output.body;
+    contents.TranscriptResultStream = deserializeAws_restJson1TranscriptResultStream(data, context);
     return Promise.resolve(contents);
 };
 exports.deserializeAws_restJson1StartStreamTranscriptionCommand = deserializeAws_restJson1StartStreamTranscriptionCommand;
@@ -385,143 +357,6 @@ const deserializeAws_restJson1StartStreamTranscriptionCommandError = async (outp
             throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
     }
 };
-const serializeAws_restJson1AudioStream_event = (input, context) => {
-    return models_0_1.AudioStream.visit(input, {
-        AudioEvent: (value) => serializeAws_restJson1AudioEvent_event(value, context),
-        _: (value) => value,
-    });
-};
-const deserializeAws_restJson1MedicalTranscriptResultStream_event = async (output, context) => {
-    if (output["TranscriptEvent"] !== undefined) {
-        return {
-            TranscriptEvent: await deserializeAws_restJson1MedicalTranscriptEvent_event(output["TranscriptEvent"], context),
-        };
-    }
-    if (output["BadRequestException"] !== undefined) {
-        return {
-            BadRequestException: await deserializeAws_restJson1BadRequestException_event(output["BadRequestException"], context),
-        };
-    }
-    if (output["LimitExceededException"] !== undefined) {
-        return {
-            LimitExceededException: await deserializeAws_restJson1LimitExceededException_event(output["LimitExceededException"], context),
-        };
-    }
-    if (output["InternalFailureException"] !== undefined) {
-        return {
-            InternalFailureException: await deserializeAws_restJson1InternalFailureException_event(output["InternalFailureException"], context),
-        };
-    }
-    if (output["ConflictException"] !== undefined) {
-        return {
-            ConflictException: await deserializeAws_restJson1ConflictException_event(output["ConflictException"], context),
-        };
-    }
-    if (output["ServiceUnavailableException"] !== undefined) {
-        return {
-            ServiceUnavailableException: await deserializeAws_restJson1ServiceUnavailableException_event(output["ServiceUnavailableException"], context),
-        };
-    }
-    return { $unknown: output };
-};
-const deserializeAws_restJson1TranscriptResultStream_event = async (output, context) => {
-    if (output["TranscriptEvent"] !== undefined) {
-        return {
-            TranscriptEvent: await deserializeAws_restJson1TranscriptEvent_event(output["TranscriptEvent"], context),
-        };
-    }
-    if (output["BadRequestException"] !== undefined) {
-        return {
-            BadRequestException: await deserializeAws_restJson1BadRequestException_event(output["BadRequestException"], context),
-        };
-    }
-    if (output["LimitExceededException"] !== undefined) {
-        return {
-            LimitExceededException: await deserializeAws_restJson1LimitExceededException_event(output["LimitExceededException"], context),
-        };
-    }
-    if (output["InternalFailureException"] !== undefined) {
-        return {
-            InternalFailureException: await deserializeAws_restJson1InternalFailureException_event(output["InternalFailureException"], context),
-        };
-    }
-    if (output["ConflictException"] !== undefined) {
-        return {
-            ConflictException: await deserializeAws_restJson1ConflictException_event(output["ConflictException"], context),
-        };
-    }
-    if (output["ServiceUnavailableException"] !== undefined) {
-        return {
-            ServiceUnavailableException: await deserializeAws_restJson1ServiceUnavailableException_event(output["ServiceUnavailableException"], context),
-        };
-    }
-    return { $unknown: output };
-};
-const serializeAws_restJson1AudioEvent_event = (input, context) => {
-    const message = {
-        headers: {
-            ":event-type": { type: "string", value: "AudioEvent" },
-            ":message-type": { type: "string", value: "event" },
-            ":content-type": { type: "string", value: "application/octet-stream" },
-        },
-        body: new Uint8Array(),
-    };
-    message.body = input.AudioChunk || message.body;
-    return message;
-};
-const deserializeAws_restJson1BadRequestException_event = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseBody(output.body, context),
-    };
-    return deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
-};
-const deserializeAws_restJson1ConflictException_event = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseBody(output.body, context),
-    };
-    return deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
-};
-const deserializeAws_restJson1InternalFailureException_event = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseBody(output.body, context),
-    };
-    return deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
-};
-const deserializeAws_restJson1LimitExceededException_event = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseBody(output.body, context),
-    };
-    return deserializeAws_restJson1LimitExceededExceptionResponse(parsedOutput, context);
-};
-const deserializeAws_restJson1MedicalTranscriptEvent_event = async (output, context) => {
-    let contents = {};
-    const data = await parseBody(output.body, context);
-    contents = {
-        ...contents,
-        ...deserializeAws_restJson1MedicalTranscriptEvent(data, context),
-    };
-    return contents;
-};
-const deserializeAws_restJson1ServiceUnavailableException_event = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseBody(output.body, context),
-    };
-    return deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
-};
-const deserializeAws_restJson1TranscriptEvent_event = async (output, context) => {
-    let contents = {};
-    const data = await parseBody(output.body, context);
-    contents = {
-        ...contents,
-        ...deserializeAws_restJson1TranscriptEvent(data, context),
-    };
-    return contents;
-};
 const deserializeAws_restJson1BadRequestExceptionResponse = async (parsedOutput, context) => {
     const contents = {};
     const data = parsedOutput.body;
@@ -582,17 +417,142 @@ const deserializeAws_restJson1ServiceUnavailableExceptionResponse = async (parse
     });
     return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
 };
-const serializeAws_restJson1AudioEvent = (input, context) => {
-    return {
-        ...(input.AudioChunk != null && { AudioChunk: context.base64Encoder(input.AudioChunk) }),
+const serializeAws_restJson1AudioStream = (input, context) => {
+    const eventMarshallingVisitor = (event) => models_0_1.AudioStream.visit(event, {
+        AudioEvent: (value) => serializeAws_restJson1AudioEvent_event(value, context),
+        _: (value) => value,
+    });
+    return context.eventStreamMarshaller.serialize(input, eventMarshallingVisitor);
+};
+const serializeAws_restJson1AudioEvent_event = (input, context) => {
+    const headers = {
+        ":event-type": { type: "string", value: "AudioEvent" },
+        ":message-type": { type: "string", value: "event" },
+        ":content-type": { type: "string", value: "application/octet-stream" },
     };
+    let body = new Uint8Array();
+    if (input.AudioChunk != null) {
+        body = input.AudioChunk;
+    }
+    return { headers, body };
 };
-const serializeAws_restJson1AudioStream = (input, context) => {
-    return models_0_1.AudioStream.visit(input, {
-        AudioEvent: (value) => ({ AudioEvent: serializeAws_restJson1AudioEvent(value, context) }),
-        _: (name, value) => ({ name: value }),
+const deserializeAws_restJson1MedicalTranscriptResultStream = (output, context) => {
+    return context.eventStreamMarshaller.deserialize(output, async (event) => {
+        if (event["TranscriptEvent"] != null) {
+            return {
+                TranscriptEvent: await deserializeAws_restJson1MedicalTranscriptEvent_event(event["TranscriptEvent"], context),
+            };
+        }
+        if (event["BadRequestException"] != null) {
+            return {
+                BadRequestException: await deserializeAws_restJson1BadRequestException_event(event["BadRequestException"], context),
+            };
+        }
+        if (event["LimitExceededException"] != null) {
+            return {
+                LimitExceededException: await deserializeAws_restJson1LimitExceededException_event(event["LimitExceededException"], context),
+            };
+        }
+        if (event["InternalFailureException"] != null) {
+            return {
+                InternalFailureException: await deserializeAws_restJson1InternalFailureException_event(event["InternalFailureException"], context),
+            };
+        }
+        if (event["ConflictException"] != null) {
+            return {
+                ConflictException: await deserializeAws_restJson1ConflictException_event(event["ConflictException"], context),
+            };
+        }
+        if (event["ServiceUnavailableException"] != null) {
+            return {
+                ServiceUnavailableException: await deserializeAws_restJson1ServiceUnavailableException_event(event["ServiceUnavailableException"], context),
+            };
+        }
+        return { $unknown: output };
     });
 };
+const deserializeAws_restJson1TranscriptResultStream = (output, context) => {
+    return context.eventStreamMarshaller.deserialize(output, async (event) => {
+        if (event["TranscriptEvent"] != null) {
+            return {
+                TranscriptEvent: await deserializeAws_restJson1TranscriptEvent_event(event["TranscriptEvent"], context),
+            };
+        }
+        if (event["BadRequestException"] != null) {
+            return {
+                BadRequestException: await deserializeAws_restJson1BadRequestException_event(event["BadRequestException"], context),
+            };
+        }
+        if (event["LimitExceededException"] != null) {
+            return {
+                LimitExceededException: await deserializeAws_restJson1LimitExceededException_event(event["LimitExceededException"], context),
+            };
+        }
+        if (event["InternalFailureException"] != null) {
+            return {
+                InternalFailureException: await deserializeAws_restJson1InternalFailureException_event(event["InternalFailureException"], context),
+            };
+        }
+        if (event["ConflictException"] != null) {
+            return {
+                ConflictException: await deserializeAws_restJson1ConflictException_event(event["ConflictException"], context),
+            };
+        }
+        if (event["ServiceUnavailableException"] != null) {
+            return {
+                ServiceUnavailableException: await deserializeAws_restJson1ServiceUnavailableException_event(event["ServiceUnavailableException"], context),
+            };
+        }
+        return { $unknown: output };
+    });
+};
+const deserializeAws_restJson1BadRequestException_event = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    return deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+};
+const deserializeAws_restJson1ConflictException_event = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    return deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+};
+const deserializeAws_restJson1InternalFailureException_event = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    return deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+};
+const deserializeAws_restJson1LimitExceededException_event = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    return deserializeAws_restJson1LimitExceededExceptionResponse(parsedOutput, context);
+};
+const deserializeAws_restJson1MedicalTranscriptEvent_event = async (output, context) => {
+    const contents = {};
+    const data = await parseBody(output.body, context);
+    Object.assign(contents, deserializeAws_restJson1MedicalTranscriptEvent(data, context));
+    return contents;
+};
+const deserializeAws_restJson1ServiceUnavailableException_event = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    return deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+};
+const deserializeAws_restJson1TranscriptEvent_event = async (output, context) => {
+    const contents = {};
+    const data = await parseBody(output.body, context);
+    Object.assign(contents, deserializeAws_restJson1TranscriptEvent(data, context));
+    return contents;
+};
 const deserializeAws_restJson1Alternative = (output, context) => {
     return {
         Entities: output.Entities != null ? deserializeAws_restJson1EntityList(output.Entities, context) : undefined,
@@ -611,16 +571,6 @@ const deserializeAws_restJson1AlternativeList = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_restJson1BadRequestException = (output, context) => {
-    return {
-        Message: (0, smithy_client_1.expectString)(output.Message),
-    };
-};
-const deserializeAws_restJson1ConflictException = (output, context) => {
-    return {
-        Message: (0, smithy_client_1.expectString)(output.Message),
-    };
-};
 const deserializeAws_restJson1Entity = (output, context) => {
     return {
         Category: (0, smithy_client_1.expectString)(output.Category),
@@ -642,11 +592,6 @@ const deserializeAws_restJson1EntityList = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_restJson1InternalFailureException = (output, context) => {
-    return {
-        Message: (0, smithy_client_1.expectString)(output.Message),
-    };
-};
 const deserializeAws_restJson1Item = (output, context) => {
     return {
         Confidence: (0, smithy_client_1.limitedParseDouble)(output.Confidence),
@@ -687,11 +632,6 @@ const deserializeAws_restJson1LanguageWithScore = (output, context) => {
         Score: (0, smithy_client_1.limitedParseDouble)(output.Score),
     };
 };
-const deserializeAws_restJson1LimitExceededException = (output, context) => {
-    return {
-        Message: (0, smithy_client_1.expectString)(output.Message),
-    };
-};
 const deserializeAws_restJson1MedicalAlternative = (output, context) => {
     return {
         Entities: output.Entities != null ? deserializeAws_restJson1MedicalEntityList(output.Entities, context) : undefined,
@@ -784,39 +724,6 @@ const deserializeAws_restJson1MedicalTranscriptEvent = (output, context) => {
         Transcript: output.Transcript != null ? deserializeAws_restJson1MedicalTranscript(output.Transcript, context) : undefined,
     };
 };
-const deserializeAws_restJson1MedicalTranscriptResultStream = (output, context) => {
-    if (output.BadRequestException !== undefined && output.BadRequestException !== null) {
-        return {
-            BadRequestException: deserializeAws_restJson1BadRequestException(output.BadRequestException, context),
-        };
-    }
-    if (output.ConflictException !== undefined && output.ConflictException !== null) {
-        return {
-            ConflictException: deserializeAws_restJson1ConflictException(output.ConflictException, context),
-        };
-    }
-    if (output.InternalFailureException !== undefined && output.InternalFailureException !== null) {
-        return {
-            InternalFailureException: deserializeAws_restJson1InternalFailureException(output.InternalFailureException, context),
-        };
-    }
-    if (output.LimitExceededException !== undefined && output.LimitExceededException !== null) {
-        return {
-            LimitExceededException: deserializeAws_restJson1LimitExceededException(output.LimitExceededException, context),
-        };
-    }
-    if (output.ServiceUnavailableException !== undefined && output.ServiceUnavailableException !== null) {
-        return {
-            ServiceUnavailableException: deserializeAws_restJson1ServiceUnavailableException(output.ServiceUnavailableException, context),
-        };
-    }
-    if (output.TranscriptEvent !== undefined && output.TranscriptEvent !== null) {
-        return {
-            TranscriptEvent: deserializeAws_restJson1MedicalTranscriptEvent(output.TranscriptEvent, context),
-        };
-    }
-    return { $unknown: Object.entries(output)[0] };
-};
 const deserializeAws_restJson1Result = (output, context) => {
     return {
         Alternatives: output.Alternatives != null ? deserializeAws_restJson1AlternativeList(output.Alternatives, context) : undefined,
@@ -842,11 +749,6 @@ const deserializeAws_restJson1ResultList = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_restJson1ServiceUnavailableException = (output, context) => {
-    return {
-        Message: (0, smithy_client_1.expectString)(output.Message),
-    };
-};
 const deserializeAws_restJson1Transcript = (output, context) => {
     return {
         Results: output.Results != null ? deserializeAws_restJson1ResultList(output.Results, context) : undefined,
@@ -857,39 +759,6 @@ const deserializeAws_restJson1TranscriptEvent = (output, context) => {
         Transcript: output.Transcript != null ? deserializeAws_restJson1Transcript(output.Transcript, context) : undefined,
     };
 };
-const deserializeAws_restJson1TranscriptResultStream = (output, context) => {
-    if (output.BadRequestException !== undefined && output.BadRequestException !== null) {
-        return {
-            BadRequestException: deserializeAws_restJson1BadRequestException(output.BadRequestException, context),
-        };
-    }
-    if (output.ConflictException !== undefined && output.ConflictException !== null) {
-        return {
-            ConflictException: deserializeAws_restJson1ConflictException(output.ConflictException, context),
-        };
-    }
-    if (output.InternalFailureException !== undefined && output.InternalFailureException !== null) {
-        return {
-            InternalFailureException: deserializeAws_restJson1InternalFailureException(output.InternalFailureException, context),
-        };
-    }
-    if (output.LimitExceededException !== undefined && output.LimitExceededException !== null) {
-        return {
-            LimitExceededException: deserializeAws_restJson1LimitExceededException(output.LimitExceededException, context),
-        };
-    }
-    if (output.ServiceUnavailableException !== undefined && output.ServiceUnavailableException !== null) {
-        return {
-            ServiceUnavailableException: deserializeAws_restJson1ServiceUnavailableException(output.ServiceUnavailableException, context),
-        };
-    }
-    if (output.TranscriptEvent !== undefined && output.TranscriptEvent !== null) {
-        return {
-            TranscriptEvent: deserializeAws_restJson1TranscriptEvent(output.TranscriptEvent, context),
-        };
-    }
-    return { $unknown: Object.entries(output)[0] };
-};
 const deserializeMetadata = (output) => {
     var _a;
     return ({

package/dist-es/protocols/Aws_restJson1.js

@@ -25,9 +25,7 @@ export var serializeAws_restJson1StartMedicalStreamTranscriptionCommand = functi
                 }));
                 resolvedPath = "".concat((basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || "") + "/medical-stream-transcription";
                 if (input.AudioStream !== undefined) {
-                    body = context.eventStreamMarshaller.serialize(input.AudioStream, function (event) {
-                        return serializeAws_restJson1AudioStream_event(event, context);
-                    });
+                    body = serializeAws_restJson1AudioStream(input.AudioStream, context);
                 }
                 return [2, new __HttpRequest({
                         protocol: protocol,
@@ -87,9 +85,7 @@ export var serializeAws_restJson1StartStreamTranscriptionCommand = function (inp
                 }));
                 resolvedPath = "".concat((basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || "") + "/stream-transcription";
                 if (input.AudioStream !== undefined) {
-                    body = context.eventStreamMarshaller.serialize(input.AudioStream, function (event) {
-                        return serializeAws_restJson1AudioStream_event(event, context);
-                    });
+                    body = serializeAws_restJson1AudioStream(input.AudioStream, context);
                 }
                 return [2, new __HttpRequest({
                         protocol: protocol,
@@ -161,30 +157,8 @@ export var deserializeAws_restJson1StartMedicalStreamTranscriptionCommand = func
         if (output.headers["x-amzn-transcribe-content-identification-type"] !== undefined) {
             contents.ContentIdentificationType = output.headers["x-amzn-transcribe-content-identification-type"];
         }
-        data = context.eventStreamMarshaller.deserialize(output.body, function (event) { return __awaiter(void 0, void 0, void 0, function () {
-            var eventName, eventHeaders, eventMessage, parsedEvent;
-            var _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        eventName = Object.keys(event)[0];
-                        eventHeaders = Object.entries(event[eventName].headers).reduce(function (accummulator, curr) {
-                            accummulator[curr[0]] = curr[1].value;
-                            return accummulator;
-                        }, {});
-                        eventMessage = {
-                            headers: eventHeaders,
-                            body: event[eventName].body,
-                        };
-                        parsedEvent = (_a = {},
-                            _a[eventName] = eventMessage,
-                            _a);
-                        return [4, deserializeAws_restJson1MedicalTranscriptResultStream_event(parsedEvent, context)];
-                    case 1: return [2, _b.sent()];
-                }
-            });
-        }); });
-        contents.TranscriptResultStream = data;
+        data = output.body;
+        contents.TranscriptResultStream = deserializeAws_restJson1MedicalTranscriptResultStream(data, context);
         return [2, Promise.resolve(contents)];
     });
 }); };
@@ -335,30 +309,8 @@ export var deserializeAws_restJson1StartStreamTranscriptionCommand = function (o
         if (output.headers["x-amzn-transcribe-vocabulary-filter-names"] !== undefined) {
             contents.VocabularyFilterNames = output.headers["x-amzn-transcribe-vocabulary-filter-names"];
         }
-        data = context.eventStreamMarshaller.deserialize(output.body, function (event) { return __awaiter(void 0, void 0, void 0, function () {
-            var eventName, eventHeaders, eventMessage, parsedEvent;
-            var _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        eventName = Object.keys(event)[0];
-                        eventHeaders = Object.entries(event[eventName].headers).reduce(function (accummulator, curr) {
-                            accummulator[curr[0]] = curr[1].value;
-                            return accummulator;
-                        }, {});
-                        eventMessage = {
-                            headers: eventHeaders,
-                            body: event[eventName].body,
-                        };
-                        parsedEvent = (_a = {},
-                            _a[eventName] = eventMessage,
-                            _a);
-                        return [4, deserializeAws_restJson1TranscriptResultStream_event(parsedEvent, context)];
-                    case 1: return [2, _b.sent()];
-                }
-            });
-        }); });
-        contents.TranscriptResultStream = data;
+        data = output.body;
+        contents.TranscriptResultStream = deserializeAws_restJson1TranscriptResultStream(data, context);
         return [2, Promise.resolve(contents)];
     });
 }); };
@@ -411,111 +363,178 @@ var deserializeAws_restJson1StartStreamTranscriptionCommandError = function (out
         }
     });
 }); };
-var serializeAws_restJson1AudioStream_event = function (input, context) {
-    return AudioStream.visit(input, {
-        AudioEvent: function (value) { return serializeAws_restJson1AudioEvent_event(value, context); },
-        _: function (value) { return value; },
+var deserializeAws_restJson1BadRequestExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var contents, data, exception;
+    return __generator(this, function (_a) {
+        contents = {};
+        data = parsedOutput.body;
+        if (data.Message !== undefined && data.Message !== null) {
+            contents.Message = __expectString(data.Message);
+        }
+        exception = new BadRequestException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, contents));
+        return [2, __decorateServiceException(exception, parsedOutput.body)];
     });
-};
-var deserializeAws_restJson1MedicalTranscriptResultStream_event = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
-    var _a, _b, _c, _d, _e, _f;
-    return __generator(this, function (_g) {
-        switch (_g.label) {
-            case 0:
-                if (!(output["TranscriptEvent"] !== undefined)) return [3, 2];
-                _a = {};
-                return [4, deserializeAws_restJson1MedicalTranscriptEvent_event(output["TranscriptEvent"], context)];
-            case 1: return [2, (_a.TranscriptEvent = _g.sent(),
-                    _a)];
-            case 2:
-                if (!(output["BadRequestException"] !== undefined)) return [3, 4];
-                _b = {};
-                return [4, deserializeAws_restJson1BadRequestException_event(output["BadRequestException"], context)];
-            case 3: return [2, (_b.BadRequestException = _g.sent(),
-                    _b)];
-            case 4:
-                if (!(output["LimitExceededException"] !== undefined)) return [3, 6];
-                _c = {};
-                return [4, deserializeAws_restJson1LimitExceededException_event(output["LimitExceededException"], context)];
-            case 5: return [2, (_c.LimitExceededException = _g.sent(),
-                    _c)];
-            case 6:
-                if (!(output["InternalFailureException"] !== undefined)) return [3, 8];
-                _d = {};
-                return [4, deserializeAws_restJson1InternalFailureException_event(output["InternalFailureException"], context)];
-            case 7: return [2, (_d.InternalFailureException = _g.sent(),
-                    _d)];
-            case 8:
-                if (!(output["ConflictException"] !== undefined)) return [3, 10];
-                _e = {};
-                return [4, deserializeAws_restJson1ConflictException_event(output["ConflictException"], context)];
-            case 9: return [2, (_e.ConflictException = _g.sent(),
-                    _e)];
-            case 10:
-                if (!(output["ServiceUnavailableException"] !== undefined)) return [3, 12];
-                _f = {};
-                return [4, deserializeAws_restJson1ServiceUnavailableException_event(output["ServiceUnavailableException"], context)];
-            case 11: return [2, (_f.ServiceUnavailableException = _g.sent(),
-                    _f)];
-            case 12: return [2, { $unknown: output }];
+}); };
+var deserializeAws_restJson1ConflictExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var contents, data, exception;
+    return __generator(this, function (_a) {
+        contents = {};
+        data = parsedOutput.body;
+        if (data.Message !== undefined && data.Message !== null) {
+            contents.Message = __expectString(data.Message);
         }
+        exception = new ConflictException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, contents));
+        return [2, __decorateServiceException(exception, parsedOutput.body)];
     });
 }); };
-var deserializeAws_restJson1TranscriptResultStream_event = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
-    var _a, _b, _c, _d, _e, _f;
-    return __generator(this, function (_g) {
-        switch (_g.label) {
-            case 0:
-                if (!(output["TranscriptEvent"] !== undefined)) return [3, 2];
-                _a = {};
-                return [4, deserializeAws_restJson1TranscriptEvent_event(output["TranscriptEvent"], context)];
-            case 1: return [2, (_a.TranscriptEvent = _g.sent(),
-                    _a)];
-            case 2:
-                if (!(output["BadRequestException"] !== undefined)) return [3, 4];
-                _b = {};
-                return [4, deserializeAws_restJson1BadRequestException_event(output["BadRequestException"], context)];
-            case 3: return [2, (_b.BadRequestException = _g.sent(),
-                    _b)];
-            case 4:
-                if (!(output["LimitExceededException"] !== undefined)) return [3, 6];
-                _c = {};
-                return [4, deserializeAws_restJson1LimitExceededException_event(output["LimitExceededException"], context)];
-            case 5: return [2, (_c.LimitExceededException = _g.sent(),
-                    _c)];
-            case 6:
-                if (!(output["InternalFailureException"] !== undefined)) return [3, 8];
-                _d = {};
-                return [4, deserializeAws_restJson1InternalFailureException_event(output["InternalFailureException"], context)];
-            case 7: return [2, (_d.InternalFailureException = _g.sent(),
-                    _d)];
-            case 8:
-                if (!(output["ConflictException"] !== undefined)) return [3, 10];
-                _e = {};
-                return [4, deserializeAws_restJson1ConflictException_event(output["ConflictException"], context)];
-            case 9: return [2, (_e.ConflictException = _g.sent(),
-                    _e)];
-            case 10:
-                if (!(output["ServiceUnavailableException"] !== undefined)) return [3, 12];
-                _f = {};
-                return [4, deserializeAws_restJson1ServiceUnavailableException_event(output["ServiceUnavailableException"], context)];
-            case 11: return [2, (_f.ServiceUnavailableException = _g.sent(),
-                    _f)];
-            case 12: return [2, { $unknown: output }];
+var deserializeAws_restJson1InternalFailureExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var contents, data, exception;
+    return __generator(this, function (_a) {
+        contents = {};
+        data = parsedOutput.body;
+        if (data.Message !== undefined && data.Message !== null) {
+            contents.Message = __expectString(data.Message);
         }
+        exception = new InternalFailureException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, contents));
+        return [2, __decorateServiceException(exception, parsedOutput.body)];
     });
 }); };
+var deserializeAws_restJson1LimitExceededExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var contents, data, exception;
+    return __generator(this, function (_a) {
+        contents = {};
+        data = parsedOutput.body;
+        if (data.Message !== undefined && data.Message !== null) {
+            contents.Message = __expectString(data.Message);
+        }
+        exception = new LimitExceededException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, contents));
+        return [2, __decorateServiceException(exception, parsedOutput.body)];
+    });
+}); };
+var deserializeAws_restJson1ServiceUnavailableExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var contents, data, exception;
+    return __generator(this, function (_a) {
+        contents = {};
+        data = parsedOutput.body;
+        if (data.Message !== undefined && data.Message !== null) {
+            contents.Message = __expectString(data.Message);
+        }
+        exception = new ServiceUnavailableException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, contents));
+        return [2, __decorateServiceException(exception, parsedOutput.body)];
+    });
+}); };
+var serializeAws_restJson1AudioStream = function (input, context) {
+    var eventMarshallingVisitor = function (event) {
+        return AudioStream.visit(event, {
+            AudioEvent: function (value) { return serializeAws_restJson1AudioEvent_event(value, context); },
+            _: function (value) { return value; },
+        });
+    };
+    return context.eventStreamMarshaller.serialize(input, eventMarshallingVisitor);
+};
 var serializeAws_restJson1AudioEvent_event = function (input, context) {
-    var message = {
-        headers: {
-            ":event-type": { type: "string", value: "AudioEvent" },
-            ":message-type": { type: "string", value: "event" },
-            ":content-type": { type: "string", value: "application/octet-stream" },
-        },
-        body: new Uint8Array(),
+    var headers = {
+        ":event-type": { type: "string", value: "AudioEvent" },
+        ":message-type": { type: "string", value: "event" },
+        ":content-type": { type: "string", value: "application/octet-stream" },
     };
-    message.body = input.AudioChunk || message.body;
-    return message;
+    var body = new Uint8Array();
+    if (input.AudioChunk != null) {
+        body = input.AudioChunk;
+    }
+    return { headers: headers, body: body };
+};
+var deserializeAws_restJson1MedicalTranscriptResultStream = function (output, context) {
+    return context.eventStreamMarshaller.deserialize(output, function (event) { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, _b, _c, _d, _e, _f;
+        return __generator(this, function (_g) {
+            switch (_g.label) {
+                case 0:
+                    if (!(event["TranscriptEvent"] != null)) return [3, 2];
+                    _a = {};
+                    return [4, deserializeAws_restJson1MedicalTranscriptEvent_event(event["TranscriptEvent"], context)];
+                case 1: return [2, (_a.TranscriptEvent = _g.sent(),
+                        _a)];
+                case 2:
+                    if (!(event["BadRequestException"] != null)) return [3, 4];
+                    _b = {};
+                    return [4, deserializeAws_restJson1BadRequestException_event(event["BadRequestException"], context)];
+                case 3: return [2, (_b.BadRequestException = _g.sent(),
+                        _b)];
+                case 4:
+                    if (!(event["LimitExceededException"] != null)) return [3, 6];
+                    _c = {};
+                    return [4, deserializeAws_restJson1LimitExceededException_event(event["LimitExceededException"], context)];
+                case 5: return [2, (_c.LimitExceededException = _g.sent(),
+                        _c)];
+                case 6:
+                    if (!(event["InternalFailureException"] != null)) return [3, 8];
+                    _d = {};
+                    return [4, deserializeAws_restJson1InternalFailureException_event(event["InternalFailureException"], context)];
+                case 7: return [2, (_d.InternalFailureException = _g.sent(),
+                        _d)];
+                case 8:
+                    if (!(event["ConflictException"] != null)) return [3, 10];
+                    _e = {};
+                    return [4, deserializeAws_restJson1ConflictException_event(event["ConflictException"], context)];
+                case 9: return [2, (_e.ConflictException = _g.sent(),
+                        _e)];
+                case 10:
+                    if (!(event["ServiceUnavailableException"] != null)) return [3, 12];
+                    _f = {};
+                    return [4, deserializeAws_restJson1ServiceUnavailableException_event(event["ServiceUnavailableException"], context)];
+                case 11: return [2, (_f.ServiceUnavailableException = _g.sent(),
+                        _f)];
+                case 12: return [2, { $unknown: output }];
+            }
+        });
+    }); });
+};
+var deserializeAws_restJson1TranscriptResultStream = function (output, context) {
+    return context.eventStreamMarshaller.deserialize(output, function (event) { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, _b, _c, _d, _e, _f;
+        return __generator(this, function (_g) {
+            switch (_g.label) {
+                case 0:
+                    if (!(event["TranscriptEvent"] != null)) return [3, 2];
+                    _a = {};
+                    return [4, deserializeAws_restJson1TranscriptEvent_event(event["TranscriptEvent"], context)];
+                case 1: return [2, (_a.TranscriptEvent = _g.sent(),
+                        _a)];
+                case 2:
+                    if (!(event["BadRequestException"] != null)) return [3, 4];
+                    _b = {};
+                    return [4, deserializeAws_restJson1BadRequestException_event(event["BadRequestException"], context)];
+                case 3: return [2, (_b.BadRequestException = _g.sent(),
+                        _b)];
+                case 4:
+                    if (!(event["LimitExceededException"] != null)) return [3, 6];
+                    _c = {};
+                    return [4, deserializeAws_restJson1LimitExceededException_event(event["LimitExceededException"], context)];
+                case 5: return [2, (_c.LimitExceededException = _g.sent(),
+                        _c)];
+                case 6:
+                    if (!(event["InternalFailureException"] != null)) return [3, 8];
+                    _d = {};
+                    return [4, deserializeAws_restJson1InternalFailureException_event(event["InternalFailureException"], context)];
+                case 7: return [2, (_d.InternalFailureException = _g.sent(),
+                        _d)];
+                case 8:
+                    if (!(event["ConflictException"] != null)) return [3, 10];
+                    _e = {};
+                    return [4, deserializeAws_restJson1ConflictException_event(event["ConflictException"], context)];
+                case 9: return [2, (_e.ConflictException = _g.sent(),
+                        _e)];
+                case 10:
+                    if (!(event["ServiceUnavailableException"] != null)) return [3, 12];
+                    _f = {};
+                    return [4, deserializeAws_restJson1ServiceUnavailableException_event(event["ServiceUnavailableException"], context)];
+                case 11: return [2, (_f.ServiceUnavailableException = _g.sent(),
+                        _f)];
+                case 12: return [2, { $unknown: output }];
+            }
+        });
+    }); });
 };
 var deserializeAws_restJson1BadRequestException_event = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var parsedOutput, _a;
@@ -586,7 +605,7 @@ var deserializeAws_restJson1MedicalTranscriptEvent_event = function (output, con
                 return [4, parseBody(output.body, context)];
             case 1:
                 data = _a.sent();
-                contents = __assign(__assign({}, contents), deserializeAws_restJson1MedicalTranscriptEvent(data, context));
+                Object.assign(contents, deserializeAws_restJson1MedicalTranscriptEvent(data, context));
                 return [2, contents];
         }
     });
@@ -615,80 +634,11 @@ var deserializeAws_restJson1TranscriptEvent_event = function (output, context) {
                 return [4, parseBody(output.body, context)];
             case 1:
                 data = _a.sent();
-                contents = __assign(__assign({}, contents), deserializeAws_restJson1TranscriptEvent(data, context));
+                Object.assign(contents, deserializeAws_restJson1TranscriptEvent(data, context));
                 return [2, contents];
         }
     });
 }); };
-var deserializeAws_restJson1BadRequestExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
-    var contents, data, exception;
-    return __generator(this, function (_a) {
-        contents = {};
-        data = parsedOutput.body;
-        if (data.Message !== undefined && data.Message !== null) {
-            contents.Message = __expectString(data.Message);
-        }
-        exception = new BadRequestException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, contents));
-        return [2, __decorateServiceException(exception, parsedOutput.body)];
-    });
-}); };
-var deserializeAws_restJson1ConflictExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
-    var contents, data, exception;
-    return __generator(this, function (_a) {
-        contents = {};
-        data = parsedOutput.body;
-        if (data.Message !== undefined && data.Message !== null) {
-            contents.Message = __expectString(data.Message);
-        }
-        exception = new ConflictException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, contents));
-        return [2, __decorateServiceException(exception, parsedOutput.body)];
-    });
-}); };
-var deserializeAws_restJson1InternalFailureExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
-    var contents, data, exception;
-    return __generator(this, function (_a) {
-        contents = {};
-        data = parsedOutput.body;
-        if (data.Message !== undefined && data.Message !== null) {
-            contents.Message = __expectString(data.Message);
-        }
-        exception = new InternalFailureException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, contents));
-        return [2, __decorateServiceException(exception, parsedOutput.body)];
-    });
-}); };
-var deserializeAws_restJson1LimitExceededExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
-    var contents, data, exception;
-    return __generator(this, function (_a) {
-        contents = {};
-        data = parsedOutput.body;
-        if (data.Message !== undefined && data.Message !== null) {
-            contents.Message = __expectString(data.Message);
-        }
-        exception = new LimitExceededException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, contents));
-        return [2, __decorateServiceException(exception, parsedOutput.body)];
-    });
-}); };
-var deserializeAws_restJson1ServiceUnavailableExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
-    var contents, data, exception;
-    return __generator(this, function (_a) {
-        contents = {};
-        data = parsedOutput.body;
-        if (data.Message !== undefined && data.Message !== null) {
-            contents.Message = __expectString(data.Message);
-        }
-        exception = new ServiceUnavailableException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, contents));
-        return [2, __decorateServiceException(exception, parsedOutput.body)];
-    });
-}); };
-var serializeAws_restJson1AudioEvent = function (input, context) {
-    return __assign({}, (input.AudioChunk != null && { AudioChunk: context.base64Encoder(input.AudioChunk) }));
-};
-var serializeAws_restJson1AudioStream = function (input, context) {
-    return AudioStream.visit(input, {
-        AudioEvent: function (value) { return ({ AudioEvent: serializeAws_restJson1AudioEvent(value, context) }); },
-        _: function (name, value) { return ({ name: value }); },
-    });
-};
 var deserializeAws_restJson1Alternative = function (output, context) {
     return {
         Entities: output.Entities != null ? deserializeAws_restJson1EntityList(output.Entities, context) : undefined,
@@ -707,16 +657,6 @@ var deserializeAws_restJson1AlternativeList = function (output, context) {
     });
     return retVal;
 };
-var deserializeAws_restJson1BadRequestException = function (output, context) {
-    return {
-        Message: __expectString(output.Message),
-    };
-};
-var deserializeAws_restJson1ConflictException = function (output, context) {
-    return {
-        Message: __expectString(output.Message),
-    };
-};
 var deserializeAws_restJson1Entity = function (output, context) {
     return {
         Category: __expectString(output.Category),
@@ -738,11 +678,6 @@ var deserializeAws_restJson1EntityList = function (output, context) {
     });
     return retVal;
 };
-var deserializeAws_restJson1InternalFailureException = function (output, context) {
-    return {
-        Message: __expectString(output.Message),
-    };
-};
 var deserializeAws_restJson1Item = function (output, context) {
     return {
         Confidence: __limitedParseDouble(output.Confidence),
@@ -783,11 +718,6 @@ var deserializeAws_restJson1LanguageWithScore = function (output, context) {
         Score: __limitedParseDouble(output.Score),
     };
 };
-var deserializeAws_restJson1LimitExceededException = function (output, context) {
-    return {
-        Message: __expectString(output.Message),
-    };
-};
 var deserializeAws_restJson1MedicalAlternative = function (output, context) {
     return {
         Entities: output.Entities != null ? deserializeAws_restJson1MedicalEntityList(output.Entities, context) : undefined,
@@ -880,39 +810,6 @@ var deserializeAws_restJson1MedicalTranscriptEvent = function (output, context)
         Transcript: output.Transcript != null ? deserializeAws_restJson1MedicalTranscript(output.Transcript, context) : undefined,
     };
 };
-var deserializeAws_restJson1MedicalTranscriptResultStream = function (output, context) {
-    if (output.BadRequestException !== undefined && output.BadRequestException !== null) {
-        return {
-            BadRequestException: deserializeAws_restJson1BadRequestException(output.BadRequestException, context),
-        };
-    }
-    if (output.ConflictException !== undefined && output.ConflictException !== null) {
-        return {
-            ConflictException: deserializeAws_restJson1ConflictException(output.ConflictException, context),
-        };
-    }
-    if (output.InternalFailureException !== undefined && output.InternalFailureException !== null) {
-        return {
-            InternalFailureException: deserializeAws_restJson1InternalFailureException(output.InternalFailureException, context),
-        };
-    }
-    if (output.LimitExceededException !== undefined && output.LimitExceededException !== null) {
-        return {
-            LimitExceededException: deserializeAws_restJson1LimitExceededException(output.LimitExceededException, context),
-        };
-    }
-    if (output.ServiceUnavailableException !== undefined && output.ServiceUnavailableException !== null) {
-        return {
-            ServiceUnavailableException: deserializeAws_restJson1ServiceUnavailableException(output.ServiceUnavailableException, context),
-        };
-    }
-    if (output.TranscriptEvent !== undefined && output.TranscriptEvent !== null) {
-        return {
-            TranscriptEvent: deserializeAws_restJson1MedicalTranscriptEvent(output.TranscriptEvent, context),
-        };
-    }
-    return { $unknown: Object.entries(output)[0] };
-};
 var deserializeAws_restJson1Result = function (output, context) {
     return {
         Alternatives: output.Alternatives != null ? deserializeAws_restJson1AlternativeList(output.Alternatives, context) : undefined,
@@ -938,11 +835,6 @@ var deserializeAws_restJson1ResultList = function (output, context) {
     });
     return retVal;
 };
-var deserializeAws_restJson1ServiceUnavailableException = function (output, context) {
-    return {
-        Message: __expectString(output.Message),
-    };
-};
 var deserializeAws_restJson1Transcript = function (output, context) {
     return {
         Results: output.Results != null ? deserializeAws_restJson1ResultList(output.Results, context) : undefined,
@@ -953,39 +845,6 @@ var deserializeAws_restJson1TranscriptEvent = function (output, context) {
         Transcript: output.Transcript != null ? deserializeAws_restJson1Transcript(output.Transcript, context) : undefined,
     };
 };
-var deserializeAws_restJson1TranscriptResultStream = function (output, context) {
-    if (output.BadRequestException !== undefined && output.BadRequestException !== null) {
-        return {
-            BadRequestException: deserializeAws_restJson1BadRequestException(output.BadRequestException, context),
-        };
-    }
-    if (output.ConflictException !== undefined && output.ConflictException !== null) {
-        return {
-            ConflictException: deserializeAws_restJson1ConflictException(output.ConflictException, context),
-        };
-    }
-    if (output.InternalFailureException !== undefined && output.InternalFailureException !== null) {
-        return {
-            InternalFailureException: deserializeAws_restJson1InternalFailureException(output.InternalFailureException, context),
-        };
-    }
-    if (output.LimitExceededException !== undefined && output.LimitExceededException !== null) {
-        return {
-            LimitExceededException: deserializeAws_restJson1LimitExceededException(output.LimitExceededException, context),
-        };
-    }
-    if (output.ServiceUnavailableException !== undefined && output.ServiceUnavailableException !== null) {
-        return {
-            ServiceUnavailableException: deserializeAws_restJson1ServiceUnavailableException(output.ServiceUnavailableException, context),
-        };
-    }
-    if (output.TranscriptEvent !== undefined && output.TranscriptEvent !== null) {
-        return {
-            TranscriptEvent: deserializeAws_restJson1TranscriptEvent(output.TranscriptEvent, context),
-        };
-    }
-    return { $unknown: Object.entries(output)[0] };
-};
 var deserializeMetadata = function (output) {
     var _a;
     return ({

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aws-sdk/client-transcribe-streaming",
   "description": "AWS SDK for JavaScript Transcribe Streaming Client for Node.js, Browser and React Native",
-  "version": "3.131.0",
+  "version": "3.135.0",
   "scripts": {
     "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
     "build:cjs": "tsc -p tsconfig.cjs.json",