@aws-amplify/graphql-api-construct 1.12.0-gen2-migration-0809.0 → 1.12.1-async-lambda.0

package/node_modules/@aws-sdk/client-bedrock-runtime/dist-cjs/index.js

@@ -0,0 +1,1924 @@
+"use strict";
+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, {
+  AccessDeniedException: () => AccessDeniedException,
+  ApplyGuardrailCommand: () => ApplyGuardrailCommand,
+  BedrockRuntime: () => BedrockRuntime,
+  BedrockRuntimeClient: () => BedrockRuntimeClient,
+  BedrockRuntimeServiceException: () => BedrockRuntimeServiceException,
+  ContentBlock: () => ContentBlock,
+  ContentBlockDelta: () => ContentBlockDelta,
+  ContentBlockStart: () => ContentBlockStart,
+  ConversationRole: () => ConversationRole,
+  ConverseCommand: () => ConverseCommand,
+  ConverseOutput: () => ConverseOutput,
+  ConverseStreamCommand: () => ConverseStreamCommand,
+  ConverseStreamOutput: () => ConverseStreamOutput,
+  ConverseStreamOutputFilterSensitiveLog: () => ConverseStreamOutputFilterSensitiveLog,
+  ConverseStreamResponseFilterSensitiveLog: () => ConverseStreamResponseFilterSensitiveLog,
+  DocumentFormat: () => DocumentFormat,
+  DocumentSource: () => DocumentSource,
+  GuardrailAction: () => GuardrailAction,
+  GuardrailContentBlock: () => GuardrailContentBlock,
+  GuardrailContentFilterConfidence: () => GuardrailContentFilterConfidence,
+  GuardrailContentFilterType: () => GuardrailContentFilterType,
+  GuardrailContentPolicyAction: () => GuardrailContentPolicyAction,
+  GuardrailContentQualifier: () => GuardrailContentQualifier,
+  GuardrailContentSource: () => GuardrailContentSource,
+  GuardrailContextualGroundingFilterType: () => GuardrailContextualGroundingFilterType,
+  GuardrailContextualGroundingPolicyAction: () => GuardrailContextualGroundingPolicyAction,
+  GuardrailConverseContentBlock: () => GuardrailConverseContentBlock,
+  GuardrailConverseContentQualifier: () => GuardrailConverseContentQualifier,
+  GuardrailManagedWordType: () => GuardrailManagedWordType,
+  GuardrailPiiEntityType: () => GuardrailPiiEntityType,
+  GuardrailSensitiveInformationPolicyAction: () => GuardrailSensitiveInformationPolicyAction,
+  GuardrailStreamProcessingMode: () => GuardrailStreamProcessingMode,
+  GuardrailTopicPolicyAction: () => GuardrailTopicPolicyAction,
+  GuardrailTopicType: () => GuardrailTopicType,
+  GuardrailTrace: () => GuardrailTrace,
+  GuardrailWordPolicyAction: () => GuardrailWordPolicyAction,
+  ImageFormat: () => ImageFormat,
+  ImageSource: () => ImageSource,
+  InternalServerException: () => InternalServerException,
+  InvokeModelCommand: () => InvokeModelCommand,
+  InvokeModelRequestFilterSensitiveLog: () => InvokeModelRequestFilterSensitiveLog,
+  InvokeModelResponseFilterSensitiveLog: () => InvokeModelResponseFilterSensitiveLog,
+  InvokeModelWithResponseStreamCommand: () => InvokeModelWithResponseStreamCommand,
+  InvokeModelWithResponseStreamRequestFilterSensitiveLog: () => InvokeModelWithResponseStreamRequestFilterSensitiveLog,
+  InvokeModelWithResponseStreamResponseFilterSensitiveLog: () => InvokeModelWithResponseStreamResponseFilterSensitiveLog,
+  ModelErrorException: () => ModelErrorException,
+  ModelNotReadyException: () => ModelNotReadyException,
+  ModelStreamErrorException: () => ModelStreamErrorException,
+  ModelTimeoutException: () => ModelTimeoutException,
+  PayloadPartFilterSensitiveLog: () => PayloadPartFilterSensitiveLog,
+  ResourceNotFoundException: () => ResourceNotFoundException,
+  ResponseStream: () => ResponseStream,
+  ResponseStreamFilterSensitiveLog: () => ResponseStreamFilterSensitiveLog,
+  ServiceQuotaExceededException: () => ServiceQuotaExceededException,
+  ServiceUnavailableException: () => ServiceUnavailableException,
+  StopReason: () => StopReason,
+  SystemContentBlock: () => SystemContentBlock,
+  ThrottlingException: () => ThrottlingException,
+  Tool: () => Tool,
+  ToolChoice: () => ToolChoice,
+  ToolInputSchema: () => ToolInputSchema,
+  ToolResultContentBlock: () => ToolResultContentBlock,
+  ToolResultStatus: () => ToolResultStatus,
+  Trace: () => Trace,
+  ValidationException: () => ValidationException,
+  __Client: () => import_smithy_client.Client
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/BedrockRuntimeClient.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_user_agent = require("@aws-sdk/middleware-user-agent");
+var import_config_resolver = require("@smithy/config-resolver");
+var import_core = require("@smithy/core");
+var import_eventstream_serde_config_resolver = require("@smithy/eventstream-serde-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");
+
+var import_httpAuthSchemeProvider = require("./auth/httpAuthSchemeProvider");
+
+// src/endpoint/EndpointParameters.ts
+var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
+  return {
+    ...options,
+    useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+    useFipsEndpoint: options.useFipsEndpoint ?? false,
+    defaultSigningName: "bedrock"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/BedrockRuntimeClient.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");
+
+// src/auth/httpAuthExtensionConfiguration.ts
+var getHttpAuthExtensionConfiguration = /* @__PURE__ */ __name((runtimeConfig) => {
+  const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
+  let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
+  let _credentials = runtimeConfig.credentials;
+  return {
+    setHttpAuthScheme(httpAuthScheme) {
+      const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
+      if (index === -1) {
+        _httpAuthSchemes.push(httpAuthScheme);
+      } else {
+        _httpAuthSchemes.splice(index, 1, httpAuthScheme);
+      }
+    },
+    httpAuthSchemes() {
+      return _httpAuthSchemes;
+    },
+    setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
+      _httpAuthSchemeProvider = httpAuthSchemeProvider;
+    },
+    httpAuthSchemeProvider() {
+      return _httpAuthSchemeProvider;
+    },
+    setCredentials(credentials) {
+      _credentials = credentials;
+    },
+    credentials() {
+      return _credentials;
+    }
+  };
+}, "getHttpAuthExtensionConfiguration");
+var resolveHttpAuthRuntimeConfig = /* @__PURE__ */ __name((config) => {
+  return {
+    httpAuthSchemes: config.httpAuthSchemes(),
+    httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
+    credentials: config.credentials()
+  };
+}, "resolveHttpAuthRuntimeConfig");
+
+// src/runtimeExtensions.ts
+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)),
+    ...asPartial(getHttpAuthExtensionConfiguration(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),
+    ...resolveHttpAuthRuntimeConfig(extensionConfiguration)
+  };
+}, "resolveRuntimeExtensions");
+
+// src/BedrockRuntimeClient.ts
+var _BedrockRuntimeClient = class _BedrockRuntimeClient 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_middleware_user_agent.resolveUserAgentConfig)(_config_1);
+    const _config_3 = (0, import_middleware_retry.resolveRetryConfig)(_config_2);
+    const _config_4 = (0, import_config_resolver.resolveRegionConfig)(_config_3);
+    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
+    const _config_6 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_5);
+    const _config_7 = (0, import_eventstream_serde_config_resolver.resolveEventStreamSerdeConfig)(_config_6);
+    const _config_8 = (0, import_httpAuthSchemeProvider.resolveHttpAuthSchemeConfig)(_config_7);
+    const _config_9 = resolveRuntimeExtensions(_config_8, (configuration == null ? void 0 : configuration.extensions) || []);
+    super(_config_9);
+    this.config = _config_9;
+    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
+    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_core.getHttpAuthSchemeEndpointRuleSetPlugin)(this.config, {
+        httpAuthSchemeParametersProvider: import_httpAuthSchemeProvider.defaultBedrockRuntimeHttpAuthSchemeParametersProvider,
+        identityProviderConfigProvider: async (config) => new import_core.DefaultIdentityProviderConfig({
+          "aws.auth#sigv4": config.credentials
+        })
+      })
+    );
+    this.middlewareStack.use((0, import_core.getHttpSigningPlugin)(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(_BedrockRuntimeClient, "BedrockRuntimeClient");
+var BedrockRuntimeClient = _BedrockRuntimeClient;
+
+// src/BedrockRuntime.ts
+
+
+// src/commands/ApplyGuardrailCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+
+// src/protocols/Aws_restJson1.ts
+var import_core2 = require("@aws-sdk/core");
+
+
+
+// src/models/BedrockRuntimeServiceException.ts
+
+var _BedrockRuntimeServiceException = class _BedrockRuntimeServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _BedrockRuntimeServiceException.prototype);
+  }
+};
+__name(_BedrockRuntimeServiceException, "BedrockRuntimeServiceException");
+var BedrockRuntimeServiceException = _BedrockRuntimeServiceException;
+
+// src/models/models_0.ts
+
+var _AccessDeniedException = class _AccessDeniedException extends BedrockRuntimeServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "AccessDeniedException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "AccessDeniedException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _AccessDeniedException.prototype);
+  }
+};
+__name(_AccessDeniedException, "AccessDeniedException");
+var AccessDeniedException = _AccessDeniedException;
+var GuardrailContentQualifier = {
+  GROUNDING_SOURCE: "grounding_source",
+  GUARD_CONTENT: "guard_content",
+  QUERY: "query"
+};
+var GuardrailContentBlock;
+((GuardrailContentBlock3) => {
+  GuardrailContentBlock3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.text !== void 0)
+      return visitor.text(value.text);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(GuardrailContentBlock || (GuardrailContentBlock = {}));
+var GuardrailContentSource = {
+  INPUT: "INPUT",
+  OUTPUT: "OUTPUT"
+};
+var GuardrailAction = {
+  GUARDRAIL_INTERVENED: "GUARDRAIL_INTERVENED",
+  NONE: "NONE"
+};
+var GuardrailContentPolicyAction = {
+  BLOCKED: "BLOCKED"
+};
+var GuardrailContentFilterConfidence = {
+  HIGH: "HIGH",
+  LOW: "LOW",
+  MEDIUM: "MEDIUM",
+  NONE: "NONE"
+};
+var GuardrailContentFilterType = {
+  HATE: "HATE",
+  INSULTS: "INSULTS",
+  MISCONDUCT: "MISCONDUCT",
+  PROMPT_ATTACK: "PROMPT_ATTACK",
+  SEXUAL: "SEXUAL",
+  VIOLENCE: "VIOLENCE"
+};
+var GuardrailContextualGroundingPolicyAction = {
+  BLOCKED: "BLOCKED",
+  NONE: "NONE"
+};
+var GuardrailContextualGroundingFilterType = {
+  GROUNDING: "GROUNDING",
+  RELEVANCE: "RELEVANCE"
+};
+var GuardrailSensitiveInformationPolicyAction = {
+  ANONYMIZED: "ANONYMIZED",
+  BLOCKED: "BLOCKED"
+};
+var GuardrailPiiEntityType = {
+  ADDRESS: "ADDRESS",
+  AGE: "AGE",
+  AWS_ACCESS_KEY: "AWS_ACCESS_KEY",
+  AWS_SECRET_KEY: "AWS_SECRET_KEY",
+  CA_HEALTH_NUMBER: "CA_HEALTH_NUMBER",
+  CA_SOCIAL_INSURANCE_NUMBER: "CA_SOCIAL_INSURANCE_NUMBER",
+  CREDIT_DEBIT_CARD_CVV: "CREDIT_DEBIT_CARD_CVV",
+  CREDIT_DEBIT_CARD_EXPIRY: "CREDIT_DEBIT_CARD_EXPIRY",
+  CREDIT_DEBIT_CARD_NUMBER: "CREDIT_DEBIT_CARD_NUMBER",
+  DRIVER_ID: "DRIVER_ID",
+  EMAIL: "EMAIL",
+  INTERNATIONAL_BANK_ACCOUNT_NUMBER: "INTERNATIONAL_BANK_ACCOUNT_NUMBER",
+  IP_ADDRESS: "IP_ADDRESS",
+  LICENSE_PLATE: "LICENSE_PLATE",
+  MAC_ADDRESS: "MAC_ADDRESS",
+  NAME: "NAME",
+  PASSWORD: "PASSWORD",
+  PHONE: "PHONE",
+  PIN: "PIN",
+  SWIFT_CODE: "SWIFT_CODE",
+  UK_NATIONAL_HEALTH_SERVICE_NUMBER: "UK_NATIONAL_HEALTH_SERVICE_NUMBER",
+  UK_NATIONAL_INSURANCE_NUMBER: "UK_NATIONAL_INSURANCE_NUMBER",
+  UK_UNIQUE_TAXPAYER_REFERENCE_NUMBER: "UK_UNIQUE_TAXPAYER_REFERENCE_NUMBER",
+  URL: "URL",
+  USERNAME: "USERNAME",
+  US_BANK_ACCOUNT_NUMBER: "US_BANK_ACCOUNT_NUMBER",
+  US_BANK_ROUTING_NUMBER: "US_BANK_ROUTING_NUMBER",
+  US_INDIVIDUAL_TAX_IDENTIFICATION_NUMBER: "US_INDIVIDUAL_TAX_IDENTIFICATION_NUMBER",
+  US_PASSPORT_NUMBER: "US_PASSPORT_NUMBER",
+  US_SOCIAL_SECURITY_NUMBER: "US_SOCIAL_SECURITY_NUMBER",
+  VEHICLE_IDENTIFICATION_NUMBER: "VEHICLE_IDENTIFICATION_NUMBER"
+};
+var GuardrailTopicPolicyAction = {
+  BLOCKED: "BLOCKED"
+};
+var GuardrailTopicType = {
+  DENY: "DENY"
+};
+var GuardrailWordPolicyAction = {
+  BLOCKED: "BLOCKED"
+};
+var GuardrailManagedWordType = {
+  PROFANITY: "PROFANITY"
+};
+var _InternalServerException = class _InternalServerException extends BedrockRuntimeServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InternalServerException",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "InternalServerException";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _InternalServerException.prototype);
+  }
+};
+__name(_InternalServerException, "InternalServerException");
+var InternalServerException = _InternalServerException;
+var _ResourceNotFoundException = class _ResourceNotFoundException extends BedrockRuntimeServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ResourceNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ResourceNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
+  }
+};
+__name(_ResourceNotFoundException, "ResourceNotFoundException");
+var ResourceNotFoundException = _ResourceNotFoundException;
+var _ServiceQuotaExceededException = class _ServiceQuotaExceededException extends BedrockRuntimeServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ServiceQuotaExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ServiceQuotaExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ServiceQuotaExceededException.prototype);
+  }
+};
+__name(_ServiceQuotaExceededException, "ServiceQuotaExceededException");
+var ServiceQuotaExceededException = _ServiceQuotaExceededException;
+var _ThrottlingException = class _ThrottlingException extends BedrockRuntimeServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ThrottlingException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ThrottlingException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ThrottlingException.prototype);
+  }
+};
+__name(_ThrottlingException, "ThrottlingException");
+var ThrottlingException = _ThrottlingException;
+var _ValidationException = class _ValidationException extends BedrockRuntimeServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ValidationException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ValidationException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ValidationException.prototype);
+  }
+};
+__name(_ValidationException, "ValidationException");
+var ValidationException = _ValidationException;
+var GuardrailTrace = {
+  DISABLED: "disabled",
+  ENABLED: "enabled"
+};
+var DocumentFormat = {
+  CSV: "csv",
+  DOC: "doc",
+  DOCX: "docx",
+  HTML: "html",
+  MD: "md",
+  PDF: "pdf",
+  TXT: "txt",
+  XLS: "xls",
+  XLSX: "xlsx"
+};
+var DocumentSource;
+((DocumentSource2) => {
+  DocumentSource2.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.bytes !== void 0)
+      return visitor.bytes(value.bytes);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(DocumentSource || (DocumentSource = {}));
+var GuardrailConverseContentQualifier = {
+  GROUNDING_SOURCE: "grounding_source",
+  GUARD_CONTENT: "guard_content",
+  QUERY: "query"
+};
+var GuardrailConverseContentBlock;
+((GuardrailConverseContentBlock3) => {
+  GuardrailConverseContentBlock3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.text !== void 0)
+      return visitor.text(value.text);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(GuardrailConverseContentBlock || (GuardrailConverseContentBlock = {}));
+var ImageFormat = {
+  GIF: "gif",
+  JPEG: "jpeg",
+  PNG: "png",
+  WEBP: "webp"
+};
+var ImageSource;
+((ImageSource2) => {
+  ImageSource2.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.bytes !== void 0)
+      return visitor.bytes(value.bytes);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(ImageSource || (ImageSource = {}));
+var ToolResultContentBlock;
+((ToolResultContentBlock2) => {
+  ToolResultContentBlock2.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.json !== void 0)
+      return visitor.json(value.json);
+    if (value.text !== void 0)
+      return visitor.text(value.text);
+    if (value.image !== void 0)
+      return visitor.image(value.image);
+    if (value.document !== void 0)
+      return visitor.document(value.document);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(ToolResultContentBlock || (ToolResultContentBlock = {}));
+var ToolResultStatus = {
+  ERROR: "error",
+  SUCCESS: "success"
+};
+var ContentBlock;
+((ContentBlock2) => {
+  ContentBlock2.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.text !== void 0)
+      return visitor.text(value.text);
+    if (value.image !== void 0)
+      return visitor.image(value.image);
+    if (value.document !== void 0)
+      return visitor.document(value.document);
+    if (value.toolUse !== void 0)
+      return visitor.toolUse(value.toolUse);
+    if (value.toolResult !== void 0)
+      return visitor.toolResult(value.toolResult);
+    if (value.guardContent !== void 0)
+      return visitor.guardContent(value.guardContent);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(ContentBlock || (ContentBlock = {}));
+var ConversationRole = {
+  ASSISTANT: "assistant",
+  USER: "user"
+};
+var SystemContentBlock;
+((SystemContentBlock3) => {
+  SystemContentBlock3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.text !== void 0)
+      return visitor.text(value.text);
+    if (value.guardContent !== void 0)
+      return visitor.guardContent(value.guardContent);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(SystemContentBlock || (SystemContentBlock = {}));
+var ToolChoice;
+((ToolChoice3) => {
+  ToolChoice3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.auto !== void 0)
+      return visitor.auto(value.auto);
+    if (value.any !== void 0)
+      return visitor.any(value.any);
+    if (value.tool !== void 0)
+      return visitor.tool(value.tool);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(ToolChoice || (ToolChoice = {}));
+var ToolInputSchema;
+((ToolInputSchema2) => {
+  ToolInputSchema2.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.json !== void 0)
+      return visitor.json(value.json);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(ToolInputSchema || (ToolInputSchema = {}));
+var Tool;
+((Tool2) => {
+  Tool2.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.toolSpec !== void 0)
+      return visitor.toolSpec(value.toolSpec);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(Tool || (Tool = {}));
+var ConverseOutput;
+((ConverseOutput3) => {
+  ConverseOutput3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.message !== void 0)
+      return visitor.message(value.message);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(ConverseOutput || (ConverseOutput = {}));
+var StopReason = {
+  CONTENT_FILTERED: "content_filtered",
+  END_TURN: "end_turn",
+  GUARDRAIL_INTERVENED: "guardrail_intervened",
+  MAX_TOKENS: "max_tokens",
+  STOP_SEQUENCE: "stop_sequence",
+  TOOL_USE: "tool_use"
+};
+var _ModelErrorException = class _ModelErrorException extends BedrockRuntimeServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ModelErrorException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ModelErrorException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ModelErrorException.prototype);
+    this.originalStatusCode = opts.originalStatusCode;
+    this.resourceName = opts.resourceName;
+  }
+};
+__name(_ModelErrorException, "ModelErrorException");
+var ModelErrorException = _ModelErrorException;
+var _ModelNotReadyException = class _ModelNotReadyException extends BedrockRuntimeServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ModelNotReadyException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ModelNotReadyException";
+    this.$fault = "client";
+    this.$retryable = {};
+    Object.setPrototypeOf(this, _ModelNotReadyException.prototype);
+  }
+};
+__name(_ModelNotReadyException, "ModelNotReadyException");
+var ModelNotReadyException = _ModelNotReadyException;
+var _ModelTimeoutException = class _ModelTimeoutException extends BedrockRuntimeServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ModelTimeoutException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ModelTimeoutException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ModelTimeoutException.prototype);
+  }
+};
+__name(_ModelTimeoutException, "ModelTimeoutException");
+var ModelTimeoutException = _ModelTimeoutException;
+var _ServiceUnavailableException = class _ServiceUnavailableException extends BedrockRuntimeServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ServiceUnavailableException",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "ServiceUnavailableException";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _ServiceUnavailableException.prototype);
+  }
+};
+__name(_ServiceUnavailableException, "ServiceUnavailableException");
+var ServiceUnavailableException = _ServiceUnavailableException;
+var GuardrailStreamProcessingMode = {
+  ASYNC: "async",
+  SYNC: "sync"
+};
+var ContentBlockDelta;
+((ContentBlockDelta2) => {
+  ContentBlockDelta2.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.text !== void 0)
+      return visitor.text(value.text);
+    if (value.toolUse !== void 0)
+      return visitor.toolUse(value.toolUse);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(ContentBlockDelta || (ContentBlockDelta = {}));
+var ContentBlockStart;
+((ContentBlockStart2) => {
+  ContentBlockStart2.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.toolUse !== void 0)
+      return visitor.toolUse(value.toolUse);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(ContentBlockStart || (ContentBlockStart = {}));
+var _ModelStreamErrorException = class _ModelStreamErrorException extends BedrockRuntimeServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ModelStreamErrorException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ModelStreamErrorException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ModelStreamErrorException.prototype);
+    this.originalStatusCode = opts.originalStatusCode;
+    this.originalMessage = opts.originalMessage;
+  }
+};
+__name(_ModelStreamErrorException, "ModelStreamErrorException");
+var ModelStreamErrorException = _ModelStreamErrorException;
+var ConverseStreamOutput;
+((ConverseStreamOutput3) => {
+  ConverseStreamOutput3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.messageStart !== void 0)
+      return visitor.messageStart(value.messageStart);
+    if (value.contentBlockStart !== void 0)
+      return visitor.contentBlockStart(value.contentBlockStart);
+    if (value.contentBlockDelta !== void 0)
+      return visitor.contentBlockDelta(value.contentBlockDelta);
+    if (value.contentBlockStop !== void 0)
+      return visitor.contentBlockStop(value.contentBlockStop);
+    if (value.messageStop !== void 0)
+      return visitor.messageStop(value.messageStop);
+    if (value.metadata !== void 0)
+      return visitor.metadata(value.metadata);
+    if (value.internalServerException !== void 0)
+      return visitor.internalServerException(value.internalServerException);
+    if (value.modelStreamErrorException !== void 0)
+      return visitor.modelStreamErrorException(value.modelStreamErrorException);
+    if (value.validationException !== void 0)
+      return visitor.validationException(value.validationException);
+    if (value.throttlingException !== void 0)
+      return visitor.throttlingException(value.throttlingException);
+    if (value.serviceUnavailableException !== void 0)
+      return visitor.serviceUnavailableException(value.serviceUnavailableException);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(ConverseStreamOutput || (ConverseStreamOutput = {}));
+var Trace = {
+  DISABLED: "DISABLED",
+  ENABLED: "ENABLED"
+};
+var ResponseStream;
+((ResponseStream3) => {
+  ResponseStream3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.chunk !== void 0)
+      return visitor.chunk(value.chunk);
+    if (value.internalServerException !== void 0)
+      return visitor.internalServerException(value.internalServerException);
+    if (value.modelStreamErrorException !== void 0)
+      return visitor.modelStreamErrorException(value.modelStreamErrorException);
+    if (value.validationException !== void 0)
+      return visitor.validationException(value.validationException);
+    if (value.throttlingException !== void 0)
+      return visitor.throttlingException(value.throttlingException);
+    if (value.modelTimeoutException !== void 0)
+      return visitor.modelTimeoutException(value.modelTimeoutException);
+    if (value.serviceUnavailableException !== void 0)
+      return visitor.serviceUnavailableException(value.serviceUnavailableException);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(ResponseStream || (ResponseStream = {}));
+var ConverseStreamOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => {
+  if (obj.messageStart !== void 0)
+    return { messageStart: obj.messageStart };
+  if (obj.contentBlockStart !== void 0)
+    return { contentBlockStart: obj.contentBlockStart };
+  if (obj.contentBlockDelta !== void 0)
+    return { contentBlockDelta: obj.contentBlockDelta };
+  if (obj.contentBlockStop !== void 0)
+    return { contentBlockStop: obj.contentBlockStop };
+  if (obj.messageStop !== void 0)
+    return { messageStop: obj.messageStop };
+  if (obj.metadata !== void 0)
+    return { metadata: obj.metadata };
+  if (obj.internalServerException !== void 0)
+    return { internalServerException: obj.internalServerException };
+  if (obj.modelStreamErrorException !== void 0)
+    return { modelStreamErrorException: obj.modelStreamErrorException };
+  if (obj.validationException !== void 0)
+    return { validationException: obj.validationException };
+  if (obj.throttlingException !== void 0)
+    return { throttlingException: obj.throttlingException };
+  if (obj.serviceUnavailableException !== void 0)
+    return { serviceUnavailableException: obj.serviceUnavailableException };
+  if (obj.$unknown !== void 0)
+    return { [obj.$unknown[0]]: "UNKNOWN" };
+}, "ConverseStreamOutputFilterSensitiveLog");
+var ConverseStreamResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.stream && { stream: "STREAMING_CONTENT" }
+}), "ConverseStreamResponseFilterSensitiveLog");
+var InvokeModelRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.body && { body: import_smithy_client.SENSITIVE_STRING }
+}), "InvokeModelRequestFilterSensitiveLog");
+var InvokeModelResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.body && { body: import_smithy_client.SENSITIVE_STRING }
+}), "InvokeModelResponseFilterSensitiveLog");
+var InvokeModelWithResponseStreamRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.body && { body: import_smithy_client.SENSITIVE_STRING }
+}), "InvokeModelWithResponseStreamRequestFilterSensitiveLog");
+var PayloadPartFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.bytes && { bytes: import_smithy_client.SENSITIVE_STRING }
+}), "PayloadPartFilterSensitiveLog");
+var ResponseStreamFilterSensitiveLog = /* @__PURE__ */ __name((obj) => {
+  if (obj.chunk !== void 0)
+    return { chunk: import_smithy_client.SENSITIVE_STRING };
+  if (obj.internalServerException !== void 0)
+    return { internalServerException: obj.internalServerException };
+  if (obj.modelStreamErrorException !== void 0)
+    return { modelStreamErrorException: obj.modelStreamErrorException };
+  if (obj.validationException !== void 0)
+    return { validationException: obj.validationException };
+  if (obj.throttlingException !== void 0)
+    return { throttlingException: obj.throttlingException };
+  if (obj.modelTimeoutException !== void 0)
+    return { modelTimeoutException: obj.modelTimeoutException };
+  if (obj.serviceUnavailableException !== void 0)
+    return { serviceUnavailableException: obj.serviceUnavailableException };
+  if (obj.$unknown !== void 0)
+    return { [obj.$unknown[0]]: "UNKNOWN" };
+}, "ResponseStreamFilterSensitiveLog");
+var InvokeModelWithResponseStreamResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.body && { body: "STREAMING_CONTENT" }
+}), "InvokeModelWithResponseStreamResponseFilterSensitiveLog");
+
+// src/protocols/Aws_restJson1.ts
+var se_ApplyGuardrailCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/guardrail/{guardrailIdentifier}/version/{guardrailVersion}/apply");
+  b.p("guardrailIdentifier", () => input.guardrailIdentifier, "{guardrailIdentifier}", false);
+  b.p("guardrailVersion", () => input.guardrailVersion, "{guardrailVersion}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      content: (_) => (0, import_smithy_client._json)(_),
+      source: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ApplyGuardrailCommand");
+var se_ConverseCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/model/{modelId}/converse");
+  b.p("modelId", () => input.modelId, "{modelId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      additionalModelRequestFields: (_) => se_Document(_, context),
+      additionalModelResponseFieldPaths: (_) => (0, import_smithy_client._json)(_),
+      guardrailConfig: (_) => (0, import_smithy_client._json)(_),
+      inferenceConfig: (_) => se_InferenceConfiguration(_, context),
+      messages: (_) => se_Messages(_, context),
+      system: (_) => (0, import_smithy_client._json)(_),
+      toolConfig: (_) => se_ToolConfiguration(_, context)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ConverseCommand");
+var se_ConverseStreamCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/model/{modelId}/converse-stream");
+  b.p("modelId", () => input.modelId, "{modelId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      additionalModelRequestFields: (_) => se_Document(_, context),
+      additionalModelResponseFieldPaths: (_) => (0, import_smithy_client._json)(_),
+      guardrailConfig: (_) => (0, import_smithy_client._json)(_),
+      inferenceConfig: (_) => se_InferenceConfiguration(_, context),
+      messages: (_) => se_Messages(_, context),
+      system: (_) => (0, import_smithy_client._json)(_),
+      toolConfig: (_) => se_ToolConfiguration(_, context)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ConverseStreamCommand");
+var se_InvokeModelCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = (0, import_smithy_client.map)({}, isSerializableHeaderValue, {
+    [_ct]: input[_cT] || "application/octet-stream",
+    [_a]: input[_a],
+    [_xabt]: input[_t],
+    [_xabg]: input[_gI],
+    [_xabg_]: input[_gV]
+  });
+  b.bp("/model/{modelId}/invoke");
+  b.p("modelId", () => input.modelId, "{modelId}", false);
+  let body;
+  if (input.body !== void 0) {
+    body = input.body;
+  }
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_InvokeModelCommand");
+var se_InvokeModelWithResponseStreamCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = (0, import_smithy_client.map)({}, isSerializableHeaderValue, {
+    [_ct]: input[_cT] || "application/octet-stream",
+    [_xaba]: input[_a],
+    [_xabt]: input[_t],
+    [_xabg]: input[_gI],
+    [_xabg_]: input[_gV]
+  });
+  b.bp("/model/{modelId}/invoke-with-response-stream");
+  b.p("modelId", () => input.modelId, "{modelId}", false);
+  let body;
+  if (input.body !== void 0) {
+    body = input.body;
+  }
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_InvokeModelWithResponseStreamCommand");
+var de_ApplyGuardrailCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    action: import_smithy_client.expectString,
+    assessments: (_) => de_GuardrailAssessmentList(_, context),
+    outputs: import_smithy_client._json,
+    usage: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ApplyGuardrailCommand");
+var de_ConverseCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    additionalModelResponseFields: (_) => de_Document(_, context),
+    metrics: import_smithy_client._json,
+    output: (_) => de_ConverseOutput((0, import_core2.awsExpectUnion)(_), context),
+    stopReason: import_smithy_client.expectString,
+    trace: (_) => de_ConverseTrace(_, context),
+    usage: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ConverseCommand");
+var de_ConverseStreamCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = output.body;
+  contents.stream = de_ConverseStreamOutput(data, context);
+  return contents;
+}, "de_ConverseStreamCommand");
+var de_InvokeModelCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output),
+    [_cT]: [, output.headers[_ct]]
+  });
+  const data = await (0, import_smithy_client.collectBody)(output.body, context);
+  contents.body = data;
+  return contents;
+}, "de_InvokeModelCommand");
+var de_InvokeModelWithResponseStreamCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output),
+    [_cT]: [, output.headers[_xabct]]
+  });
+  const data = output.body;
+  contents.body = de_ResponseStream(data, context);
+  return contents;
+}, "de_InvokeModelWithResponseStreamCommand");
+var de_CommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await (0, import_core2.parseJsonErrorBody)(output.body, context)
+  };
+  const errorCode = (0, import_core2.loadRestJsonErrorCode)(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.bedrockruntime#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.bedrockruntime#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.bedrockruntime#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.bedrockruntime#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.bedrockruntime#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.bedrockruntime#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    case "ModelErrorException":
+    case "com.amazonaws.bedrockruntime#ModelErrorException":
+      throw await de_ModelErrorExceptionRes(parsedOutput, context);
+    case "ModelNotReadyException":
+    case "com.amazonaws.bedrockruntime#ModelNotReadyException":
+      throw await de_ModelNotReadyExceptionRes(parsedOutput, context);
+    case "ModelTimeoutException":
+    case "com.amazonaws.bedrockruntime#ModelTimeoutException":
+      throw await de_ModelTimeoutExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.bedrockruntime#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "ModelStreamErrorException":
+    case "com.amazonaws.bedrockruntime#ModelStreamErrorException":
+      throw await de_ModelStreamErrorExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CommandError");
+var throwDefaultError = (0, import_smithy_client.withBaseException)(BedrockRuntimeServiceException);
+var de_AccessDeniedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new AccessDeniedException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_AccessDeniedExceptionRes");
+var de_InternalServerExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new InternalServerException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_InternalServerExceptionRes");
+var de_ModelErrorExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString,
+    originalStatusCode: import_smithy_client.expectInt32,
+    resourceName: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ModelErrorException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ModelErrorExceptionRes");
+var de_ModelNotReadyExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ModelNotReadyException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ModelNotReadyExceptionRes");
+var de_ModelStreamErrorExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString,
+    originalMessage: import_smithy_client.expectString,
+    originalStatusCode: import_smithy_client.expectInt32
+  });
+  Object.assign(contents, doc);
+  const exception = new ModelStreamErrorException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ModelStreamErrorExceptionRes");
+var de_ModelTimeoutExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ModelTimeoutException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ModelTimeoutExceptionRes");
+var de_ResourceNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ResourceNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ResourceNotFoundExceptionRes");
+var de_ServiceQuotaExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ServiceQuotaExceededException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ServiceQuotaExceededExceptionRes");
+var de_ServiceUnavailableExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ServiceUnavailableException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ServiceUnavailableExceptionRes");
+var de_ThrottlingExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ThrottlingException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ThrottlingExceptionRes");
+var de_ValidationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ValidationException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ValidationExceptionRes");
+var de_ConverseStreamOutput = /* @__PURE__ */ __name((output, context) => {
+  return context.eventStreamMarshaller.deserialize(output, async (event) => {
+    if (event["messageStart"] != null) {
+      return {
+        messageStart: await de_MessageStartEvent_event(event["messageStart"], context)
+      };
+    }
+    if (event["contentBlockStart"] != null) {
+      return {
+        contentBlockStart: await de_ContentBlockStartEvent_event(event["contentBlockStart"], context)
+      };
+    }
+    if (event["contentBlockDelta"] != null) {
+      return {
+        contentBlockDelta: await de_ContentBlockDeltaEvent_event(event["contentBlockDelta"], context)
+      };
+    }
+    if (event["contentBlockStop"] != null) {
+      return {
+        contentBlockStop: await de_ContentBlockStopEvent_event(event["contentBlockStop"], context)
+      };
+    }
+    if (event["messageStop"] != null) {
+      return {
+        messageStop: await de_MessageStopEvent_event(event["messageStop"], context)
+      };
+    }
+    if (event["metadata"] != null) {
+      return {
+        metadata: await de_ConverseStreamMetadataEvent_event(event["metadata"], context)
+      };
+    }
+    if (event["internalServerException"] != null) {
+      return {
+        internalServerException: await de_InternalServerException_event(event["internalServerException"], context)
+      };
+    }
+    if (event["modelStreamErrorException"] != null) {
+      return {
+        modelStreamErrorException: await de_ModelStreamErrorException_event(
+          event["modelStreamErrorException"],
+          context
+        )
+      };
+    }
+    if (event["validationException"] != null) {
+      return {
+        validationException: await de_ValidationException_event(event["validationException"], context)
+      };
+    }
+    if (event["throttlingException"] != null) {
+      return {
+        throttlingException: await de_ThrottlingException_event(event["throttlingException"], context)
+      };
+    }
+    if (event["serviceUnavailableException"] != null) {
+      return {
+        serviceUnavailableException: await de_ServiceUnavailableException_event(
+          event["serviceUnavailableException"],
+          context
+        )
+      };
+    }
+    return { $unknown: output };
+  });
+}, "de_ConverseStreamOutput");
+var de_ResponseStream = /* @__PURE__ */ __name((output, context) => {
+  return context.eventStreamMarshaller.deserialize(output, async (event) => {
+    if (event["chunk"] != null) {
+      return {
+        chunk: await de_PayloadPart_event(event["chunk"], context)
+      };
+    }
+    if (event["internalServerException"] != null) {
+      return {
+        internalServerException: await de_InternalServerException_event(event["internalServerException"], context)
+      };
+    }
+    if (event["modelStreamErrorException"] != null) {
+      return {
+        modelStreamErrorException: await de_ModelStreamErrorException_event(
+          event["modelStreamErrorException"],
+          context
+        )
+      };
+    }
+    if (event["validationException"] != null) {
+      return {
+        validationException: await de_ValidationException_event(event["validationException"], context)
+      };
+    }
+    if (event["throttlingException"] != null) {
+      return {
+        throttlingException: await de_ThrottlingException_event(event["throttlingException"], context)
+      };
+    }
+    if (event["modelTimeoutException"] != null) {
+      return {
+        modelTimeoutException: await de_ModelTimeoutException_event(event["modelTimeoutException"], context)
+      };
+    }
+    if (event["serviceUnavailableException"] != null) {
+      return {
+        serviceUnavailableException: await de_ServiceUnavailableException_event(
+          event["serviceUnavailableException"],
+          context
+        )
+      };
+    }
+    return { $unknown: output };
+  });
+}, "de_ResponseStream");
+var de_ContentBlockDeltaEvent_event = /* @__PURE__ */ __name(async (output, context) => {
+  const contents = {};
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  Object.assign(contents, (0, import_smithy_client._json)(data));
+  return contents;
+}, "de_ContentBlockDeltaEvent_event");
+var de_ContentBlockStartEvent_event = /* @__PURE__ */ __name(async (output, context) => {
+  const contents = {};
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  Object.assign(contents, (0, import_smithy_client._json)(data));
+  return contents;
+}, "de_ContentBlockStartEvent_event");
+var de_ContentBlockStopEvent_event = /* @__PURE__ */ __name(async (output, context) => {
+  const contents = {};
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  Object.assign(contents, (0, import_smithy_client._json)(data));
+  return contents;
+}, "de_ContentBlockStopEvent_event");
+var de_ConverseStreamMetadataEvent_event = /* @__PURE__ */ __name(async (output, context) => {
+  const contents = {};
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  Object.assign(contents, de_ConverseStreamMetadataEvent(data, context));
+  return contents;
+}, "de_ConverseStreamMetadataEvent_event");
+var de_InternalServerException_event = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await (0, import_core2.parseJsonBody)(output.body, context)
+  };
+  return de_InternalServerExceptionRes(parsedOutput, context);
+}, "de_InternalServerException_event");
+var de_MessageStartEvent_event = /* @__PURE__ */ __name(async (output, context) => {
+  const contents = {};
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  Object.assign(contents, (0, import_smithy_client._json)(data));
+  return contents;
+}, "de_MessageStartEvent_event");
+var de_MessageStopEvent_event = /* @__PURE__ */ __name(async (output, context) => {
+  const contents = {};
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  Object.assign(contents, de_MessageStopEvent(data, context));
+  return contents;
+}, "de_MessageStopEvent_event");
+var de_ModelStreamErrorException_event = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await (0, import_core2.parseJsonBody)(output.body, context)
+  };
+  return de_ModelStreamErrorExceptionRes(parsedOutput, context);
+}, "de_ModelStreamErrorException_event");
+var de_ModelTimeoutException_event = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await (0, import_core2.parseJsonBody)(output.body, context)
+  };
+  return de_ModelTimeoutExceptionRes(parsedOutput, context);
+}, "de_ModelTimeoutException_event");
+var de_PayloadPart_event = /* @__PURE__ */ __name(async (output, context) => {
+  const contents = {};
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  Object.assign(contents, de_PayloadPart(data, context));
+  return contents;
+}, "de_PayloadPart_event");
+var de_ServiceUnavailableException_event = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await (0, import_core2.parseJsonBody)(output.body, context)
+  };
+  return de_ServiceUnavailableExceptionRes(parsedOutput, context);
+}, "de_ServiceUnavailableException_event");
+var de_ThrottlingException_event = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await (0, import_core2.parseJsonBody)(output.body, context)
+  };
+  return de_ThrottlingExceptionRes(parsedOutput, context);
+}, "de_ThrottlingException_event");
+var de_ValidationException_event = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await (0, import_core2.parseJsonBody)(output.body, context)
+  };
+  return de_ValidationExceptionRes(parsedOutput, context);
+}, "de_ValidationException_event");
+var se_ContentBlock = /* @__PURE__ */ __name((input, context) => {
+  return ContentBlock.visit(input, {
+    document: (value) => ({ document: se_DocumentBlock(value, context) }),
+    guardContent: (value) => ({ guardContent: (0, import_smithy_client._json)(value) }),
+    image: (value) => ({ image: se_ImageBlock(value, context) }),
+    text: (value) => ({ text: value }),
+    toolResult: (value) => ({ toolResult: se_ToolResultBlock(value, context) }),
+    toolUse: (value) => ({ toolUse: se_ToolUseBlock(value, context) }),
+    _: (name, value) => ({ name: value })
+  });
+}, "se_ContentBlock");
+var se_ContentBlocks = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_ContentBlock(entry, context);
+  });
+}, "se_ContentBlocks");
+var se_DocumentBlock = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    format: [],
+    name: [],
+    source: (_) => se_DocumentSource(_, context)
+  });
+}, "se_DocumentBlock");
+var se_DocumentSource = /* @__PURE__ */ __name((input, context) => {
+  return DocumentSource.visit(input, {
+    bytes: (value) => ({ bytes: context.base64Encoder(value) }),
+    _: (name, value) => ({ name: value })
+  });
+}, "se_DocumentSource");
+var se_ImageBlock = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    format: [],
+    source: (_) => se_ImageSource(_, context)
+  });
+}, "se_ImageBlock");
+var se_ImageSource = /* @__PURE__ */ __name((input, context) => {
+  return ImageSource.visit(input, {
+    bytes: (value) => ({ bytes: context.base64Encoder(value) }),
+    _: (name, value) => ({ name: value })
+  });
+}, "se_ImageSource");
+var se_InferenceConfiguration = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    maxTokens: [],
+    stopSequences: import_smithy_client._json,
+    temperature: import_smithy_client.serializeFloat,
+    topP: import_smithy_client.serializeFloat
+  });
+}, "se_InferenceConfiguration");
+var se_Message = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    content: (_) => se_ContentBlocks(_, context),
+    role: []
+  });
+}, "se_Message");
+var se_Messages = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_Message(entry, context);
+  });
+}, "se_Messages");
+var se_Tool = /* @__PURE__ */ __name((input, context) => {
+  return Tool.visit(input, {
+    toolSpec: (value) => ({ toolSpec: se_ToolSpecification(value, context) }),
+    _: (name, value) => ({ name: value })
+  });
+}, "se_Tool");
+var se_ToolConfiguration = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    toolChoice: import_smithy_client._json,
+    tools: (_) => se_Tools(_, context)
+  });
+}, "se_ToolConfiguration");
+var se_ToolInputSchema = /* @__PURE__ */ __name((input, context) => {
+  return ToolInputSchema.visit(input, {
+    json: (value) => ({ json: se_Document(value, context) }),
+    _: (name, value) => ({ name: value })
+  });
+}, "se_ToolInputSchema");
+var se_ToolResultBlock = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    content: (_) => se_ToolResultContentBlocks(_, context),
+    status: [],
+    toolUseId: []
+  });
+}, "se_ToolResultBlock");
+var se_ToolResultContentBlock = /* @__PURE__ */ __name((input, context) => {
+  return ToolResultContentBlock.visit(input, {
+    document: (value) => ({ document: se_DocumentBlock(value, context) }),
+    image: (value) => ({ image: se_ImageBlock(value, context) }),
+    json: (value) => ({ json: se_Document(value, context) }),
+    text: (value) => ({ text: value }),
+    _: (name, value) => ({ name: value })
+  });
+}, "se_ToolResultContentBlock");
+var se_ToolResultContentBlocks = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_ToolResultContentBlock(entry, context);
+  });
+}, "se_ToolResultContentBlocks");
+var se_Tools = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_Tool(entry, context);
+  });
+}, "se_Tools");
+var se_ToolSpecification = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    description: [],
+    inputSchema: (_) => se_ToolInputSchema(_, context),
+    name: []
+  });
+}, "se_ToolSpecification");
+var se_ToolUseBlock = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    input: (_) => se_Document(_, context),
+    name: [],
+    toolUseId: []
+  });
+}, "se_ToolUseBlock");
+var se_Document = /* @__PURE__ */ __name((input, context) => {
+  return input;
+}, "se_Document");
+var de_ContentBlock = /* @__PURE__ */ __name((output, context) => {
+  if (output.document != null) {
+    return {
+      document: de_DocumentBlock(output.document, context)
+    };
+  }
+  if (output.guardContent != null) {
+    return {
+      guardContent: (0, import_smithy_client._json)((0, import_core2.awsExpectUnion)(output.guardContent))
+    };
+  }
+  if (output.image != null) {
+    return {
+      image: de_ImageBlock(output.image, context)
+    };
+  }
+  if ((0, import_smithy_client.expectString)(output.text) !== void 0) {
+    return { text: (0, import_smithy_client.expectString)(output.text) };
+  }
+  if (output.toolResult != null) {
+    return {
+      toolResult: de_ToolResultBlock(output.toolResult, context)
+    };
+  }
+  if (output.toolUse != null) {
+    return {
+      toolUse: de_ToolUseBlock(output.toolUse, context)
+    };
+  }
+  return { $unknown: Object.entries(output)[0] };
+}, "de_ContentBlock");
+var de_ContentBlocks = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_ContentBlock((0, import_core2.awsExpectUnion)(entry), context);
+  });
+  return retVal;
+}, "de_ContentBlocks");
+var de_ConverseOutput = /* @__PURE__ */ __name((output, context) => {
+  if (output.message != null) {
+    return {
+      message: de_Message(output.message, context)
+    };
+  }
+  return { $unknown: Object.entries(output)[0] };
+}, "de_ConverseOutput");
+var de_ConverseStreamMetadataEvent = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    metrics: import_smithy_client._json,
+    trace: (_) => de_ConverseStreamTrace(_, context),
+    usage: import_smithy_client._json
+  });
+}, "de_ConverseStreamMetadataEvent");
+var de_ConverseStreamTrace = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    guardrail: (_) => de_GuardrailTraceAssessment(_, context)
+  });
+}, "de_ConverseStreamTrace");
+var de_ConverseTrace = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    guardrail: (_) => de_GuardrailTraceAssessment(_, context)
+  });
+}, "de_ConverseTrace");
+var de_DocumentBlock = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    format: import_smithy_client.expectString,
+    name: import_smithy_client.expectString,
+    source: (_) => de_DocumentSource((0, import_core2.awsExpectUnion)(_), context)
+  });
+}, "de_DocumentBlock");
+var de_DocumentSource = /* @__PURE__ */ __name((output, context) => {
+  if (output.bytes != null) {
+    return {
+      bytes: context.base64Decoder(output.bytes)
+    };
+  }
+  return { $unknown: Object.entries(output)[0] };
+}, "de_DocumentSource");
+var de_GuardrailAssessment = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    contentPolicy: import_smithy_client._json,
+    contextualGroundingPolicy: (_) => de_GuardrailContextualGroundingPolicyAssessment(_, context),
+    sensitiveInformationPolicy: import_smithy_client._json,
+    topicPolicy: import_smithy_client._json,
+    wordPolicy: import_smithy_client._json
+  });
+}, "de_GuardrailAssessment");
+var de_GuardrailAssessmentList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_GuardrailAssessment(entry, context);
+  });
+  return retVal;
+}, "de_GuardrailAssessmentList");
+var de_GuardrailAssessmentListMap = /* @__PURE__ */ __name((output, context) => {
+  return Object.entries(output).reduce((acc, [key, value]) => {
+    if (value === null) {
+      return acc;
+    }
+    acc[key] = de_GuardrailAssessmentList(value, context);
+    return acc;
+  }, {});
+}, "de_GuardrailAssessmentListMap");
+var de_GuardrailAssessmentMap = /* @__PURE__ */ __name((output, context) => {
+  return Object.entries(output).reduce((acc, [key, value]) => {
+    if (value === null) {
+      return acc;
+    }
+    acc[key] = de_GuardrailAssessment(value, context);
+    return acc;
+  }, {});
+}, "de_GuardrailAssessmentMap");
+var de_GuardrailContextualGroundingFilter = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    action: import_smithy_client.expectString,
+    score: import_smithy_client.limitedParseDouble,
+    threshold: import_smithy_client.limitedParseDouble,
+    type: import_smithy_client.expectString
+  });
+}, "de_GuardrailContextualGroundingFilter");
+var de_GuardrailContextualGroundingFilters = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_GuardrailContextualGroundingFilter(entry, context);
+  });
+  return retVal;
+}, "de_GuardrailContextualGroundingFilters");
+var de_GuardrailContextualGroundingPolicyAssessment = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    filters: (_) => de_GuardrailContextualGroundingFilters(_, context)
+  });
+}, "de_GuardrailContextualGroundingPolicyAssessment");
+var de_GuardrailTraceAssessment = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    inputAssessment: (_) => de_GuardrailAssessmentMap(_, context),
+    modelOutput: import_smithy_client._json,
+    outputAssessments: (_) => de_GuardrailAssessmentListMap(_, context)
+  });
+}, "de_GuardrailTraceAssessment");
+var de_ImageBlock = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    format: import_smithy_client.expectString,
+    source: (_) => de_ImageSource((0, import_core2.awsExpectUnion)(_), context)
+  });
+}, "de_ImageBlock");
+var de_ImageSource = /* @__PURE__ */ __name((output, context) => {
+  if (output.bytes != null) {
+    return {
+      bytes: context.base64Decoder(output.bytes)
+    };
+  }
+  return { $unknown: Object.entries(output)[0] };
+}, "de_ImageSource");
+var de_Message = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    content: (_) => de_ContentBlocks(_, context),
+    role: import_smithy_client.expectString
+  });
+}, "de_Message");
+var de_MessageStopEvent = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    additionalModelResponseFields: (_) => de_Document(_, context),
+    stopReason: import_smithy_client.expectString
+  });
+}, "de_MessageStopEvent");
+var de_PayloadPart = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    bytes: context.base64Decoder
+  });
+}, "de_PayloadPart");
+var de_ToolResultBlock = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    content: (_) => de_ToolResultContentBlocks(_, context),
+    status: import_smithy_client.expectString,
+    toolUseId: import_smithy_client.expectString
+  });
+}, "de_ToolResultBlock");
+var de_ToolResultContentBlock = /* @__PURE__ */ __name((output, context) => {
+  if (output.document != null) {
+    return {
+      document: de_DocumentBlock(output.document, context)
+    };
+  }
+  if (output.image != null) {
+    return {
+      image: de_ImageBlock(output.image, context)
+    };
+  }
+  if (output.json != null) {
+    return {
+      json: de_Document(output.json, context)
+    };
+  }
+  if ((0, import_smithy_client.expectString)(output.text) !== void 0) {
+    return { text: (0, import_smithy_client.expectString)(output.text) };
+  }
+  return { $unknown: Object.entries(output)[0] };
+}, "de_ToolResultContentBlock");
+var de_ToolResultContentBlocks = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_ToolResultContentBlock((0, import_core2.awsExpectUnion)(entry), context);
+  });
+  return retVal;
+}, "de_ToolResultContentBlocks");
+var de_ToolUseBlock = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    input: (_) => de_Document(_, context),
+    name: import_smithy_client.expectString,
+    toolUseId: import_smithy_client.expectString
+  });
+}, "de_ToolUseBlock");
+var de_Document = /* @__PURE__ */ __name((output, context) => {
+  return output;
+}, "de_Document");
+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 isSerializableHeaderValue = /* @__PURE__ */ __name((value) => value !== void 0 && value !== null && value !== "" && (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) && (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0), "isSerializableHeaderValue");
+var _a = "accept";
+var _cT = "contentType";
+var _ct = "content-type";
+var _gI = "guardrailIdentifier";
+var _gV = "guardrailVersion";
+var _t = "trace";
+var _xaba = "x-amzn-bedrock-accept";
+var _xabct = "x-amzn-bedrock-content-type";
+var _xabg = "x-amzn-bedrock-guardrailidentifier";
+var _xabg_ = "x-amzn-bedrock-guardrailversion";
+var _xabt = "x-amzn-bedrock-trace";
+
+// src/commands/ApplyGuardrailCommand.ts
+var _ApplyGuardrailCommand = class _ApplyGuardrailCommand 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("AmazonBedrockFrontendService", "ApplyGuardrail", {}).n("BedrockRuntimeClient", "ApplyGuardrailCommand").f(void 0, void 0).ser(se_ApplyGuardrailCommand).de(de_ApplyGuardrailCommand).build() {
+};
+__name(_ApplyGuardrailCommand, "ApplyGuardrailCommand");
+var ApplyGuardrailCommand = _ApplyGuardrailCommand;
+
+// src/commands/ConverseCommand.ts
+
+
+
+var _ConverseCommand = class _ConverseCommand 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("AmazonBedrockFrontendService", "Converse", {}).n("BedrockRuntimeClient", "ConverseCommand").f(void 0, void 0).ser(se_ConverseCommand).de(de_ConverseCommand).build() {
+};
+__name(_ConverseCommand, "ConverseCommand");
+var ConverseCommand = _ConverseCommand;
+
+// src/commands/ConverseStreamCommand.ts
+
+
+
+var _ConverseStreamCommand = class _ConverseStreamCommand 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("AmazonBedrockFrontendService", "ConverseStream", {
+  /**
+   * @internal
+   */
+  eventStream: {
+    output: true
+  }
+}).n("BedrockRuntimeClient", "ConverseStreamCommand").f(void 0, ConverseStreamResponseFilterSensitiveLog).ser(se_ConverseStreamCommand).de(de_ConverseStreamCommand).build() {
+};
+__name(_ConverseStreamCommand, "ConverseStreamCommand");
+var ConverseStreamCommand = _ConverseStreamCommand;
+
+// src/commands/InvokeModelCommand.ts
+
+
+
+var _InvokeModelCommand = class _InvokeModelCommand 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("AmazonBedrockFrontendService", "InvokeModel", {}).n("BedrockRuntimeClient", "InvokeModelCommand").f(InvokeModelRequestFilterSensitiveLog, InvokeModelResponseFilterSensitiveLog).ser(se_InvokeModelCommand).de(de_InvokeModelCommand).build() {
+};
+__name(_InvokeModelCommand, "InvokeModelCommand");
+var InvokeModelCommand = _InvokeModelCommand;
+
+// src/commands/InvokeModelWithResponseStreamCommand.ts
+
+
+
+var _InvokeModelWithResponseStreamCommand = class _InvokeModelWithResponseStreamCommand 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("AmazonBedrockFrontendService", "InvokeModelWithResponseStream", {
+  /**
+   * @internal
+   */
+  eventStream: {
+    output: true
+  }
+}).n("BedrockRuntimeClient", "InvokeModelWithResponseStreamCommand").f(InvokeModelWithResponseStreamRequestFilterSensitiveLog, InvokeModelWithResponseStreamResponseFilterSensitiveLog).ser(se_InvokeModelWithResponseStreamCommand).de(de_InvokeModelWithResponseStreamCommand).build() {
+};
+__name(_InvokeModelWithResponseStreamCommand, "InvokeModelWithResponseStreamCommand");
+var InvokeModelWithResponseStreamCommand = _InvokeModelWithResponseStreamCommand;
+
+// src/BedrockRuntime.ts
+var commands = {
+  ApplyGuardrailCommand,
+  ConverseCommand,
+  ConverseStreamCommand,
+  InvokeModelCommand,
+  InvokeModelWithResponseStreamCommand
+};
+var _BedrockRuntime = class _BedrockRuntime extends BedrockRuntimeClient {
+};
+__name(_BedrockRuntime, "BedrockRuntime");
+var BedrockRuntime = _BedrockRuntime;
+(0, import_smithy_client.createAggregatedClient)(commands, BedrockRuntime);
+// Annotate the CommonJS export names for ESM import in node:
+
+0 && (module.exports = {
+  BedrockRuntimeServiceException,
+  __Client,
+  BedrockRuntimeClient,
+  BedrockRuntime,
+  $Command,
+  ApplyGuardrailCommand,
+  ConverseCommand,
+  ConverseStreamCommand,
+  InvokeModelCommand,
+  InvokeModelWithResponseStreamCommand,
+  AccessDeniedException,
+  GuardrailContentQualifier,
+  GuardrailContentBlock,
+  GuardrailContentSource,
+  GuardrailAction,
+  GuardrailContentPolicyAction,
+  GuardrailContentFilterConfidence,
+  GuardrailContentFilterType,
+  GuardrailContextualGroundingPolicyAction,
+  GuardrailContextualGroundingFilterType,
+  GuardrailSensitiveInformationPolicyAction,
+  GuardrailPiiEntityType,
+  GuardrailTopicPolicyAction,
+  GuardrailTopicType,
+  GuardrailWordPolicyAction,
+  GuardrailManagedWordType,
+  InternalServerException,
+  ResourceNotFoundException,
+  ServiceQuotaExceededException,
+  ThrottlingException,
+  ValidationException,
+  GuardrailTrace,
+  DocumentFormat,
+  DocumentSource,
+  GuardrailConverseContentQualifier,
+  GuardrailConverseContentBlock,
+  ImageFormat,
+  ImageSource,
+  ToolResultContentBlock,
+  ToolResultStatus,
+  ContentBlock,
+  ConversationRole,
+  SystemContentBlock,
+  ToolChoice,
+  ToolInputSchema,
+  Tool,
+  ConverseOutput,
+  StopReason,
+  ModelErrorException,
+  ModelNotReadyException,
+  ModelTimeoutException,
+  ServiceUnavailableException,
+  GuardrailStreamProcessingMode,
+  ContentBlockDelta,
+  ContentBlockStart,
+  ModelStreamErrorException,
+  ConverseStreamOutput,
+  Trace,
+  ResponseStream,
+  ConverseStreamOutputFilterSensitiveLog,
+  ConverseStreamResponseFilterSensitiveLog,
+  InvokeModelRequestFilterSensitiveLog,
+  InvokeModelResponseFilterSensitiveLog,
+  InvokeModelWithResponseStreamRequestFilterSensitiveLog,
+  PayloadPartFilterSensitiveLog,
+  ResponseStreamFilterSensitiveLog,
+  InvokeModelWithResponseStreamResponseFilterSensitiveLog
+});
+