@aws-sdk/client-transcribe 3.489.0 → 3.495.0

package/dist-cjs/index.js

@@ -1,12 +1,3991 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TranscribeServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./TranscribeClient"), exports);
-tslib_1.__exportStar(require("./Transcribe"), exports);
-tslib_1.__exportStar(require("./commands"), exports);
-tslib_1.__exportStar(require("./pagination"), exports);
-tslib_1.__exportStar(require("./models"), exports);
-require("@aws-sdk/util-endpoints");
-var TranscribeServiceException_1 = require("./models/TranscribeServiceException");
-Object.defineProperty(exports, "TranscribeServiceException", { enumerable: true, get: function () { return TranscribeServiceException_1.TranscribeServiceException; } });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  BadRequestException: () => BadRequestException,
+  BaseModelName: () => BaseModelName,
+  CLMLanguageCode: () => CLMLanguageCode,
+  CallAnalyticsJobStatus: () => CallAnalyticsJobStatus,
+  ConflictException: () => ConflictException,
+  CreateCallAnalyticsCategoryCommand: () => CreateCallAnalyticsCategoryCommand,
+  CreateLanguageModelCommand: () => CreateLanguageModelCommand,
+  CreateMedicalVocabularyCommand: () => CreateMedicalVocabularyCommand,
+  CreateVocabularyCommand: () => CreateVocabularyCommand,
+  CreateVocabularyFilterCommand: () => CreateVocabularyFilterCommand,
+  DeleteCallAnalyticsCategoryCommand: () => DeleteCallAnalyticsCategoryCommand,
+  DeleteCallAnalyticsJobCommand: () => DeleteCallAnalyticsJobCommand,
+  DeleteLanguageModelCommand: () => DeleteLanguageModelCommand,
+  DeleteMedicalScribeJobCommand: () => DeleteMedicalScribeJobCommand,
+  DeleteMedicalTranscriptionJobCommand: () => DeleteMedicalTranscriptionJobCommand,
+  DeleteMedicalVocabularyCommand: () => DeleteMedicalVocabularyCommand,
+  DeleteTranscriptionJobCommand: () => DeleteTranscriptionJobCommand,
+  DeleteVocabularyCommand: () => DeleteVocabularyCommand,
+  DeleteVocabularyFilterCommand: () => DeleteVocabularyFilterCommand,
+  DescribeLanguageModelCommand: () => DescribeLanguageModelCommand,
+  GetCallAnalyticsCategoryCommand: () => GetCallAnalyticsCategoryCommand,
+  GetCallAnalyticsJobCommand: () => GetCallAnalyticsJobCommand,
+  GetMedicalScribeJobCommand: () => GetMedicalScribeJobCommand,
+  GetMedicalTranscriptionJobCommand: () => GetMedicalTranscriptionJobCommand,
+  GetMedicalVocabularyCommand: () => GetMedicalVocabularyCommand,
+  GetTranscriptionJobCommand: () => GetTranscriptionJobCommand,
+  GetVocabularyCommand: () => GetVocabularyCommand,
+  GetVocabularyFilterCommand: () => GetVocabularyFilterCommand,
+  InputType: () => InputType,
+  InternalFailureException: () => InternalFailureException,
+  LanguageCode: () => LanguageCode,
+  LimitExceededException: () => LimitExceededException,
+  ListCallAnalyticsCategoriesCommand: () => ListCallAnalyticsCategoriesCommand,
+  ListCallAnalyticsJobsCommand: () => ListCallAnalyticsJobsCommand,
+  ListLanguageModelsCommand: () => ListLanguageModelsCommand,
+  ListMedicalScribeJobsCommand: () => ListMedicalScribeJobsCommand,
+  ListMedicalTranscriptionJobsCommand: () => ListMedicalTranscriptionJobsCommand,
+  ListMedicalVocabulariesCommand: () => ListMedicalVocabulariesCommand,
+  ListTagsForResourceCommand: () => ListTagsForResourceCommand,
+  ListTranscriptionJobsCommand: () => ListTranscriptionJobsCommand,
+  ListVocabulariesCommand: () => ListVocabulariesCommand,
+  ListVocabularyFiltersCommand: () => ListVocabularyFiltersCommand,
+  MediaFormat: () => MediaFormat,
+  MedicalContentIdentificationType: () => MedicalContentIdentificationType,
+  MedicalScribeJobStatus: () => MedicalScribeJobStatus,
+  MedicalScribeLanguageCode: () => MedicalScribeLanguageCode,
+  MedicalScribeParticipantRole: () => MedicalScribeParticipantRole,
+  ModelStatus: () => ModelStatus,
+  NotFoundException: () => NotFoundException,
+  OutputLocationType: () => OutputLocationType,
+  ParticipantRole: () => ParticipantRole,
+  PiiEntityType: () => PiiEntityType,
+  RedactionOutput: () => RedactionOutput,
+  RedactionType: () => RedactionType,
+  Rule: () => Rule,
+  SentimentValue: () => SentimentValue,
+  Specialty: () => Specialty,
+  StartCallAnalyticsJobCommand: () => StartCallAnalyticsJobCommand,
+  StartMedicalScribeJobCommand: () => StartMedicalScribeJobCommand,
+  StartMedicalTranscriptionJobCommand: () => StartMedicalTranscriptionJobCommand,
+  StartTranscriptionJobCommand: () => StartTranscriptionJobCommand,
+  SubtitleFormat: () => SubtitleFormat,
+  TagResourceCommand: () => TagResourceCommand,
+  ToxicityCategory: () => ToxicityCategory,
+  Transcribe: () => Transcribe,
+  TranscribeClient: () => TranscribeClient,
+  TranscribeServiceException: () => TranscribeServiceException,
+  TranscriptFilterType: () => TranscriptFilterType,
+  TranscriptionJobStatus: () => TranscriptionJobStatus,
+  Type: () => Type,
+  UntagResourceCommand: () => UntagResourceCommand,
+  UpdateCallAnalyticsCategoryCommand: () => UpdateCallAnalyticsCategoryCommand,
+  UpdateMedicalVocabularyCommand: () => UpdateMedicalVocabularyCommand,
+  UpdateVocabularyCommand: () => UpdateVocabularyCommand,
+  UpdateVocabularyFilterCommand: () => UpdateVocabularyFilterCommand,
+  VocabularyFilterMethod: () => VocabularyFilterMethod,
+  VocabularyState: () => VocabularyState,
+  __Client: () => import_smithy_client.Client,
+  paginateListCallAnalyticsCategories: () => paginateListCallAnalyticsCategories,
+  paginateListCallAnalyticsJobs: () => paginateListCallAnalyticsJobs,
+  paginateListLanguageModels: () => paginateListLanguageModels,
+  paginateListMedicalScribeJobs: () => paginateListMedicalScribeJobs,
+  paginateListMedicalTranscriptionJobs: () => paginateListMedicalTranscriptionJobs,
+  paginateListMedicalVocabularies: () => paginateListMedicalVocabularies,
+  paginateListTranscriptionJobs: () => paginateListTranscriptionJobs,
+  paginateListVocabularies: () => paginateListVocabularies,
+  paginateListVocabularyFilters: () => paginateListVocabularyFilters
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/TranscribeClient.ts
+var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
+var import_middleware_logger = require("@aws-sdk/middleware-logger");
+var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
+var import_middleware_signing = require("@aws-sdk/middleware-signing");
+var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
+var import_config_resolver = require("@smithy/config-resolver");
+var import_middleware_content_length = require("@smithy/middleware-content-length");
+var import_middleware_endpoint = require("@smithy/middleware-endpoint");
+var import_middleware_retry = require("@smithy/middleware-retry");
+
+
+// src/endpoint/EndpointParameters.ts
+var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
+  return {
+    ...options,
+    useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+    useFipsEndpoint: options.useFipsEndpoint ?? false,
+    defaultSigningName: "transcribe"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/TranscribeClient.ts
+var import_runtimeConfig = require("././runtimeConfig");
+
+// src/runtimeExtensions.ts
+var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
+var import_protocol_http = require("@smithy/protocol-http");
+var import_smithy_client = require("@smithy/smithy-client");
+var asPartial = /* @__PURE__ */ __name((t) => t, "asPartial");
+var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
+  const extensionConfiguration = {
+    ...asPartial((0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig))
+  };
+  extensions.forEach((extension) => extension.configure(extensionConfiguration));
+  return {
+    ...runtimeConfig,
+    ...(0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
+    ...(0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
+    ...(0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration)
+  };
+}, "resolveRuntimeExtensions");
+
+// src/TranscribeClient.ts
+var _TranscribeClient = class _TranscribeClient extends import_smithy_client.Client {
+  constructor(...[configuration]) {
+    const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
+    const _config_1 = resolveClientEndpointParameters(_config_0);
+    const _config_2 = (0, import_config_resolver.resolveRegionConfig)(_config_1);
+    const _config_3 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_2);
+    const _config_4 = (0, import_middleware_retry.resolveRetryConfig)(_config_3);
+    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
+    const _config_6 = (0, import_middleware_signing.resolveAwsAuthConfig)(_config_5);
+    const _config_7 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_6);
+    const _config_8 = resolveRuntimeExtensions(_config_7, (configuration == null ? void 0 : configuration.extensions) || []);
+    super(_config_8);
+    this.config = _config_8;
+    this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_signing.getAwsAuthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
+  }
+  /**
+   * Destroy underlying resources, like sockets. It's usually not necessary to do this.
+   * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
+   * Otherwise, sockets might stay open for quite a long time before the server terminates them.
+   */
+  destroy() {
+    super.destroy();
+  }
+};
+__name(_TranscribeClient, "TranscribeClient");
+var TranscribeClient = _TranscribeClient;
+
+// src/Transcribe.ts
+
+
+// src/commands/CreateCallAnalyticsCategoryCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/protocols/Aws_json1_1.ts
+
+
+
+// src/models/TranscribeServiceException.ts
+
+var _TranscribeServiceException = class _TranscribeServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _TranscribeServiceException.prototype);
+  }
+};
+__name(_TranscribeServiceException, "TranscribeServiceException");
+var TranscribeServiceException = _TranscribeServiceException;
+
+// src/models/models_0.ts
+var _BadRequestException = class _BadRequestException extends TranscribeServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "BadRequestException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "BadRequestException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _BadRequestException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_BadRequestException, "BadRequestException");
+var BadRequestException = _BadRequestException;
+var BaseModelName = {
+  NARROW_BAND: "NarrowBand",
+  WIDE_BAND: "WideBand"
+};
+var CallAnalyticsJobStatus = {
+  COMPLETED: "COMPLETED",
+  FAILED: "FAILED",
+  IN_PROGRESS: "IN_PROGRESS",
+  QUEUED: "QUEUED"
+};
+var ParticipantRole = {
+  AGENT: "AGENT",
+  CUSTOMER: "CUSTOMER"
+};
+var LanguageCode = {
+  AB_GE: "ab-GE",
+  AF_ZA: "af-ZA",
+  AR_AE: "ar-AE",
+  AR_SA: "ar-SA",
+  AST_ES: "ast-ES",
+  AZ_AZ: "az-AZ",
+  BA_RU: "ba-RU",
+  BE_BY: "be-BY",
+  BG_BG: "bg-BG",
+  BN_IN: "bn-IN",
+  BS_BA: "bs-BA",
+  CA_ES: "ca-ES",
+  CKB_IQ: "ckb-IQ",
+  CKB_IR: "ckb-IR",
+  CS_CZ: "cs-CZ",
+  CY_WL: "cy-WL",
+  DA_DK: "da-DK",
+  DE_CH: "de-CH",
+  DE_DE: "de-DE",
+  EL_GR: "el-GR",
+  EN_AB: "en-AB",
+  EN_AU: "en-AU",
+  EN_GB: "en-GB",
+  EN_IE: "en-IE",
+  EN_IN: "en-IN",
+  EN_NZ: "en-NZ",
+  EN_US: "en-US",
+  EN_WL: "en-WL",
+  EN_ZA: "en-ZA",
+  ES_ES: "es-ES",
+  ES_US: "es-US",
+  ET_ET: "et-ET",
+  EU_ES: "eu-ES",
+  FA_IR: "fa-IR",
+  FI_FI: "fi-FI",
+  FR_CA: "fr-CA",
+  FR_FR: "fr-FR",
+  GL_ES: "gl-ES",
+  GU_IN: "gu-IN",
+  HA_NG: "ha-NG",
+  HE_IL: "he-IL",
+  HI_IN: "hi-IN",
+  HR_HR: "hr-HR",
+  HU_HU: "hu-HU",
+  HY_AM: "hy-AM",
+  ID_ID: "id-ID",
+  IS_IS: "is-IS",
+  IT_IT: "it-IT",
+  JA_JP: "ja-JP",
+  KAB_DZ: "kab-DZ",
+  KA_GE: "ka-GE",
+  KK_KZ: "kk-KZ",
+  KN_IN: "kn-IN",
+  KO_KR: "ko-KR",
+  KY_KG: "ky-KG",
+  LG_IN: "lg-IN",
+  LT_LT: "lt-LT",
+  LV_LV: "lv-LV",
+  MHR_RU: "mhr-RU",
+  MI_NZ: "mi-NZ",
+  MK_MK: "mk-MK",
+  ML_IN: "ml-IN",
+  MN_MN: "mn-MN",
+  MR_IN: "mr-IN",
+  MS_MY: "ms-MY",
+  MT_MT: "mt-MT",
+  NL_NL: "nl-NL",
+  NO_NO: "no-NO",
+  OR_IN: "or-IN",
+  PA_IN: "pa-IN",
+  PL_PL: "pl-PL",
+  PS_AF: "ps-AF",
+  PT_BR: "pt-BR",
+  PT_PT: "pt-PT",
+  RO_RO: "ro-RO",
+  RU_RU: "ru-RU",
+  RW_RW: "rw-RW",
+  SI_LK: "si-LK",
+  SK_SK: "sk-SK",
+  SL_SI: "sl-SI",
+  SO_SO: "so-SO",
+  SR_RS: "sr-RS",
+  SU_ID: "su-ID",
+  SV_SE: "sv-SE",
+  SW_BI: "sw-BI",
+  SW_KE: "sw-KE",
+  SW_RW: "sw-RW",
+  SW_TZ: "sw-TZ",
+  SW_UG: "sw-UG",
+  TA_IN: "ta-IN",
+  TE_IN: "te-IN",
+  TH_TH: "th-TH",
+  TL_PH: "tl-PH",
+  TR_TR: "tr-TR",
+  TT_RU: "tt-RU",
+  UG_CN: "ug-CN",
+  UK_UA: "uk-UA",
+  UZ_UZ: "uz-UZ",
+  VI_VN: "vi-VN",
+  WO_SN: "wo-SN",
+  ZH_CN: "zh-CN",
+  ZH_TW: "zh-TW",
+  ZU_ZA: "zu-ZA"
+};
+var MediaFormat = {
+  AMR: "amr",
+  FLAC: "flac",
+  M4A: "m4a",
+  MP3: "mp3",
+  MP4: "mp4",
+  OGG: "ogg",
+  WAV: "wav",
+  WEBM: "webm"
+};
+var PiiEntityType = {
+  ADDRESS: "ADDRESS",
+  ALL: "ALL",
+  BANK_ACCOUNT_NUMBER: "BANK_ACCOUNT_NUMBER",
+  BANK_ROUTING: "BANK_ROUTING",
+  CREDIT_DEBIT_CVV: "CREDIT_DEBIT_CVV",
+  CREDIT_DEBIT_EXPIRY: "CREDIT_DEBIT_EXPIRY",
+  CREDIT_DEBIT_NUMBER: "CREDIT_DEBIT_NUMBER",
+  EMAIL: "EMAIL",
+  NAME: "NAME",
+  PHONE: "PHONE",
+  PIN: "PIN",
+  SSN: "SSN"
+};
+var RedactionOutput = {
+  REDACTED: "redacted",
+  REDACTED_AND_UNREDACTED: "redacted_and_unredacted"
+};
+var RedactionType = {
+  PII: "PII"
+};
+var VocabularyFilterMethod = {
+  MASK: "mask",
+  REMOVE: "remove",
+  TAG: "tag"
+};
+var InputType = {
+  POST_CALL: "POST_CALL",
+  REAL_TIME: "REAL_TIME"
+};
+var SentimentValue = {
+  MIXED: "MIXED",
+  NEGATIVE: "NEGATIVE",
+  NEUTRAL: "NEUTRAL",
+  POSITIVE: "POSITIVE"
+};
+var TranscriptFilterType = {
+  EXACT: "EXACT"
+};
+var Rule;
+((Rule3) => {
+  Rule3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.NonTalkTimeFilter !== void 0)
+      return visitor.NonTalkTimeFilter(value.NonTalkTimeFilter);
+    if (value.InterruptionFilter !== void 0)
+      return visitor.InterruptionFilter(value.InterruptionFilter);
+    if (value.TranscriptFilter !== void 0)
+      return visitor.TranscriptFilter(value.TranscriptFilter);
+    if (value.SentimentFilter !== void 0)
+      return visitor.SentimentFilter(value.SentimentFilter);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(Rule || (Rule = {}));
+var CLMLanguageCode = {
+  DE_DE: "de-DE",
+  EN_AU: "en-AU",
+  EN_GB: "en-GB",
+  EN_US: "en-US",
+  ES_US: "es-US",
+  HI_IN: "hi-IN",
+  JA_JP: "ja-JP"
+};
+var _ConflictException = class _ConflictException extends TranscribeServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ConflictException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ConflictException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ConflictException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_ConflictException, "ConflictException");
+var ConflictException = _ConflictException;
+var _InternalFailureException = class _InternalFailureException extends TranscribeServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InternalFailureException",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "InternalFailureException";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _InternalFailureException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_InternalFailureException, "InternalFailureException");
+var InternalFailureException = _InternalFailureException;
+var _LimitExceededException = class _LimitExceededException extends TranscribeServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "LimitExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "LimitExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _LimitExceededException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_LimitExceededException, "LimitExceededException");
+var LimitExceededException = _LimitExceededException;
+var ModelStatus = {
+  COMPLETED: "COMPLETED",
+  FAILED: "FAILED",
+  IN_PROGRESS: "IN_PROGRESS"
+};
+var VocabularyState = {
+  FAILED: "FAILED",
+  PENDING: "PENDING",
+  READY: "READY"
+};
+var _NotFoundException = class _NotFoundException extends TranscribeServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "NotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "NotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _NotFoundException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_NotFoundException, "NotFoundException");
+var NotFoundException = _NotFoundException;
+var MedicalScribeParticipantRole = {
+  CLINICIAN: "CLINICIAN",
+  PATIENT: "PATIENT"
+};
+var MedicalScribeLanguageCode = {
+  EN_US: "en-US"
+};
+var MedicalScribeJobStatus = {
+  COMPLETED: "COMPLETED",
+  FAILED: "FAILED",
+  IN_PROGRESS: "IN_PROGRESS",
+  QUEUED: "QUEUED"
+};
+var MedicalContentIdentificationType = {
+  PHI: "PHI"
+};
+var Specialty = {
+  PRIMARYCARE: "PRIMARYCARE"
+};
+var TranscriptionJobStatus = {
+  COMPLETED: "COMPLETED",
+  FAILED: "FAILED",
+  IN_PROGRESS: "IN_PROGRESS",
+  QUEUED: "QUEUED"
+};
+var Type = {
+  CONVERSATION: "CONVERSATION",
+  DICTATION: "DICTATION"
+};
+var SubtitleFormat = {
+  SRT: "srt",
+  VTT: "vtt"
+};
+var ToxicityCategory = {
+  ALL: "ALL"
+};
+var OutputLocationType = {
+  CUSTOMER_BUCKET: "CUSTOMER_BUCKET",
+  SERVICE_BUCKET: "SERVICE_BUCKET"
+};
+
+// src/protocols/Aws_json1_1.ts
+var se_CreateCallAnalyticsCategoryCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateCallAnalyticsCategory");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateCallAnalyticsCategoryCommand");
+var se_CreateLanguageModelCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateLanguageModel");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateLanguageModelCommand");
+var se_CreateMedicalVocabularyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateMedicalVocabulary");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateMedicalVocabularyCommand");
+var se_CreateVocabularyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateVocabulary");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateVocabularyCommand");
+var se_CreateVocabularyFilterCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateVocabularyFilter");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateVocabularyFilterCommand");
+var se_DeleteCallAnalyticsCategoryCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteCallAnalyticsCategory");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteCallAnalyticsCategoryCommand");
+var se_DeleteCallAnalyticsJobCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteCallAnalyticsJob");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteCallAnalyticsJobCommand");
+var se_DeleteLanguageModelCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteLanguageModel");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteLanguageModelCommand");
+var se_DeleteMedicalScribeJobCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteMedicalScribeJob");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteMedicalScribeJobCommand");
+var se_DeleteMedicalTranscriptionJobCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteMedicalTranscriptionJob");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteMedicalTranscriptionJobCommand");
+var se_DeleteMedicalVocabularyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteMedicalVocabulary");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteMedicalVocabularyCommand");
+var se_DeleteTranscriptionJobCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteTranscriptionJob");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteTranscriptionJobCommand");
+var se_DeleteVocabularyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteVocabulary");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteVocabularyCommand");
+var se_DeleteVocabularyFilterCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteVocabularyFilter");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteVocabularyFilterCommand");
+var se_DescribeLanguageModelCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeLanguageModel");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeLanguageModelCommand");
+var se_GetCallAnalyticsCategoryCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetCallAnalyticsCategory");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetCallAnalyticsCategoryCommand");
+var se_GetCallAnalyticsJobCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetCallAnalyticsJob");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetCallAnalyticsJobCommand");
+var se_GetMedicalScribeJobCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetMedicalScribeJob");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetMedicalScribeJobCommand");
+var se_GetMedicalTranscriptionJobCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetMedicalTranscriptionJob");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetMedicalTranscriptionJobCommand");
+var se_GetMedicalVocabularyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetMedicalVocabulary");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetMedicalVocabularyCommand");
+var se_GetTranscriptionJobCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetTranscriptionJob");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetTranscriptionJobCommand");
+var se_GetVocabularyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetVocabulary");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetVocabularyCommand");
+var se_GetVocabularyFilterCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetVocabularyFilter");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetVocabularyFilterCommand");
+var se_ListCallAnalyticsCategoriesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListCallAnalyticsCategories");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListCallAnalyticsCategoriesCommand");
+var se_ListCallAnalyticsJobsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListCallAnalyticsJobs");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListCallAnalyticsJobsCommand");
+var se_ListLanguageModelsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListLanguageModels");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListLanguageModelsCommand");
+var se_ListMedicalScribeJobsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListMedicalScribeJobs");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListMedicalScribeJobsCommand");
+var se_ListMedicalTranscriptionJobsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListMedicalTranscriptionJobs");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListMedicalTranscriptionJobsCommand");
+var se_ListMedicalVocabulariesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListMedicalVocabularies");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListMedicalVocabulariesCommand");
+var se_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListTagsForResource");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListTagsForResourceCommand");
+var se_ListTranscriptionJobsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListTranscriptionJobs");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListTranscriptionJobsCommand");
+var se_ListVocabulariesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListVocabularies");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListVocabulariesCommand");
+var se_ListVocabularyFiltersCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListVocabularyFilters");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListVocabularyFiltersCommand");
+var se_StartCallAnalyticsJobCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("StartCallAnalyticsJob");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_StartCallAnalyticsJobCommand");
+var se_StartMedicalScribeJobCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("StartMedicalScribeJob");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_StartMedicalScribeJobCommand");
+var se_StartMedicalTranscriptionJobCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("StartMedicalTranscriptionJob");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_StartMedicalTranscriptionJobCommand");
+var se_StartTranscriptionJobCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("StartTranscriptionJob");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_StartTranscriptionJobCommand");
+var se_TagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("TagResource");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_TagResourceCommand");
+var se_UntagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UntagResource");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UntagResourceCommand");
+var se_UpdateCallAnalyticsCategoryCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateCallAnalyticsCategory");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateCallAnalyticsCategoryCommand");
+var se_UpdateMedicalVocabularyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateMedicalVocabulary");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateMedicalVocabularyCommand");
+var se_UpdateVocabularyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateVocabulary");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateVocabularyCommand");
+var se_UpdateVocabularyFilterCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateVocabularyFilter");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateVocabularyFilterCommand");
+var de_CreateCallAnalyticsCategoryCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateCallAnalyticsCategoryCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_CreateCallAnalyticsCategoryResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateCallAnalyticsCategoryCommand");
+var de_CreateCallAnalyticsCategoryCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.transcribe#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.transcribe#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.transcribe#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.transcribe#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateCallAnalyticsCategoryCommandError");
+var de_CreateLanguageModelCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateLanguageModelCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateLanguageModelCommand");
+var de_CreateLanguageModelCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.transcribe#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.transcribe#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.transcribe#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.transcribe#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateLanguageModelCommandError");
+var de_CreateMedicalVocabularyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateMedicalVocabularyCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_CreateMedicalVocabularyResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateMedicalVocabularyCommand");
+var de_CreateMedicalVocabularyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.transcribe#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.transcribe#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.transcribe#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.transcribe#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateMedicalVocabularyCommandError");
+var de_CreateVocabularyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateVocabularyCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_CreateVocabularyResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateVocabularyCommand");
+var de_CreateVocabularyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.transcribe#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.transcribe#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.transcribe#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.transcribe#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateVocabularyCommandError");
+var de_CreateVocabularyFilterCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateVocabularyFilterCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_CreateVocabularyFilterResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateVocabularyFilterCommand");
+var de_CreateVocabularyFilterCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.transcribe#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.transcribe#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.transcribe#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.transcribe#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateVocabularyFilterCommandError");
+var de_DeleteCallAnalyticsCategoryCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteCallAnalyticsCategoryCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteCallAnalyticsCategoryCommand");
+var de_DeleteCallAnalyticsCategoryCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.transcribe#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.transcribe#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.transcribe#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.transcribe#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteCallAnalyticsCategoryCommandError");
+var de_DeleteCallAnalyticsJobCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteCallAnalyticsJobCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteCallAnalyticsJobCommand");
+var de_DeleteCallAnalyticsJobCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.transcribe#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.transcribe#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.transcribe#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteCallAnalyticsJobCommandError");
+var de_DeleteLanguageModelCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteLanguageModelCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_DeleteLanguageModelCommand");
+var de_DeleteLanguageModelCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.transcribe#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.transcribe#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.transcribe#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteLanguageModelCommandError");
+var de_DeleteMedicalScribeJobCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteMedicalScribeJobCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_DeleteMedicalScribeJobCommand");
+var de_DeleteMedicalScribeJobCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.transcribe#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.transcribe#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.transcribe#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteMedicalScribeJobCommandError");
+var de_DeleteMedicalTranscriptionJobCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteMedicalTranscriptionJobCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_DeleteMedicalTranscriptionJobCommand");
+var de_DeleteMedicalTranscriptionJobCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.transcribe#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.transcribe#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.transcribe#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteMedicalTranscriptionJobCommandError");
+var de_DeleteMedicalVocabularyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteMedicalVocabularyCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_DeleteMedicalVocabularyCommand");
+var de_DeleteMedicalVocabularyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.transcribe#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.transcribe#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.transcribe#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.transcribe#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteMedicalVocabularyCommandError");
+var de_DeleteTranscriptionJobCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteTranscriptionJobCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_DeleteTranscriptionJobCommand");
+var de_DeleteTranscriptionJobCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.transcribe#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.transcribe#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.transcribe#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteTranscriptionJobCommandError");
+var de_DeleteVocabularyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteVocabularyCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_DeleteVocabularyCommand");
+var de_DeleteVocabularyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.transcribe#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.transcribe#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.transcribe#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.transcribe#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteVocabularyCommandError");
+var de_DeleteVocabularyFilterCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteVocabularyFilterCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_DeleteVocabularyFilterCommand");
+var de_DeleteVocabularyFilterCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.transcribe#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.transcribe#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.transcribe#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.transcribe#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteVocabularyFilterCommandError");
+var de_DescribeLanguageModelCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeLanguageModelCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeLanguageModelResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeLanguageModelCommand");
+var de_DescribeLanguageModelCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.transcribe#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.transcribe#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.transcribe#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.transcribe#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeLanguageModelCommandError");
+var de_GetCallAnalyticsCategoryCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetCallAnalyticsCategoryCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_GetCallAnalyticsCategoryResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetCallAnalyticsCategoryCommand");
+var de_GetCallAnalyticsCategoryCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.transcribe#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.transcribe#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.transcribe#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.transcribe#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetCallAnalyticsCategoryCommandError");
+var de_GetCallAnalyticsJobCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetCallAnalyticsJobCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_GetCallAnalyticsJobResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetCallAnalyticsJobCommand");
+var de_GetCallAnalyticsJobCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.transcribe#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.transcribe#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.transcribe#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.transcribe#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetCallAnalyticsJobCommandError");
+var de_GetMedicalScribeJobCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetMedicalScribeJobCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_GetMedicalScribeJobResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetMedicalScribeJobCommand");
+var de_GetMedicalScribeJobCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.transcribe#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.transcribe#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.transcribe#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.transcribe#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetMedicalScribeJobCommandError");
+var de_GetMedicalTranscriptionJobCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetMedicalTranscriptionJobCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_GetMedicalTranscriptionJobResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetMedicalTranscriptionJobCommand");
+var de_GetMedicalTranscriptionJobCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.transcribe#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.transcribe#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.transcribe#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.transcribe#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetMedicalTranscriptionJobCommandError");
+var de_GetMedicalVocabularyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetMedicalVocabularyCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_GetMedicalVocabularyResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetMedicalVocabularyCommand");
+var de_GetMedicalVocabularyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.transcribe#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.transcribe#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.transcribe#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.transcribe#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetMedicalVocabularyCommandError");
+var de_GetTranscriptionJobCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetTranscriptionJobCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_GetTranscriptionJobResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetTranscriptionJobCommand");
+var de_GetTranscriptionJobCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.transcribe#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.transcribe#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.transcribe#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.transcribe#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetTranscriptionJobCommandError");
+var de_GetVocabularyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetVocabularyCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_GetVocabularyResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetVocabularyCommand");
+var de_GetVocabularyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.transcribe#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.transcribe#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.transcribe#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.transcribe#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetVocabularyCommandError");
+var de_GetVocabularyFilterCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetVocabularyFilterCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_GetVocabularyFilterResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetVocabularyFilterCommand");
+var de_GetVocabularyFilterCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.transcribe#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.transcribe#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.transcribe#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.transcribe#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetVocabularyFilterCommandError");
+var de_ListCallAnalyticsCategoriesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListCallAnalyticsCategoriesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListCallAnalyticsCategoriesResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListCallAnalyticsCategoriesCommand");
+var de_ListCallAnalyticsCategoriesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.transcribe#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.transcribe#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.transcribe#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListCallAnalyticsCategoriesCommandError");
+var de_ListCallAnalyticsJobsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListCallAnalyticsJobsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListCallAnalyticsJobsResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListCallAnalyticsJobsCommand");
+var de_ListCallAnalyticsJobsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.transcribe#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.transcribe#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.transcribe#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListCallAnalyticsJobsCommandError");
+var de_ListLanguageModelsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListLanguageModelsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListLanguageModelsResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListLanguageModelsCommand");
+var de_ListLanguageModelsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.transcribe#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.transcribe#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.transcribe#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListLanguageModelsCommandError");
+var de_ListMedicalScribeJobsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListMedicalScribeJobsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListMedicalScribeJobsResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListMedicalScribeJobsCommand");
+var de_ListMedicalScribeJobsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.transcribe#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.transcribe#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.transcribe#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListMedicalScribeJobsCommandError");
+var de_ListMedicalTranscriptionJobsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListMedicalTranscriptionJobsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListMedicalTranscriptionJobsResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListMedicalTranscriptionJobsCommand");
+var de_ListMedicalTranscriptionJobsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.transcribe#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.transcribe#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.transcribe#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListMedicalTranscriptionJobsCommandError");
+var de_ListMedicalVocabulariesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListMedicalVocabulariesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListMedicalVocabulariesResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListMedicalVocabulariesCommand");
+var de_ListMedicalVocabulariesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.transcribe#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.transcribe#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.transcribe#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListMedicalVocabulariesCommandError");
+var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListTagsForResourceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListTagsForResourceCommand");
+var de_ListTagsForResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.transcribe#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.transcribe#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.transcribe#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.transcribe#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListTagsForResourceCommandError");
+var de_ListTranscriptionJobsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListTranscriptionJobsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListTranscriptionJobsResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListTranscriptionJobsCommand");
+var de_ListTranscriptionJobsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.transcribe#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.transcribe#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.transcribe#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListTranscriptionJobsCommandError");
+var de_ListVocabulariesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListVocabulariesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListVocabulariesResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListVocabulariesCommand");
+var de_ListVocabulariesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.transcribe#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.transcribe#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.transcribe#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListVocabulariesCommandError");
+var de_ListVocabularyFiltersCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListVocabularyFiltersCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListVocabularyFiltersResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListVocabularyFiltersCommand");
+var de_ListVocabularyFiltersCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.transcribe#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.transcribe#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.transcribe#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListVocabularyFiltersCommandError");
+var de_StartCallAnalyticsJobCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_StartCallAnalyticsJobCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_StartCallAnalyticsJobResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_StartCallAnalyticsJobCommand");
+var de_StartCallAnalyticsJobCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.transcribe#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.transcribe#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.transcribe#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.transcribe#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_StartCallAnalyticsJobCommandError");
+var de_StartMedicalScribeJobCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_StartMedicalScribeJobCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_StartMedicalScribeJobResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_StartMedicalScribeJobCommand");
+var de_StartMedicalScribeJobCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.transcribe#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.transcribe#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.transcribe#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.transcribe#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_StartMedicalScribeJobCommandError");
+var de_StartMedicalTranscriptionJobCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_StartMedicalTranscriptionJobCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_StartMedicalTranscriptionJobResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_StartMedicalTranscriptionJobCommand");
+var de_StartMedicalTranscriptionJobCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.transcribe#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.transcribe#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.transcribe#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.transcribe#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_StartMedicalTranscriptionJobCommandError");
+var de_StartTranscriptionJobCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_StartTranscriptionJobCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_StartTranscriptionJobResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_StartTranscriptionJobCommand");
+var de_StartTranscriptionJobCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.transcribe#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.transcribe#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.transcribe#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.transcribe#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_StartTranscriptionJobCommandError");
+var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_TagResourceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_TagResourceCommand");
+var de_TagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.transcribe#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.transcribe#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.transcribe#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.transcribe#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.transcribe#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_TagResourceCommandError");
+var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UntagResourceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UntagResourceCommand");
+var de_UntagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.transcribe#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.transcribe#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.transcribe#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.transcribe#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.transcribe#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UntagResourceCommandError");
+var de_UpdateCallAnalyticsCategoryCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateCallAnalyticsCategoryCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_UpdateCallAnalyticsCategoryResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateCallAnalyticsCategoryCommand");
+var de_UpdateCallAnalyticsCategoryCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.transcribe#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.transcribe#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.transcribe#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.transcribe#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.transcribe#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateCallAnalyticsCategoryCommandError");
+var de_UpdateMedicalVocabularyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateMedicalVocabularyCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_UpdateMedicalVocabularyResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateMedicalVocabularyCommand");
+var de_UpdateMedicalVocabularyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.transcribe#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.transcribe#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.transcribe#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.transcribe#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.transcribe#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateMedicalVocabularyCommandError");
+var de_UpdateVocabularyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateVocabularyCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_UpdateVocabularyResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateVocabularyCommand");
+var de_UpdateVocabularyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.transcribe#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.transcribe#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.transcribe#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.transcribe#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.transcribe#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateVocabularyCommandError");
+var de_UpdateVocabularyFilterCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateVocabularyFilterCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_UpdateVocabularyFilterResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateVocabularyFilterCommand");
+var de_UpdateVocabularyFilterCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.transcribe#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.transcribe#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.transcribe#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.transcribe#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateVocabularyFilterCommandError");
+var de_BadRequestExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new BadRequestException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_BadRequestExceptionRes");
+var de_ConflictExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ConflictException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ConflictExceptionRes");
+var de_InternalFailureExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InternalFailureException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InternalFailureExceptionRes");
+var de_LimitExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new LimitExceededException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_LimitExceededExceptionRes");
+var de_NotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new NotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_NotFoundExceptionRes");
+var de_CallAnalyticsJob = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    CallAnalyticsJobName: import_smithy_client.expectString,
+    CallAnalyticsJobStatus: import_smithy_client.expectString,
+    ChannelDefinitions: import_smithy_client._json,
+    CompletionTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    DataAccessRoleArn: import_smithy_client.expectString,
+    FailureReason: import_smithy_client.expectString,
+    IdentifiedLanguageScore: import_smithy_client.limitedParseFloat32,
+    LanguageCode: import_smithy_client.expectString,
+    Media: import_smithy_client._json,
+    MediaFormat: import_smithy_client.expectString,
+    MediaSampleRateHertz: import_smithy_client.expectInt32,
+    Settings: import_smithy_client._json,
+    StartTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Transcript: import_smithy_client._json
+  });
+}, "de_CallAnalyticsJob");
+var de_CallAnalyticsJobSummaries = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_CallAnalyticsJobSummary(entry, context);
+  });
+  return retVal;
+}, "de_CallAnalyticsJobSummaries");
+var de_CallAnalyticsJobSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    CallAnalyticsJobName: import_smithy_client.expectString,
+    CallAnalyticsJobStatus: import_smithy_client.expectString,
+    CompletionTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    FailureReason: import_smithy_client.expectString,
+    LanguageCode: import_smithy_client.expectString,
+    StartTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_)))
+  });
+}, "de_CallAnalyticsJobSummary");
+var de_CategoryProperties = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    CategoryName: import_smithy_client.expectString,
+    CreateTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    InputType: import_smithy_client.expectString,
+    LastUpdateTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Rules: import_smithy_client._json
+  });
+}, "de_CategoryProperties");
+var de_CategoryPropertiesList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_CategoryProperties(entry, context);
+  });
+  return retVal;
+}, "de_CategoryPropertiesList");
+var de_CreateCallAnalyticsCategoryResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    CategoryProperties: (_) => de_CategoryProperties(_, context)
+  });
+}, "de_CreateCallAnalyticsCategoryResponse");
+var de_CreateMedicalVocabularyResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    FailureReason: import_smithy_client.expectString,
+    LanguageCode: import_smithy_client.expectString,
+    LastModifiedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    VocabularyName: import_smithy_client.expectString,
+    VocabularyState: import_smithy_client.expectString
+  });
+}, "de_CreateMedicalVocabularyResponse");
+var de_CreateVocabularyFilterResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    LanguageCode: import_smithy_client.expectString,
+    LastModifiedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    VocabularyFilterName: import_smithy_client.expectString
+  });
+}, "de_CreateVocabularyFilterResponse");
+var de_CreateVocabularyResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    FailureReason: import_smithy_client.expectString,
+    LanguageCode: import_smithy_client.expectString,
+    LastModifiedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    VocabularyName: import_smithy_client.expectString,
+    VocabularyState: import_smithy_client.expectString
+  });
+}, "de_CreateVocabularyResponse");
+var de_DescribeLanguageModelResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    LanguageModel: (_) => de_LanguageModel(_, context)
+  });
+}, "de_DescribeLanguageModelResponse");
+var de_GetCallAnalyticsCategoryResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    CategoryProperties: (_) => de_CategoryProperties(_, context)
+  });
+}, "de_GetCallAnalyticsCategoryResponse");
+var de_GetCallAnalyticsJobResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    CallAnalyticsJob: (_) => de_CallAnalyticsJob(_, context)
+  });
+}, "de_GetCallAnalyticsJobResponse");
+var de_GetMedicalScribeJobResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    MedicalScribeJob: (_) => de_MedicalScribeJob(_, context)
+  });
+}, "de_GetMedicalScribeJobResponse");
+var de_GetMedicalTranscriptionJobResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    MedicalTranscriptionJob: (_) => de_MedicalTranscriptionJob(_, context)
+  });
+}, "de_GetMedicalTranscriptionJobResponse");
+var de_GetMedicalVocabularyResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    DownloadUri: import_smithy_client.expectString,
+    FailureReason: import_smithy_client.expectString,
+    LanguageCode: import_smithy_client.expectString,
+    LastModifiedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    VocabularyName: import_smithy_client.expectString,
+    VocabularyState: import_smithy_client.expectString
+  });
+}, "de_GetMedicalVocabularyResponse");
+var de_GetTranscriptionJobResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    TranscriptionJob: (_) => de_TranscriptionJob(_, context)
+  });
+}, "de_GetTranscriptionJobResponse");
+var de_GetVocabularyFilterResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    DownloadUri: import_smithy_client.expectString,
+    LanguageCode: import_smithy_client.expectString,
+    LastModifiedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    VocabularyFilterName: import_smithy_client.expectString
+  });
+}, "de_GetVocabularyFilterResponse");
+var de_GetVocabularyResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    DownloadUri: import_smithy_client.expectString,
+    FailureReason: import_smithy_client.expectString,
+    LanguageCode: import_smithy_client.expectString,
+    LastModifiedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    VocabularyName: import_smithy_client.expectString,
+    VocabularyState: import_smithy_client.expectString
+  });
+}, "de_GetVocabularyResponse");
+var de_LanguageCodeItem = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    DurationInSeconds: import_smithy_client.limitedParseFloat32,
+    LanguageCode: import_smithy_client.expectString
+  });
+}, "de_LanguageCodeItem");
+var de_LanguageCodeList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_LanguageCodeItem(entry, context);
+  });
+  return retVal;
+}, "de_LanguageCodeList");
+var de_LanguageModel = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    BaseModelName: import_smithy_client.expectString,
+    CreateTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    FailureReason: import_smithy_client.expectString,
+    InputDataConfig: import_smithy_client._json,
+    LanguageCode: import_smithy_client.expectString,
+    LastModifiedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    ModelName: import_smithy_client.expectString,
+    ModelStatus: import_smithy_client.expectString,
+    UpgradeAvailability: import_smithy_client.expectBoolean
+  });
+}, "de_LanguageModel");
+var de_ListCallAnalyticsCategoriesResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Categories: (_) => de_CategoryPropertiesList(_, context),
+    NextToken: import_smithy_client.expectString
+  });
+}, "de_ListCallAnalyticsCategoriesResponse");
+var de_ListCallAnalyticsJobsResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    CallAnalyticsJobSummaries: (_) => de_CallAnalyticsJobSummaries(_, context),
+    NextToken: import_smithy_client.expectString,
+    Status: import_smithy_client.expectString
+  });
+}, "de_ListCallAnalyticsJobsResponse");
+var de_ListLanguageModelsResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Models: (_) => de_Models(_, context),
+    NextToken: import_smithy_client.expectString
+  });
+}, "de_ListLanguageModelsResponse");
+var de_ListMedicalScribeJobsResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    MedicalScribeJobSummaries: (_) => de_MedicalScribeJobSummaries(_, context),
+    NextToken: import_smithy_client.expectString,
+    Status: import_smithy_client.expectString
+  });
+}, "de_ListMedicalScribeJobsResponse");
+var de_ListMedicalTranscriptionJobsResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    MedicalTranscriptionJobSummaries: (_) => de_MedicalTranscriptionJobSummaries(_, context),
+    NextToken: import_smithy_client.expectString,
+    Status: import_smithy_client.expectString
+  });
+}, "de_ListMedicalTranscriptionJobsResponse");
+var de_ListMedicalVocabulariesResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    NextToken: import_smithy_client.expectString,
+    Status: import_smithy_client.expectString,
+    Vocabularies: (_) => de_Vocabularies(_, context)
+  });
+}, "de_ListMedicalVocabulariesResponse");
+var de_ListTranscriptionJobsResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    NextToken: import_smithy_client.expectString,
+    Status: import_smithy_client.expectString,
+    TranscriptionJobSummaries: (_) => de_TranscriptionJobSummaries(_, context)
+  });
+}, "de_ListTranscriptionJobsResponse");
+var de_ListVocabulariesResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    NextToken: import_smithy_client.expectString,
+    Status: import_smithy_client.expectString,
+    Vocabularies: (_) => de_Vocabularies(_, context)
+  });
+}, "de_ListVocabulariesResponse");
+var de_ListVocabularyFiltersResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    NextToken: import_smithy_client.expectString,
+    VocabularyFilters: (_) => de_VocabularyFilters(_, context)
+  });
+}, "de_ListVocabularyFiltersResponse");
+var de_MedicalScribeJob = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    ChannelDefinitions: import_smithy_client._json,
+    CompletionTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    DataAccessRoleArn: import_smithy_client.expectString,
+    FailureReason: import_smithy_client.expectString,
+    LanguageCode: import_smithy_client.expectString,
+    Media: import_smithy_client._json,
+    MedicalScribeJobName: import_smithy_client.expectString,
+    MedicalScribeJobStatus: import_smithy_client.expectString,
+    MedicalScribeOutput: import_smithy_client._json,
+    Settings: import_smithy_client._json,
+    StartTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Tags: import_smithy_client._json
+  });
+}, "de_MedicalScribeJob");
+var de_MedicalScribeJobSummaries = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_MedicalScribeJobSummary(entry, context);
+  });
+  return retVal;
+}, "de_MedicalScribeJobSummaries");
+var de_MedicalScribeJobSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    CompletionTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    FailureReason: import_smithy_client.expectString,
+    LanguageCode: import_smithy_client.expectString,
+    MedicalScribeJobName: import_smithy_client.expectString,
+    MedicalScribeJobStatus: import_smithy_client.expectString,
+    StartTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_)))
+  });
+}, "de_MedicalScribeJobSummary");
+var de_MedicalTranscriptionJob = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    CompletionTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    ContentIdentificationType: import_smithy_client.expectString,
+    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    FailureReason: import_smithy_client.expectString,
+    LanguageCode: import_smithy_client.expectString,
+    Media: import_smithy_client._json,
+    MediaFormat: import_smithy_client.expectString,
+    MediaSampleRateHertz: import_smithy_client.expectInt32,
+    MedicalTranscriptionJobName: import_smithy_client.expectString,
+    Settings: import_smithy_client._json,
+    Specialty: import_smithy_client.expectString,
+    StartTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Tags: import_smithy_client._json,
+    Transcript: import_smithy_client._json,
+    TranscriptionJobStatus: import_smithy_client.expectString,
+    Type: import_smithy_client.expectString
+  });
+}, "de_MedicalTranscriptionJob");
+var de_MedicalTranscriptionJobSummaries = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_MedicalTranscriptionJobSummary(entry, context);
+  });
+  return retVal;
+}, "de_MedicalTranscriptionJobSummaries");
+var de_MedicalTranscriptionJobSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    CompletionTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    ContentIdentificationType: import_smithy_client.expectString,
+    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    FailureReason: import_smithy_client.expectString,
+    LanguageCode: import_smithy_client.expectString,
+    MedicalTranscriptionJobName: import_smithy_client.expectString,
+    OutputLocationType: import_smithy_client.expectString,
+    Specialty: import_smithy_client.expectString,
+    StartTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    TranscriptionJobStatus: import_smithy_client.expectString,
+    Type: import_smithy_client.expectString
+  });
+}, "de_MedicalTranscriptionJobSummary");
+var de_Models = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_LanguageModel(entry, context);
+  });
+  return retVal;
+}, "de_Models");
+var de_StartCallAnalyticsJobResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    CallAnalyticsJob: (_) => de_CallAnalyticsJob(_, context)
+  });
+}, "de_StartCallAnalyticsJobResponse");
+var de_StartMedicalScribeJobResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    MedicalScribeJob: (_) => de_MedicalScribeJob(_, context)
+  });
+}, "de_StartMedicalScribeJobResponse");
+var de_StartMedicalTranscriptionJobResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    MedicalTranscriptionJob: (_) => de_MedicalTranscriptionJob(_, context)
+  });
+}, "de_StartMedicalTranscriptionJobResponse");
+var de_StartTranscriptionJobResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    TranscriptionJob: (_) => de_TranscriptionJob(_, context)
+  });
+}, "de_StartTranscriptionJobResponse");
+var de_TranscriptionJob = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    CompletionTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    ContentRedaction: import_smithy_client._json,
+    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    FailureReason: import_smithy_client.expectString,
+    IdentifiedLanguageScore: import_smithy_client.limitedParseFloat32,
+    IdentifyLanguage: import_smithy_client.expectBoolean,
+    IdentifyMultipleLanguages: import_smithy_client.expectBoolean,
+    JobExecutionSettings: import_smithy_client._json,
+    LanguageCode: import_smithy_client.expectString,
+    LanguageCodes: (_) => de_LanguageCodeList(_, context),
+    LanguageIdSettings: import_smithy_client._json,
+    LanguageOptions: import_smithy_client._json,
+    Media: import_smithy_client._json,
+    MediaFormat: import_smithy_client.expectString,
+    MediaSampleRateHertz: import_smithy_client.expectInt32,
+    ModelSettings: import_smithy_client._json,
+    Settings: import_smithy_client._json,
+    StartTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Subtitles: import_smithy_client._json,
+    Tags: import_smithy_client._json,
+    ToxicityDetection: import_smithy_client._json,
+    Transcript: import_smithy_client._json,
+    TranscriptionJobName: import_smithy_client.expectString,
+    TranscriptionJobStatus: import_smithy_client.expectString
+  });
+}, "de_TranscriptionJob");
+var de_TranscriptionJobSummaries = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_TranscriptionJobSummary(entry, context);
+  });
+  return retVal;
+}, "de_TranscriptionJobSummaries");
+var de_TranscriptionJobSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    CompletionTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    ContentRedaction: import_smithy_client._json,
+    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    FailureReason: import_smithy_client.expectString,
+    IdentifiedLanguageScore: import_smithy_client.limitedParseFloat32,
+    IdentifyLanguage: import_smithy_client.expectBoolean,
+    IdentifyMultipleLanguages: import_smithy_client.expectBoolean,
+    LanguageCode: import_smithy_client.expectString,
+    LanguageCodes: (_) => de_LanguageCodeList(_, context),
+    ModelSettings: import_smithy_client._json,
+    OutputLocationType: import_smithy_client.expectString,
+    StartTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    ToxicityDetection: import_smithy_client._json,
+    TranscriptionJobName: import_smithy_client.expectString,
+    TranscriptionJobStatus: import_smithy_client.expectString
+  });
+}, "de_TranscriptionJobSummary");
+var de_UpdateCallAnalyticsCategoryResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    CategoryProperties: (_) => de_CategoryProperties(_, context)
+  });
+}, "de_UpdateCallAnalyticsCategoryResponse");
+var de_UpdateMedicalVocabularyResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    LanguageCode: import_smithy_client.expectString,
+    LastModifiedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    VocabularyName: import_smithy_client.expectString,
+    VocabularyState: import_smithy_client.expectString
+  });
+}, "de_UpdateMedicalVocabularyResponse");
+var de_UpdateVocabularyFilterResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    LanguageCode: import_smithy_client.expectString,
+    LastModifiedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    VocabularyFilterName: import_smithy_client.expectString
+  });
+}, "de_UpdateVocabularyFilterResponse");
+var de_UpdateVocabularyResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    LanguageCode: import_smithy_client.expectString,
+    LastModifiedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    VocabularyName: import_smithy_client.expectString,
+    VocabularyState: import_smithy_client.expectString
+  });
+}, "de_UpdateVocabularyResponse");
+var de_Vocabularies = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_VocabularyInfo(entry, context);
+  });
+  return retVal;
+}, "de_Vocabularies");
+var de_VocabularyFilterInfo = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    LanguageCode: import_smithy_client.expectString,
+    LastModifiedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    VocabularyFilterName: import_smithy_client.expectString
+  });
+}, "de_VocabularyFilterInfo");
+var de_VocabularyFilters = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_VocabularyFilterInfo(entry, context);
+  });
+  return retVal;
+}, "de_VocabularyFilters");
+var de_VocabularyInfo = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    LanguageCode: import_smithy_client.expectString,
+    LastModifiedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    VocabularyName: import_smithy_client.expectString,
+    VocabularyState: import_smithy_client.expectString
+  });
+}, "de_VocabularyInfo");
+var deserializeMetadata = /* @__PURE__ */ __name((output) => ({
+  httpStatusCode: output.statusCode,
+  requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
+  extendedRequestId: output.headers["x-amz-id-2"],
+  cfId: output.headers["x-amz-cf-id"]
+}), "deserializeMetadata");
+var collectBodyString = /* @__PURE__ */ __name((streamBody, context) => (0, import_smithy_client.collectBody)(streamBody, context).then((body) => context.utf8Encoder(body)), "collectBodyString");
+var throwDefaultError = (0, import_smithy_client.withBaseException)(TranscribeServiceException);
+var buildHttpRpcRequest = /* @__PURE__ */ __name(async (context, headers, path, resolvedHostname, body) => {
+  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+  const contents = {
+    protocol,
+    hostname,
+    port,
+    method: "POST",
+    path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
+    headers
+  };
+  if (resolvedHostname !== void 0) {
+    contents.hostname = resolvedHostname;
+  }
+  if (body !== void 0) {
+    contents.body = body;
+  }
+  return new import_protocol_http.HttpRequest(contents);
+}, "buildHttpRpcRequest");
+function sharedHeaders(operation) {
+  return {
+    "content-type": "application/x-amz-json-1.1",
+    "x-amz-target": `Transcribe.${operation}`
+  };
+}
+__name(sharedHeaders, "sharedHeaders");
+var parseBody = /* @__PURE__ */ __name((streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
+  if (encoded.length) {
+    return JSON.parse(encoded);
+  }
+  return {};
+}), "parseBody");
+var parseErrorBody = /* @__PURE__ */ __name(async (errorBody, context) => {
+  const value = await parseBody(errorBody, context);
+  value.message = value.message ?? value.Message;
+  return value;
+}, "parseErrorBody");
+var loadRestJsonErrorCode = /* @__PURE__ */ __name((output, data) => {
+  const findKey = /* @__PURE__ */ __name((object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase()), "findKey");
+  const sanitizeErrorCode = /* @__PURE__ */ __name((rawValue) => {
+    let cleanValue = rawValue;
+    if (typeof cleanValue === "number") {
+      cleanValue = cleanValue.toString();
+    }
+    if (cleanValue.indexOf(",") >= 0) {
+      cleanValue = cleanValue.split(",")[0];
+    }
+    if (cleanValue.indexOf(":") >= 0) {
+      cleanValue = cleanValue.split(":")[0];
+    }
+    if (cleanValue.indexOf("#") >= 0) {
+      cleanValue = cleanValue.split("#")[1];
+    }
+    return cleanValue;
+  }, "sanitizeErrorCode");
+  const headerKey = findKey(output.headers, "x-amzn-errortype");
+  if (headerKey !== void 0) {
+    return sanitizeErrorCode(output.headers[headerKey]);
+  }
+  if (data.code !== void 0) {
+    return sanitizeErrorCode(data.code);
+  }
+  if (data["__type"] !== void 0) {
+    return sanitizeErrorCode(data["__type"]);
+  }
+}, "loadRestJsonErrorCode");
+
+// src/commands/CreateCallAnalyticsCategoryCommand.ts
+var _CreateCallAnalyticsCategoryCommand = class _CreateCallAnalyticsCategoryCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Transcribe", "CreateCallAnalyticsCategory", {}).n("TranscribeClient", "CreateCallAnalyticsCategoryCommand").f(void 0, void 0).ser(se_CreateCallAnalyticsCategoryCommand).de(de_CreateCallAnalyticsCategoryCommand).build() {
+};
+__name(_CreateCallAnalyticsCategoryCommand, "CreateCallAnalyticsCategoryCommand");
+var CreateCallAnalyticsCategoryCommand = _CreateCallAnalyticsCategoryCommand;
+
+// src/commands/CreateLanguageModelCommand.ts
+
+
+
+
+var _CreateLanguageModelCommand = class _CreateLanguageModelCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Transcribe", "CreateLanguageModel", {}).n("TranscribeClient", "CreateLanguageModelCommand").f(void 0, void 0).ser(se_CreateLanguageModelCommand).de(de_CreateLanguageModelCommand).build() {
+};
+__name(_CreateLanguageModelCommand, "CreateLanguageModelCommand");
+var CreateLanguageModelCommand = _CreateLanguageModelCommand;
+
+// src/commands/CreateMedicalVocabularyCommand.ts
+
+
+
+
+var _CreateMedicalVocabularyCommand = class _CreateMedicalVocabularyCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Transcribe", "CreateMedicalVocabulary", {}).n("TranscribeClient", "CreateMedicalVocabularyCommand").f(void 0, void 0).ser(se_CreateMedicalVocabularyCommand).de(de_CreateMedicalVocabularyCommand).build() {
+};
+__name(_CreateMedicalVocabularyCommand, "CreateMedicalVocabularyCommand");
+var CreateMedicalVocabularyCommand = _CreateMedicalVocabularyCommand;
+
+// src/commands/CreateVocabularyCommand.ts
+
+
+
+
+var _CreateVocabularyCommand = class _CreateVocabularyCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Transcribe", "CreateVocabulary", {}).n("TranscribeClient", "CreateVocabularyCommand").f(void 0, void 0).ser(se_CreateVocabularyCommand).de(de_CreateVocabularyCommand).build() {
+};
+__name(_CreateVocabularyCommand, "CreateVocabularyCommand");
+var CreateVocabularyCommand = _CreateVocabularyCommand;
+
+// src/commands/CreateVocabularyFilterCommand.ts
+
+
+
+
+var _CreateVocabularyFilterCommand = class _CreateVocabularyFilterCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Transcribe", "CreateVocabularyFilter", {}).n("TranscribeClient", "CreateVocabularyFilterCommand").f(void 0, void 0).ser(se_CreateVocabularyFilterCommand).de(de_CreateVocabularyFilterCommand).build() {
+};
+__name(_CreateVocabularyFilterCommand, "CreateVocabularyFilterCommand");
+var CreateVocabularyFilterCommand = _CreateVocabularyFilterCommand;
+
+// src/commands/DeleteCallAnalyticsCategoryCommand.ts
+
+
+
+
+var _DeleteCallAnalyticsCategoryCommand = class _DeleteCallAnalyticsCategoryCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Transcribe", "DeleteCallAnalyticsCategory", {}).n("TranscribeClient", "DeleteCallAnalyticsCategoryCommand").f(void 0, void 0).ser(se_DeleteCallAnalyticsCategoryCommand).de(de_DeleteCallAnalyticsCategoryCommand).build() {
+};
+__name(_DeleteCallAnalyticsCategoryCommand, "DeleteCallAnalyticsCategoryCommand");
+var DeleteCallAnalyticsCategoryCommand = _DeleteCallAnalyticsCategoryCommand;
+
+// src/commands/DeleteCallAnalyticsJobCommand.ts
+
+
+
+
+var _DeleteCallAnalyticsJobCommand = class _DeleteCallAnalyticsJobCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Transcribe", "DeleteCallAnalyticsJob", {}).n("TranscribeClient", "DeleteCallAnalyticsJobCommand").f(void 0, void 0).ser(se_DeleteCallAnalyticsJobCommand).de(de_DeleteCallAnalyticsJobCommand).build() {
+};
+__name(_DeleteCallAnalyticsJobCommand, "DeleteCallAnalyticsJobCommand");
+var DeleteCallAnalyticsJobCommand = _DeleteCallAnalyticsJobCommand;
+
+// src/commands/DeleteLanguageModelCommand.ts
+
+
+
+
+var _DeleteLanguageModelCommand = class _DeleteLanguageModelCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Transcribe", "DeleteLanguageModel", {}).n("TranscribeClient", "DeleteLanguageModelCommand").f(void 0, void 0).ser(se_DeleteLanguageModelCommand).de(de_DeleteLanguageModelCommand).build() {
+};
+__name(_DeleteLanguageModelCommand, "DeleteLanguageModelCommand");
+var DeleteLanguageModelCommand = _DeleteLanguageModelCommand;
+
+// src/commands/DeleteMedicalScribeJobCommand.ts
+
+
+
+
+var _DeleteMedicalScribeJobCommand = class _DeleteMedicalScribeJobCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Transcribe", "DeleteMedicalScribeJob", {}).n("TranscribeClient", "DeleteMedicalScribeJobCommand").f(void 0, void 0).ser(se_DeleteMedicalScribeJobCommand).de(de_DeleteMedicalScribeJobCommand).build() {
+};
+__name(_DeleteMedicalScribeJobCommand, "DeleteMedicalScribeJobCommand");
+var DeleteMedicalScribeJobCommand = _DeleteMedicalScribeJobCommand;
+
+// src/commands/DeleteMedicalTranscriptionJobCommand.ts
+
+
+
+
+var _DeleteMedicalTranscriptionJobCommand = class _DeleteMedicalTranscriptionJobCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Transcribe", "DeleteMedicalTranscriptionJob", {}).n("TranscribeClient", "DeleteMedicalTranscriptionJobCommand").f(void 0, void 0).ser(se_DeleteMedicalTranscriptionJobCommand).de(de_DeleteMedicalTranscriptionJobCommand).build() {
+};
+__name(_DeleteMedicalTranscriptionJobCommand, "DeleteMedicalTranscriptionJobCommand");
+var DeleteMedicalTranscriptionJobCommand = _DeleteMedicalTranscriptionJobCommand;
+
+// src/commands/DeleteMedicalVocabularyCommand.ts
+
+
+
+
+var _DeleteMedicalVocabularyCommand = class _DeleteMedicalVocabularyCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Transcribe", "DeleteMedicalVocabulary", {}).n("TranscribeClient", "DeleteMedicalVocabularyCommand").f(void 0, void 0).ser(se_DeleteMedicalVocabularyCommand).de(de_DeleteMedicalVocabularyCommand).build() {
+};
+__name(_DeleteMedicalVocabularyCommand, "DeleteMedicalVocabularyCommand");
+var DeleteMedicalVocabularyCommand = _DeleteMedicalVocabularyCommand;
+
+// src/commands/DeleteTranscriptionJobCommand.ts
+
+
+
+
+var _DeleteTranscriptionJobCommand = class _DeleteTranscriptionJobCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Transcribe", "DeleteTranscriptionJob", {}).n("TranscribeClient", "DeleteTranscriptionJobCommand").f(void 0, void 0).ser(se_DeleteTranscriptionJobCommand).de(de_DeleteTranscriptionJobCommand).build() {
+};
+__name(_DeleteTranscriptionJobCommand, "DeleteTranscriptionJobCommand");
+var DeleteTranscriptionJobCommand = _DeleteTranscriptionJobCommand;
+
+// src/commands/DeleteVocabularyCommand.ts
+
+
+
+
+var _DeleteVocabularyCommand = class _DeleteVocabularyCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Transcribe", "DeleteVocabulary", {}).n("TranscribeClient", "DeleteVocabularyCommand").f(void 0, void 0).ser(se_DeleteVocabularyCommand).de(de_DeleteVocabularyCommand).build() {
+};
+__name(_DeleteVocabularyCommand, "DeleteVocabularyCommand");
+var DeleteVocabularyCommand = _DeleteVocabularyCommand;
+
+// src/commands/DeleteVocabularyFilterCommand.ts
+
+
+
+
+var _DeleteVocabularyFilterCommand = class _DeleteVocabularyFilterCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Transcribe", "DeleteVocabularyFilter", {}).n("TranscribeClient", "DeleteVocabularyFilterCommand").f(void 0, void 0).ser(se_DeleteVocabularyFilterCommand).de(de_DeleteVocabularyFilterCommand).build() {
+};
+__name(_DeleteVocabularyFilterCommand, "DeleteVocabularyFilterCommand");
+var DeleteVocabularyFilterCommand = _DeleteVocabularyFilterCommand;
+
+// src/commands/DescribeLanguageModelCommand.ts
+
+
+
+
+var _DescribeLanguageModelCommand = class _DescribeLanguageModelCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Transcribe", "DescribeLanguageModel", {}).n("TranscribeClient", "DescribeLanguageModelCommand").f(void 0, void 0).ser(se_DescribeLanguageModelCommand).de(de_DescribeLanguageModelCommand).build() {
+};
+__name(_DescribeLanguageModelCommand, "DescribeLanguageModelCommand");
+var DescribeLanguageModelCommand = _DescribeLanguageModelCommand;
+
+// src/commands/GetCallAnalyticsCategoryCommand.ts
+
+
+
+
+var _GetCallAnalyticsCategoryCommand = class _GetCallAnalyticsCategoryCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Transcribe", "GetCallAnalyticsCategory", {}).n("TranscribeClient", "GetCallAnalyticsCategoryCommand").f(void 0, void 0).ser(se_GetCallAnalyticsCategoryCommand).de(de_GetCallAnalyticsCategoryCommand).build() {
+};
+__name(_GetCallAnalyticsCategoryCommand, "GetCallAnalyticsCategoryCommand");
+var GetCallAnalyticsCategoryCommand = _GetCallAnalyticsCategoryCommand;
+
+// src/commands/GetCallAnalyticsJobCommand.ts
+
+
+
+
+var _GetCallAnalyticsJobCommand = class _GetCallAnalyticsJobCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Transcribe", "GetCallAnalyticsJob", {}).n("TranscribeClient", "GetCallAnalyticsJobCommand").f(void 0, void 0).ser(se_GetCallAnalyticsJobCommand).de(de_GetCallAnalyticsJobCommand).build() {
+};
+__name(_GetCallAnalyticsJobCommand, "GetCallAnalyticsJobCommand");
+var GetCallAnalyticsJobCommand = _GetCallAnalyticsJobCommand;
+
+// src/commands/GetMedicalScribeJobCommand.ts
+
+
+
+
+var _GetMedicalScribeJobCommand = class _GetMedicalScribeJobCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Transcribe", "GetMedicalScribeJob", {}).n("TranscribeClient", "GetMedicalScribeJobCommand").f(void 0, void 0).ser(se_GetMedicalScribeJobCommand).de(de_GetMedicalScribeJobCommand).build() {
+};
+__name(_GetMedicalScribeJobCommand, "GetMedicalScribeJobCommand");
+var GetMedicalScribeJobCommand = _GetMedicalScribeJobCommand;
+
+// src/commands/GetMedicalTranscriptionJobCommand.ts
+
+
+
+
+var _GetMedicalTranscriptionJobCommand = class _GetMedicalTranscriptionJobCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Transcribe", "GetMedicalTranscriptionJob", {}).n("TranscribeClient", "GetMedicalTranscriptionJobCommand").f(void 0, void 0).ser(se_GetMedicalTranscriptionJobCommand).de(de_GetMedicalTranscriptionJobCommand).build() {
+};
+__name(_GetMedicalTranscriptionJobCommand, "GetMedicalTranscriptionJobCommand");
+var GetMedicalTranscriptionJobCommand = _GetMedicalTranscriptionJobCommand;
+
+// src/commands/GetMedicalVocabularyCommand.ts
+
+
+
+
+var _GetMedicalVocabularyCommand = class _GetMedicalVocabularyCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Transcribe", "GetMedicalVocabulary", {}).n("TranscribeClient", "GetMedicalVocabularyCommand").f(void 0, void 0).ser(se_GetMedicalVocabularyCommand).de(de_GetMedicalVocabularyCommand).build() {
+};
+__name(_GetMedicalVocabularyCommand, "GetMedicalVocabularyCommand");
+var GetMedicalVocabularyCommand = _GetMedicalVocabularyCommand;
+
+// src/commands/GetTranscriptionJobCommand.ts
+
+
+
+
+var _GetTranscriptionJobCommand = class _GetTranscriptionJobCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Transcribe", "GetTranscriptionJob", {}).n("TranscribeClient", "GetTranscriptionJobCommand").f(void 0, void 0).ser(se_GetTranscriptionJobCommand).de(de_GetTranscriptionJobCommand).build() {
+};
+__name(_GetTranscriptionJobCommand, "GetTranscriptionJobCommand");
+var GetTranscriptionJobCommand = _GetTranscriptionJobCommand;
+
+// src/commands/GetVocabularyCommand.ts
+
+
+
+
+var _GetVocabularyCommand = class _GetVocabularyCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Transcribe", "GetVocabulary", {}).n("TranscribeClient", "GetVocabularyCommand").f(void 0, void 0).ser(se_GetVocabularyCommand).de(de_GetVocabularyCommand).build() {
+};
+__name(_GetVocabularyCommand, "GetVocabularyCommand");
+var GetVocabularyCommand = _GetVocabularyCommand;
+
+// src/commands/GetVocabularyFilterCommand.ts
+
+
+
+
+var _GetVocabularyFilterCommand = class _GetVocabularyFilterCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Transcribe", "GetVocabularyFilter", {}).n("TranscribeClient", "GetVocabularyFilterCommand").f(void 0, void 0).ser(se_GetVocabularyFilterCommand).de(de_GetVocabularyFilterCommand).build() {
+};
+__name(_GetVocabularyFilterCommand, "GetVocabularyFilterCommand");
+var GetVocabularyFilterCommand = _GetVocabularyFilterCommand;
+
+// src/commands/ListCallAnalyticsCategoriesCommand.ts
+
+
+
+
+var _ListCallAnalyticsCategoriesCommand = class _ListCallAnalyticsCategoriesCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Transcribe", "ListCallAnalyticsCategories", {}).n("TranscribeClient", "ListCallAnalyticsCategoriesCommand").f(void 0, void 0).ser(se_ListCallAnalyticsCategoriesCommand).de(de_ListCallAnalyticsCategoriesCommand).build() {
+};
+__name(_ListCallAnalyticsCategoriesCommand, "ListCallAnalyticsCategoriesCommand");
+var ListCallAnalyticsCategoriesCommand = _ListCallAnalyticsCategoriesCommand;
+
+// src/commands/ListCallAnalyticsJobsCommand.ts
+
+
+
+
+var _ListCallAnalyticsJobsCommand = class _ListCallAnalyticsJobsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Transcribe", "ListCallAnalyticsJobs", {}).n("TranscribeClient", "ListCallAnalyticsJobsCommand").f(void 0, void 0).ser(se_ListCallAnalyticsJobsCommand).de(de_ListCallAnalyticsJobsCommand).build() {
+};
+__name(_ListCallAnalyticsJobsCommand, "ListCallAnalyticsJobsCommand");
+var ListCallAnalyticsJobsCommand = _ListCallAnalyticsJobsCommand;
+
+// src/commands/ListLanguageModelsCommand.ts
+
+
+
+
+var _ListLanguageModelsCommand = class _ListLanguageModelsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Transcribe", "ListLanguageModels", {}).n("TranscribeClient", "ListLanguageModelsCommand").f(void 0, void 0).ser(se_ListLanguageModelsCommand).de(de_ListLanguageModelsCommand).build() {
+};
+__name(_ListLanguageModelsCommand, "ListLanguageModelsCommand");
+var ListLanguageModelsCommand = _ListLanguageModelsCommand;
+
+// src/commands/ListMedicalScribeJobsCommand.ts
+
+
+
+
+var _ListMedicalScribeJobsCommand = class _ListMedicalScribeJobsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Transcribe", "ListMedicalScribeJobs", {}).n("TranscribeClient", "ListMedicalScribeJobsCommand").f(void 0, void 0).ser(se_ListMedicalScribeJobsCommand).de(de_ListMedicalScribeJobsCommand).build() {
+};
+__name(_ListMedicalScribeJobsCommand, "ListMedicalScribeJobsCommand");
+var ListMedicalScribeJobsCommand = _ListMedicalScribeJobsCommand;
+
+// src/commands/ListMedicalTranscriptionJobsCommand.ts
+
+
+
+
+var _ListMedicalTranscriptionJobsCommand = class _ListMedicalTranscriptionJobsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Transcribe", "ListMedicalTranscriptionJobs", {}).n("TranscribeClient", "ListMedicalTranscriptionJobsCommand").f(void 0, void 0).ser(se_ListMedicalTranscriptionJobsCommand).de(de_ListMedicalTranscriptionJobsCommand).build() {
+};
+__name(_ListMedicalTranscriptionJobsCommand, "ListMedicalTranscriptionJobsCommand");
+var ListMedicalTranscriptionJobsCommand = _ListMedicalTranscriptionJobsCommand;
+
+// src/commands/ListMedicalVocabulariesCommand.ts
+
+
+
+
+var _ListMedicalVocabulariesCommand = class _ListMedicalVocabulariesCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Transcribe", "ListMedicalVocabularies", {}).n("TranscribeClient", "ListMedicalVocabulariesCommand").f(void 0, void 0).ser(se_ListMedicalVocabulariesCommand).de(de_ListMedicalVocabulariesCommand).build() {
+};
+__name(_ListMedicalVocabulariesCommand, "ListMedicalVocabulariesCommand");
+var ListMedicalVocabulariesCommand = _ListMedicalVocabulariesCommand;
+
+// src/commands/ListTagsForResourceCommand.ts
+
+
+
+
+var _ListTagsForResourceCommand = class _ListTagsForResourceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Transcribe", "ListTagsForResource", {}).n("TranscribeClient", "ListTagsForResourceCommand").f(void 0, void 0).ser(se_ListTagsForResourceCommand).de(de_ListTagsForResourceCommand).build() {
+};
+__name(_ListTagsForResourceCommand, "ListTagsForResourceCommand");
+var ListTagsForResourceCommand = _ListTagsForResourceCommand;
+
+// src/commands/ListTranscriptionJobsCommand.ts
+
+
+
+
+var _ListTranscriptionJobsCommand = class _ListTranscriptionJobsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Transcribe", "ListTranscriptionJobs", {}).n("TranscribeClient", "ListTranscriptionJobsCommand").f(void 0, void 0).ser(se_ListTranscriptionJobsCommand).de(de_ListTranscriptionJobsCommand).build() {
+};
+__name(_ListTranscriptionJobsCommand, "ListTranscriptionJobsCommand");
+var ListTranscriptionJobsCommand = _ListTranscriptionJobsCommand;
+
+// src/commands/ListVocabulariesCommand.ts
+
+
+
+
+var _ListVocabulariesCommand = class _ListVocabulariesCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Transcribe", "ListVocabularies", {}).n("TranscribeClient", "ListVocabulariesCommand").f(void 0, void 0).ser(se_ListVocabulariesCommand).de(de_ListVocabulariesCommand).build() {
+};
+__name(_ListVocabulariesCommand, "ListVocabulariesCommand");
+var ListVocabulariesCommand = _ListVocabulariesCommand;
+
+// src/commands/ListVocabularyFiltersCommand.ts
+
+
+
+
+var _ListVocabularyFiltersCommand = class _ListVocabularyFiltersCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Transcribe", "ListVocabularyFilters", {}).n("TranscribeClient", "ListVocabularyFiltersCommand").f(void 0, void 0).ser(se_ListVocabularyFiltersCommand).de(de_ListVocabularyFiltersCommand).build() {
+};
+__name(_ListVocabularyFiltersCommand, "ListVocabularyFiltersCommand");
+var ListVocabularyFiltersCommand = _ListVocabularyFiltersCommand;
+
+// src/commands/StartCallAnalyticsJobCommand.ts
+
+
+
+
+var _StartCallAnalyticsJobCommand = class _StartCallAnalyticsJobCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Transcribe", "StartCallAnalyticsJob", {}).n("TranscribeClient", "StartCallAnalyticsJobCommand").f(void 0, void 0).ser(se_StartCallAnalyticsJobCommand).de(de_StartCallAnalyticsJobCommand).build() {
+};
+__name(_StartCallAnalyticsJobCommand, "StartCallAnalyticsJobCommand");
+var StartCallAnalyticsJobCommand = _StartCallAnalyticsJobCommand;
+
+// src/commands/StartMedicalScribeJobCommand.ts
+
+
+
+
+var _StartMedicalScribeJobCommand = class _StartMedicalScribeJobCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Transcribe", "StartMedicalScribeJob", {}).n("TranscribeClient", "StartMedicalScribeJobCommand").f(void 0, void 0).ser(se_StartMedicalScribeJobCommand).de(de_StartMedicalScribeJobCommand).build() {
+};
+__name(_StartMedicalScribeJobCommand, "StartMedicalScribeJobCommand");
+var StartMedicalScribeJobCommand = _StartMedicalScribeJobCommand;
+
+// src/commands/StartMedicalTranscriptionJobCommand.ts
+
+
+
+
+var _StartMedicalTranscriptionJobCommand = class _StartMedicalTranscriptionJobCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Transcribe", "StartMedicalTranscriptionJob", {}).n("TranscribeClient", "StartMedicalTranscriptionJobCommand").f(void 0, void 0).ser(se_StartMedicalTranscriptionJobCommand).de(de_StartMedicalTranscriptionJobCommand).build() {
+};
+__name(_StartMedicalTranscriptionJobCommand, "StartMedicalTranscriptionJobCommand");
+var StartMedicalTranscriptionJobCommand = _StartMedicalTranscriptionJobCommand;
+
+// src/commands/StartTranscriptionJobCommand.ts
+
+
+
+
+var _StartTranscriptionJobCommand = class _StartTranscriptionJobCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Transcribe", "StartTranscriptionJob", {}).n("TranscribeClient", "StartTranscriptionJobCommand").f(void 0, void 0).ser(se_StartTranscriptionJobCommand).de(de_StartTranscriptionJobCommand).build() {
+};
+__name(_StartTranscriptionJobCommand, "StartTranscriptionJobCommand");
+var StartTranscriptionJobCommand = _StartTranscriptionJobCommand;
+
+// src/commands/TagResourceCommand.ts
+
+
+
+
+var _TagResourceCommand = class _TagResourceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Transcribe", "TagResource", {}).n("TranscribeClient", "TagResourceCommand").f(void 0, void 0).ser(se_TagResourceCommand).de(de_TagResourceCommand).build() {
+};
+__name(_TagResourceCommand, "TagResourceCommand");
+var TagResourceCommand = _TagResourceCommand;
+
+// src/commands/UntagResourceCommand.ts
+
+
+
+
+var _UntagResourceCommand = class _UntagResourceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Transcribe", "UntagResource", {}).n("TranscribeClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
+};
+__name(_UntagResourceCommand, "UntagResourceCommand");
+var UntagResourceCommand = _UntagResourceCommand;
+
+// src/commands/UpdateCallAnalyticsCategoryCommand.ts
+
+
+
+
+var _UpdateCallAnalyticsCategoryCommand = class _UpdateCallAnalyticsCategoryCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Transcribe", "UpdateCallAnalyticsCategory", {}).n("TranscribeClient", "UpdateCallAnalyticsCategoryCommand").f(void 0, void 0).ser(se_UpdateCallAnalyticsCategoryCommand).de(de_UpdateCallAnalyticsCategoryCommand).build() {
+};
+__name(_UpdateCallAnalyticsCategoryCommand, "UpdateCallAnalyticsCategoryCommand");
+var UpdateCallAnalyticsCategoryCommand = _UpdateCallAnalyticsCategoryCommand;
+
+// src/commands/UpdateMedicalVocabularyCommand.ts
+
+
+
+
+var _UpdateMedicalVocabularyCommand = class _UpdateMedicalVocabularyCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Transcribe", "UpdateMedicalVocabulary", {}).n("TranscribeClient", "UpdateMedicalVocabularyCommand").f(void 0, void 0).ser(se_UpdateMedicalVocabularyCommand).de(de_UpdateMedicalVocabularyCommand).build() {
+};
+__name(_UpdateMedicalVocabularyCommand, "UpdateMedicalVocabularyCommand");
+var UpdateMedicalVocabularyCommand = _UpdateMedicalVocabularyCommand;
+
+// src/commands/UpdateVocabularyCommand.ts
+
+
+
+
+var _UpdateVocabularyCommand = class _UpdateVocabularyCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Transcribe", "UpdateVocabulary", {}).n("TranscribeClient", "UpdateVocabularyCommand").f(void 0, void 0).ser(se_UpdateVocabularyCommand).de(de_UpdateVocabularyCommand).build() {
+};
+__name(_UpdateVocabularyCommand, "UpdateVocabularyCommand");
+var UpdateVocabularyCommand = _UpdateVocabularyCommand;
+
+// src/commands/UpdateVocabularyFilterCommand.ts
+
+
+
+
+var _UpdateVocabularyFilterCommand = class _UpdateVocabularyFilterCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Transcribe", "UpdateVocabularyFilter", {}).n("TranscribeClient", "UpdateVocabularyFilterCommand").f(void 0, void 0).ser(se_UpdateVocabularyFilterCommand).de(de_UpdateVocabularyFilterCommand).build() {
+};
+__name(_UpdateVocabularyFilterCommand, "UpdateVocabularyFilterCommand");
+var UpdateVocabularyFilterCommand = _UpdateVocabularyFilterCommand;
+
+// src/Transcribe.ts
+var commands = {
+  CreateCallAnalyticsCategoryCommand,
+  CreateLanguageModelCommand,
+  CreateMedicalVocabularyCommand,
+  CreateVocabularyCommand,
+  CreateVocabularyFilterCommand,
+  DeleteCallAnalyticsCategoryCommand,
+  DeleteCallAnalyticsJobCommand,
+  DeleteLanguageModelCommand,
+  DeleteMedicalScribeJobCommand,
+  DeleteMedicalTranscriptionJobCommand,
+  DeleteMedicalVocabularyCommand,
+  DeleteTranscriptionJobCommand,
+  DeleteVocabularyCommand,
+  DeleteVocabularyFilterCommand,
+  DescribeLanguageModelCommand,
+  GetCallAnalyticsCategoryCommand,
+  GetCallAnalyticsJobCommand,
+  GetMedicalScribeJobCommand,
+  GetMedicalTranscriptionJobCommand,
+  GetMedicalVocabularyCommand,
+  GetTranscriptionJobCommand,
+  GetVocabularyCommand,
+  GetVocabularyFilterCommand,
+  ListCallAnalyticsCategoriesCommand,
+  ListCallAnalyticsJobsCommand,
+  ListLanguageModelsCommand,
+  ListMedicalScribeJobsCommand,
+  ListMedicalTranscriptionJobsCommand,
+  ListMedicalVocabulariesCommand,
+  ListTagsForResourceCommand,
+  ListTranscriptionJobsCommand,
+  ListVocabulariesCommand,
+  ListVocabularyFiltersCommand,
+  StartCallAnalyticsJobCommand,
+  StartMedicalScribeJobCommand,
+  StartMedicalTranscriptionJobCommand,
+  StartTranscriptionJobCommand,
+  TagResourceCommand,
+  UntagResourceCommand,
+  UpdateCallAnalyticsCategoryCommand,
+  UpdateMedicalVocabularyCommand,
+  UpdateVocabularyCommand,
+  UpdateVocabularyFilterCommand
+};
+var _Transcribe = class _Transcribe extends TranscribeClient {
+};
+__name(_Transcribe, "Transcribe");
+var Transcribe = _Transcribe;
+(0, import_smithy_client.createAggregatedClient)(commands, Transcribe);
+
+// src/pagination/ListCallAnalyticsCategoriesPaginator.ts
+var import_core = require("@smithy/core");
+var paginateListCallAnalyticsCategories = (0, import_core.createPaginator)(TranscribeClient, ListCallAnalyticsCategoriesCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListCallAnalyticsJobsPaginator.ts
+
+var paginateListCallAnalyticsJobs = (0, import_core.createPaginator)(TranscribeClient, ListCallAnalyticsJobsCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListLanguageModelsPaginator.ts
+
+var paginateListLanguageModels = (0, import_core.createPaginator)(TranscribeClient, ListLanguageModelsCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListMedicalScribeJobsPaginator.ts
+
+var paginateListMedicalScribeJobs = (0, import_core.createPaginator)(TranscribeClient, ListMedicalScribeJobsCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListMedicalTranscriptionJobsPaginator.ts
+
+var paginateListMedicalTranscriptionJobs = (0, import_core.createPaginator)(TranscribeClient, ListMedicalTranscriptionJobsCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListMedicalVocabulariesPaginator.ts
+
+var paginateListMedicalVocabularies = (0, import_core.createPaginator)(TranscribeClient, ListMedicalVocabulariesCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListTranscriptionJobsPaginator.ts
+
+var paginateListTranscriptionJobs = (0, import_core.createPaginator)(TranscribeClient, ListTranscriptionJobsCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListVocabulariesPaginator.ts
+
+var paginateListVocabularies = (0, import_core.createPaginator)(TranscribeClient, ListVocabulariesCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListVocabularyFiltersPaginator.ts
+
+var paginateListVocabularyFilters = (0, import_core.createPaginator)(TranscribeClient, ListVocabularyFiltersCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/index.ts
+var import_util_endpoints = require("@aws-sdk/util-endpoints");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BadRequestException,
+  BaseModelName,
+  CLMLanguageCode,
+  CallAnalyticsJobStatus,
+  ConflictException,
+  CreateCallAnalyticsCategoryCommand,
+  CreateLanguageModelCommand,
+  CreateMedicalVocabularyCommand,
+  CreateVocabularyCommand,
+  CreateVocabularyFilterCommand,
+  DeleteCallAnalyticsCategoryCommand,
+  DeleteCallAnalyticsJobCommand,
+  DeleteLanguageModelCommand,
+  DeleteMedicalScribeJobCommand,
+  DeleteMedicalTranscriptionJobCommand,
+  DeleteMedicalVocabularyCommand,
+  DeleteTranscriptionJobCommand,
+  DeleteVocabularyCommand,
+  DeleteVocabularyFilterCommand,
+  DescribeLanguageModelCommand,
+  GetCallAnalyticsCategoryCommand,
+  GetCallAnalyticsJobCommand,
+  GetMedicalScribeJobCommand,
+  GetMedicalTranscriptionJobCommand,
+  GetMedicalVocabularyCommand,
+  GetTranscriptionJobCommand,
+  GetVocabularyCommand,
+  GetVocabularyFilterCommand,
+  InputType,
+  InternalFailureException,
+  LanguageCode,
+  LimitExceededException,
+  ListCallAnalyticsCategoriesCommand,
+  ListCallAnalyticsJobsCommand,
+  ListLanguageModelsCommand,
+  ListMedicalScribeJobsCommand,
+  ListMedicalTranscriptionJobsCommand,
+  ListMedicalVocabulariesCommand,
+  ListTagsForResourceCommand,
+  ListTranscriptionJobsCommand,
+  ListVocabulariesCommand,
+  ListVocabularyFiltersCommand,
+  MediaFormat,
+  MedicalContentIdentificationType,
+  MedicalScribeJobStatus,
+  MedicalScribeLanguageCode,
+  MedicalScribeParticipantRole,
+  ModelStatus,
+  NotFoundException,
+  OutputLocationType,
+  ParticipantRole,
+  PiiEntityType,
+  RedactionOutput,
+  RedactionType,
+  Rule,
+  SentimentValue,
+  Specialty,
+  StartCallAnalyticsJobCommand,
+  StartMedicalScribeJobCommand,
+  StartMedicalTranscriptionJobCommand,
+  StartTranscriptionJobCommand,
+  SubtitleFormat,
+  TagResourceCommand,
+  ToxicityCategory,
+  Transcribe,
+  TranscribeClient,
+  TranscribeServiceException,
+  TranscriptFilterType,
+  TranscriptionJobStatus,
+  Type,
+  UntagResourceCommand,
+  UpdateCallAnalyticsCategoryCommand,
+  UpdateMedicalVocabularyCommand,
+  UpdateVocabularyCommand,
+  UpdateVocabularyFilterCommand,
+  VocabularyFilterMethod,
+  VocabularyState,
+  __Client,
+  paginateListCallAnalyticsCategories,
+  paginateListCallAnalyticsJobs,
+  paginateListLanguageModels,
+  paginateListMedicalScribeJobs,
+  paginateListMedicalTranscriptionJobs,
+  paginateListMedicalVocabularies,
+  paginateListTranscriptionJobs,
+  paginateListVocabularies,
+  paginateListVocabularyFilters
+});