@aws-sdk/client-kinesis-analytics 3.490.0 → 3.495.0

package/dist-cjs/index.js

@@ -1,11 +1,1985 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.KinesisAnalyticsServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./KinesisAnalyticsClient"), exports);
-tslib_1.__exportStar(require("./KinesisAnalytics"), exports);
-tslib_1.__exportStar(require("./commands"), exports);
-tslib_1.__exportStar(require("./models"), exports);
-require("@aws-sdk/util-endpoints");
-var KinesisAnalyticsServiceException_1 = require("./models/KinesisAnalyticsServiceException");
-Object.defineProperty(exports, "KinesisAnalyticsServiceException", { enumerable: true, get: function () { return KinesisAnalyticsServiceException_1.KinesisAnalyticsServiceException; } });
+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, {
+  AddApplicationCloudWatchLoggingOptionCommand: () => AddApplicationCloudWatchLoggingOptionCommand,
+  AddApplicationInputCommand: () => AddApplicationInputCommand,
+  AddApplicationInputProcessingConfigurationCommand: () => AddApplicationInputProcessingConfigurationCommand,
+  AddApplicationOutputCommand: () => AddApplicationOutputCommand,
+  AddApplicationReferenceDataSourceCommand: () => AddApplicationReferenceDataSourceCommand,
+  ApplicationStatus: () => ApplicationStatus,
+  CodeValidationException: () => CodeValidationException,
+  ConcurrentModificationException: () => ConcurrentModificationException,
+  CreateApplicationCommand: () => CreateApplicationCommand,
+  DeleteApplicationCloudWatchLoggingOptionCommand: () => DeleteApplicationCloudWatchLoggingOptionCommand,
+  DeleteApplicationCommand: () => DeleteApplicationCommand,
+  DeleteApplicationInputProcessingConfigurationCommand: () => DeleteApplicationInputProcessingConfigurationCommand,
+  DeleteApplicationOutputCommand: () => DeleteApplicationOutputCommand,
+  DeleteApplicationReferenceDataSourceCommand: () => DeleteApplicationReferenceDataSourceCommand,
+  DescribeApplicationCommand: () => DescribeApplicationCommand,
+  DiscoverInputSchemaCommand: () => DiscoverInputSchemaCommand,
+  InputStartingPosition: () => InputStartingPosition,
+  InvalidApplicationConfigurationException: () => InvalidApplicationConfigurationException,
+  InvalidArgumentException: () => InvalidArgumentException,
+  KinesisAnalytics: () => KinesisAnalytics,
+  KinesisAnalyticsClient: () => KinesisAnalyticsClient,
+  KinesisAnalyticsServiceException: () => KinesisAnalyticsServiceException,
+  LimitExceededException: () => LimitExceededException,
+  ListApplicationsCommand: () => ListApplicationsCommand,
+  ListTagsForResourceCommand: () => ListTagsForResourceCommand,
+  RecordFormatType: () => RecordFormatType,
+  ResourceInUseException: () => ResourceInUseException,
+  ResourceNotFoundException: () => ResourceNotFoundException,
+  ResourceProvisionedThroughputExceededException: () => ResourceProvisionedThroughputExceededException,
+  ServiceUnavailableException: () => ServiceUnavailableException,
+  StartApplicationCommand: () => StartApplicationCommand,
+  StopApplicationCommand: () => StopApplicationCommand,
+  TagResourceCommand: () => TagResourceCommand,
+  TooManyTagsException: () => TooManyTagsException,
+  UnableToDetectSchemaException: () => UnableToDetectSchemaException,
+  UnsupportedOperationException: () => UnsupportedOperationException,
+  UntagResourceCommand: () => UntagResourceCommand,
+  UpdateApplicationCommand: () => UpdateApplicationCommand,
+  __Client: () => import_smithy_client.Client
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/KinesisAnalyticsClient.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: "kinesisanalytics"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/KinesisAnalyticsClient.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/KinesisAnalyticsClient.ts
+var _KinesisAnalyticsClient = class _KinesisAnalyticsClient 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(_KinesisAnalyticsClient, "KinesisAnalyticsClient");
+var KinesisAnalyticsClient = _KinesisAnalyticsClient;
+
+// src/KinesisAnalytics.ts
+
+
+// src/commands/AddApplicationCloudWatchLoggingOptionCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/protocols/Aws_json1_1.ts
+
+
+
+// src/models/KinesisAnalyticsServiceException.ts
+
+var _KinesisAnalyticsServiceException = class _KinesisAnalyticsServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _KinesisAnalyticsServiceException.prototype);
+  }
+};
+__name(_KinesisAnalyticsServiceException, "KinesisAnalyticsServiceException");
+var KinesisAnalyticsServiceException = _KinesisAnalyticsServiceException;
+
+// src/models/models_0.ts
+var _ConcurrentModificationException = class _ConcurrentModificationException extends KinesisAnalyticsServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ConcurrentModificationException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ConcurrentModificationException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ConcurrentModificationException.prototype);
+  }
+};
+__name(_ConcurrentModificationException, "ConcurrentModificationException");
+var ConcurrentModificationException = _ConcurrentModificationException;
+var _InvalidArgumentException = class _InvalidArgumentException extends KinesisAnalyticsServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidArgumentException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidArgumentException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidArgumentException.prototype);
+  }
+};
+__name(_InvalidArgumentException, "InvalidArgumentException");
+var InvalidArgumentException = _InvalidArgumentException;
+var _ResourceInUseException = class _ResourceInUseException extends KinesisAnalyticsServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ResourceInUseException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ResourceInUseException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ResourceInUseException.prototype);
+  }
+};
+__name(_ResourceInUseException, "ResourceInUseException");
+var ResourceInUseException = _ResourceInUseException;
+var _ResourceNotFoundException = class _ResourceNotFoundException extends KinesisAnalyticsServiceException {
+  /**
+   * @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 _UnsupportedOperationException = class _UnsupportedOperationException extends KinesisAnalyticsServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "UnsupportedOperationException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "UnsupportedOperationException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _UnsupportedOperationException.prototype);
+  }
+};
+__name(_UnsupportedOperationException, "UnsupportedOperationException");
+var UnsupportedOperationException = _UnsupportedOperationException;
+var RecordFormatType = {
+  CSV: "CSV",
+  JSON: "JSON"
+};
+var _CodeValidationException = class _CodeValidationException extends KinesisAnalyticsServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "CodeValidationException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "CodeValidationException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _CodeValidationException.prototype);
+  }
+};
+__name(_CodeValidationException, "CodeValidationException");
+var CodeValidationException = _CodeValidationException;
+var ApplicationStatus = {
+  DELETING: "DELETING",
+  READY: "READY",
+  RUNNING: "RUNNING",
+  STARTING: "STARTING",
+  STOPPING: "STOPPING",
+  UPDATING: "UPDATING"
+};
+var InputStartingPosition = {
+  LAST_STOPPED_POINT: "LAST_STOPPED_POINT",
+  NOW: "NOW",
+  TRIM_HORIZON: "TRIM_HORIZON"
+};
+var _LimitExceededException = class _LimitExceededException extends KinesisAnalyticsServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "LimitExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "LimitExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _LimitExceededException.prototype);
+  }
+};
+__name(_LimitExceededException, "LimitExceededException");
+var LimitExceededException = _LimitExceededException;
+var _TooManyTagsException = class _TooManyTagsException extends KinesisAnalyticsServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "TooManyTagsException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "TooManyTagsException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _TooManyTagsException.prototype);
+  }
+};
+__name(_TooManyTagsException, "TooManyTagsException");
+var TooManyTagsException = _TooManyTagsException;
+var _ResourceProvisionedThroughputExceededException = class _ResourceProvisionedThroughputExceededException extends KinesisAnalyticsServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ResourceProvisionedThroughputExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ResourceProvisionedThroughputExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ResourceProvisionedThroughputExceededException.prototype);
+  }
+};
+__name(_ResourceProvisionedThroughputExceededException, "ResourceProvisionedThroughputExceededException");
+var ResourceProvisionedThroughputExceededException = _ResourceProvisionedThroughputExceededException;
+var _ServiceUnavailableException = class _ServiceUnavailableException extends KinesisAnalyticsServiceException {
+  /**
+   * @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 _UnableToDetectSchemaException = class _UnableToDetectSchemaException extends KinesisAnalyticsServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "UnableToDetectSchemaException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "UnableToDetectSchemaException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _UnableToDetectSchemaException.prototype);
+    this.RawInputRecords = opts.RawInputRecords;
+    this.ProcessedInputRecords = opts.ProcessedInputRecords;
+  }
+};
+__name(_UnableToDetectSchemaException, "UnableToDetectSchemaException");
+var UnableToDetectSchemaException = _UnableToDetectSchemaException;
+var _InvalidApplicationConfigurationException = class _InvalidApplicationConfigurationException extends KinesisAnalyticsServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidApplicationConfigurationException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidApplicationConfigurationException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidApplicationConfigurationException.prototype);
+  }
+};
+__name(_InvalidApplicationConfigurationException, "InvalidApplicationConfigurationException");
+var InvalidApplicationConfigurationException = _InvalidApplicationConfigurationException;
+
+// src/protocols/Aws_json1_1.ts
+var se_AddApplicationCloudWatchLoggingOptionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("AddApplicationCloudWatchLoggingOption");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_AddApplicationCloudWatchLoggingOptionCommand");
+var se_AddApplicationInputCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("AddApplicationInput");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_AddApplicationInputCommand");
+var se_AddApplicationInputProcessingConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("AddApplicationInputProcessingConfiguration");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_AddApplicationInputProcessingConfigurationCommand");
+var se_AddApplicationOutputCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("AddApplicationOutput");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_AddApplicationOutputCommand");
+var se_AddApplicationReferenceDataSourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("AddApplicationReferenceDataSource");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_AddApplicationReferenceDataSourceCommand");
+var se_CreateApplicationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateApplication");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateApplicationCommand");
+var se_DeleteApplicationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteApplication");
+  let body;
+  body = JSON.stringify(se_DeleteApplicationRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteApplicationCommand");
+var se_DeleteApplicationCloudWatchLoggingOptionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteApplicationCloudWatchLoggingOption");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteApplicationCloudWatchLoggingOptionCommand");
+var se_DeleteApplicationInputProcessingConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteApplicationInputProcessingConfiguration");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteApplicationInputProcessingConfigurationCommand");
+var se_DeleteApplicationOutputCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteApplicationOutput");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteApplicationOutputCommand");
+var se_DeleteApplicationReferenceDataSourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteApplicationReferenceDataSource");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteApplicationReferenceDataSourceCommand");
+var se_DescribeApplicationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeApplication");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeApplicationCommand");
+var se_DiscoverInputSchemaCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DiscoverInputSchema");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DiscoverInputSchemaCommand");
+var se_ListApplicationsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListApplications");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListApplicationsCommand");
+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_StartApplicationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("StartApplication");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_StartApplicationCommand");
+var se_StopApplicationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("StopApplication");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_StopApplicationCommand");
+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_UpdateApplicationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateApplication");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateApplicationCommand");
+var de_AddApplicationCloudWatchLoggingOptionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_AddApplicationCloudWatchLoggingOptionCommandError(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_AddApplicationCloudWatchLoggingOptionCommand");
+var de_AddApplicationCloudWatchLoggingOptionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentModificationException":
+    case "com.amazonaws.kinesisanalytics#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    case "InvalidArgumentException":
+    case "com.amazonaws.kinesisanalytics#InvalidArgumentException":
+      throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+    case "ResourceInUseException":
+    case "com.amazonaws.kinesisanalytics#ResourceInUseException":
+      throw await de_ResourceInUseExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.kinesisanalytics#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "UnsupportedOperationException":
+    case "com.amazonaws.kinesisanalytics#UnsupportedOperationException":
+      throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_AddApplicationCloudWatchLoggingOptionCommandError");
+var de_AddApplicationInputCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_AddApplicationInputCommandError(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_AddApplicationInputCommand");
+var de_AddApplicationInputCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "CodeValidationException":
+    case "com.amazonaws.kinesisanalytics#CodeValidationException":
+      throw await de_CodeValidationExceptionRes(parsedOutput, context);
+    case "ConcurrentModificationException":
+    case "com.amazonaws.kinesisanalytics#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    case "InvalidArgumentException":
+    case "com.amazonaws.kinesisanalytics#InvalidArgumentException":
+      throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+    case "ResourceInUseException":
+    case "com.amazonaws.kinesisanalytics#ResourceInUseException":
+      throw await de_ResourceInUseExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.kinesisanalytics#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "UnsupportedOperationException":
+    case "com.amazonaws.kinesisanalytics#UnsupportedOperationException":
+      throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_AddApplicationInputCommandError");
+var de_AddApplicationInputProcessingConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_AddApplicationInputProcessingConfigurationCommandError(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_AddApplicationInputProcessingConfigurationCommand");
+var de_AddApplicationInputProcessingConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentModificationException":
+    case "com.amazonaws.kinesisanalytics#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    case "InvalidArgumentException":
+    case "com.amazonaws.kinesisanalytics#InvalidArgumentException":
+      throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+    case "ResourceInUseException":
+    case "com.amazonaws.kinesisanalytics#ResourceInUseException":
+      throw await de_ResourceInUseExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.kinesisanalytics#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "UnsupportedOperationException":
+    case "com.amazonaws.kinesisanalytics#UnsupportedOperationException":
+      throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_AddApplicationInputProcessingConfigurationCommandError");
+var de_AddApplicationOutputCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_AddApplicationOutputCommandError(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_AddApplicationOutputCommand");
+var de_AddApplicationOutputCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentModificationException":
+    case "com.amazonaws.kinesisanalytics#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    case "InvalidArgumentException":
+    case "com.amazonaws.kinesisanalytics#InvalidArgumentException":
+      throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+    case "ResourceInUseException":
+    case "com.amazonaws.kinesisanalytics#ResourceInUseException":
+      throw await de_ResourceInUseExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.kinesisanalytics#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "UnsupportedOperationException":
+    case "com.amazonaws.kinesisanalytics#UnsupportedOperationException":
+      throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_AddApplicationOutputCommandError");
+var de_AddApplicationReferenceDataSourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_AddApplicationReferenceDataSourceCommandError(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_AddApplicationReferenceDataSourceCommand");
+var de_AddApplicationReferenceDataSourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentModificationException":
+    case "com.amazonaws.kinesisanalytics#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    case "InvalidArgumentException":
+    case "com.amazonaws.kinesisanalytics#InvalidArgumentException":
+      throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+    case "ResourceInUseException":
+    case "com.amazonaws.kinesisanalytics#ResourceInUseException":
+      throw await de_ResourceInUseExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.kinesisanalytics#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "UnsupportedOperationException":
+    case "com.amazonaws.kinesisanalytics#UnsupportedOperationException":
+      throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_AddApplicationReferenceDataSourceCommandError");
+var de_CreateApplicationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateApplicationCommandError(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_CreateApplicationCommand");
+var de_CreateApplicationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "CodeValidationException":
+    case "com.amazonaws.kinesisanalytics#CodeValidationException":
+      throw await de_CodeValidationExceptionRes(parsedOutput, context);
+    case "ConcurrentModificationException":
+    case "com.amazonaws.kinesisanalytics#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    case "InvalidArgumentException":
+    case "com.amazonaws.kinesisanalytics#InvalidArgumentException":
+      throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.kinesisanalytics#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceInUseException":
+    case "com.amazonaws.kinesisanalytics#ResourceInUseException":
+      throw await de_ResourceInUseExceptionRes(parsedOutput, context);
+    case "TooManyTagsException":
+    case "com.amazonaws.kinesisanalytics#TooManyTagsException":
+      throw await de_TooManyTagsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateApplicationCommandError");
+var de_DeleteApplicationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteApplicationCommandError(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_DeleteApplicationCommand");
+var de_DeleteApplicationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentModificationException":
+    case "com.amazonaws.kinesisanalytics#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    case "ResourceInUseException":
+    case "com.amazonaws.kinesisanalytics#ResourceInUseException":
+      throw await de_ResourceInUseExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.kinesisanalytics#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "UnsupportedOperationException":
+    case "com.amazonaws.kinesisanalytics#UnsupportedOperationException":
+      throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteApplicationCommandError");
+var de_DeleteApplicationCloudWatchLoggingOptionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteApplicationCloudWatchLoggingOptionCommandError(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_DeleteApplicationCloudWatchLoggingOptionCommand");
+var de_DeleteApplicationCloudWatchLoggingOptionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentModificationException":
+    case "com.amazonaws.kinesisanalytics#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    case "InvalidArgumentException":
+    case "com.amazonaws.kinesisanalytics#InvalidArgumentException":
+      throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+    case "ResourceInUseException":
+    case "com.amazonaws.kinesisanalytics#ResourceInUseException":
+      throw await de_ResourceInUseExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.kinesisanalytics#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "UnsupportedOperationException":
+    case "com.amazonaws.kinesisanalytics#UnsupportedOperationException":
+      throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteApplicationCloudWatchLoggingOptionCommandError");
+var de_DeleteApplicationInputProcessingConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteApplicationInputProcessingConfigurationCommandError(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_DeleteApplicationInputProcessingConfigurationCommand");
+var de_DeleteApplicationInputProcessingConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentModificationException":
+    case "com.amazonaws.kinesisanalytics#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    case "InvalidArgumentException":
+    case "com.amazonaws.kinesisanalytics#InvalidArgumentException":
+      throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+    case "ResourceInUseException":
+    case "com.amazonaws.kinesisanalytics#ResourceInUseException":
+      throw await de_ResourceInUseExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.kinesisanalytics#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "UnsupportedOperationException":
+    case "com.amazonaws.kinesisanalytics#UnsupportedOperationException":
+      throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteApplicationInputProcessingConfigurationCommandError");
+var de_DeleteApplicationOutputCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteApplicationOutputCommandError(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_DeleteApplicationOutputCommand");
+var de_DeleteApplicationOutputCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentModificationException":
+    case "com.amazonaws.kinesisanalytics#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    case "InvalidArgumentException":
+    case "com.amazonaws.kinesisanalytics#InvalidArgumentException":
+      throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+    case "ResourceInUseException":
+    case "com.amazonaws.kinesisanalytics#ResourceInUseException":
+      throw await de_ResourceInUseExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.kinesisanalytics#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "UnsupportedOperationException":
+    case "com.amazonaws.kinesisanalytics#UnsupportedOperationException":
+      throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteApplicationOutputCommandError");
+var de_DeleteApplicationReferenceDataSourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteApplicationReferenceDataSourceCommandError(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_DeleteApplicationReferenceDataSourceCommand");
+var de_DeleteApplicationReferenceDataSourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentModificationException":
+    case "com.amazonaws.kinesisanalytics#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    case "InvalidArgumentException":
+    case "com.amazonaws.kinesisanalytics#InvalidArgumentException":
+      throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+    case "ResourceInUseException":
+    case "com.amazonaws.kinesisanalytics#ResourceInUseException":
+      throw await de_ResourceInUseExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.kinesisanalytics#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "UnsupportedOperationException":
+    case "com.amazonaws.kinesisanalytics#UnsupportedOperationException":
+      throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteApplicationReferenceDataSourceCommandError");
+var de_DescribeApplicationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeApplicationCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeApplicationResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeApplicationCommand");
+var de_DescribeApplicationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ResourceNotFoundException":
+    case "com.amazonaws.kinesisanalytics#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "UnsupportedOperationException":
+    case "com.amazonaws.kinesisanalytics#UnsupportedOperationException":
+      throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeApplicationCommandError");
+var de_DiscoverInputSchemaCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DiscoverInputSchemaCommandError(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_DiscoverInputSchemaCommand");
+var de_DiscoverInputSchemaCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidArgumentException":
+    case "com.amazonaws.kinesisanalytics#InvalidArgumentException":
+      throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+    case "ResourceProvisionedThroughputExceededException":
+    case "com.amazonaws.kinesisanalytics#ResourceProvisionedThroughputExceededException":
+      throw await de_ResourceProvisionedThroughputExceededExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.kinesisanalytics#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "UnableToDetectSchemaException":
+    case "com.amazonaws.kinesisanalytics#UnableToDetectSchemaException":
+      throw await de_UnableToDetectSchemaExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DiscoverInputSchemaCommandError");
+var de_ListApplicationsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListApplicationsCommandError(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_ListApplicationsCommand");
+var de_ListApplicationsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  const parsedBody = parsedOutput.body;
+  return throwDefaultError({
+    output,
+    parsedBody,
+    errorCode
+  });
+}, "de_ListApplicationsCommandError");
+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 "ConcurrentModificationException":
+    case "com.amazonaws.kinesisanalytics#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    case "InvalidArgumentException":
+    case "com.amazonaws.kinesisanalytics#InvalidArgumentException":
+      throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.kinesisanalytics#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListTagsForResourceCommandError");
+var de_StartApplicationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_StartApplicationCommandError(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_StartApplicationCommand");
+var de_StartApplicationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidApplicationConfigurationException":
+    case "com.amazonaws.kinesisanalytics#InvalidApplicationConfigurationException":
+      throw await de_InvalidApplicationConfigurationExceptionRes(parsedOutput, context);
+    case "InvalidArgumentException":
+    case "com.amazonaws.kinesisanalytics#InvalidArgumentException":
+      throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+    case "ResourceInUseException":
+    case "com.amazonaws.kinesisanalytics#ResourceInUseException":
+      throw await de_ResourceInUseExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.kinesisanalytics#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "UnsupportedOperationException":
+    case "com.amazonaws.kinesisanalytics#UnsupportedOperationException":
+      throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_StartApplicationCommandError");
+var de_StopApplicationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_StopApplicationCommandError(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_StopApplicationCommand");
+var de_StopApplicationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ResourceInUseException":
+    case "com.amazonaws.kinesisanalytics#ResourceInUseException":
+      throw await de_ResourceInUseExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.kinesisanalytics#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "UnsupportedOperationException":
+    case "com.amazonaws.kinesisanalytics#UnsupportedOperationException":
+      throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_StopApplicationCommandError");
+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 "ConcurrentModificationException":
+    case "com.amazonaws.kinesisanalytics#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    case "InvalidArgumentException":
+    case "com.amazonaws.kinesisanalytics#InvalidArgumentException":
+      throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+    case "ResourceInUseException":
+    case "com.amazonaws.kinesisanalytics#ResourceInUseException":
+      throw await de_ResourceInUseExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.kinesisanalytics#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "TooManyTagsException":
+    case "com.amazonaws.kinesisanalytics#TooManyTagsException":
+      throw await de_TooManyTagsExceptionRes(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 "ConcurrentModificationException":
+    case "com.amazonaws.kinesisanalytics#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    case "InvalidArgumentException":
+    case "com.amazonaws.kinesisanalytics#InvalidArgumentException":
+      throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+    case "ResourceInUseException":
+    case "com.amazonaws.kinesisanalytics#ResourceInUseException":
+      throw await de_ResourceInUseExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.kinesisanalytics#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "TooManyTagsException":
+    case "com.amazonaws.kinesisanalytics#TooManyTagsException":
+      throw await de_TooManyTagsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UntagResourceCommandError");
+var de_UpdateApplicationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateApplicationCommandError(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_UpdateApplicationCommand");
+var de_UpdateApplicationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "CodeValidationException":
+    case "com.amazonaws.kinesisanalytics#CodeValidationException":
+      throw await de_CodeValidationExceptionRes(parsedOutput, context);
+    case "ConcurrentModificationException":
+    case "com.amazonaws.kinesisanalytics#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    case "InvalidArgumentException":
+    case "com.amazonaws.kinesisanalytics#InvalidArgumentException":
+      throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
+    case "ResourceInUseException":
+    case "com.amazonaws.kinesisanalytics#ResourceInUseException":
+      throw await de_ResourceInUseExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.kinesisanalytics#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "UnsupportedOperationException":
+    case "com.amazonaws.kinesisanalytics#UnsupportedOperationException":
+      throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateApplicationCommandError");
+var de_CodeValidationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new CodeValidationException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_CodeValidationExceptionRes");
+var de_ConcurrentModificationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ConcurrentModificationException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ConcurrentModificationExceptionRes");
+var de_InvalidApplicationConfigurationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidApplicationConfigurationException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidApplicationConfigurationExceptionRes");
+var de_InvalidArgumentExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidArgumentException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidArgumentExceptionRes");
+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_ResourceInUseExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ResourceInUseException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ResourceInUseExceptionRes");
+var de_ResourceNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ResourceNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ResourceNotFoundExceptionRes");
+var de_ResourceProvisionedThroughputExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ResourceProvisionedThroughputExceededException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ResourceProvisionedThroughputExceededExceptionRes");
+var de_ServiceUnavailableExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ServiceUnavailableException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ServiceUnavailableExceptionRes");
+var de_TooManyTagsExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new TooManyTagsException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_TooManyTagsExceptionRes");
+var de_UnableToDetectSchemaExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new UnableToDetectSchemaException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_UnableToDetectSchemaExceptionRes");
+var de_UnsupportedOperationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new UnsupportedOperationException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_UnsupportedOperationExceptionRes");
+var se_DeleteApplicationRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    ApplicationName: [],
+    CreateTimestamp: (_) => Math.round(_.getTime() / 1e3)
+  });
+}, "se_DeleteApplicationRequest");
+var de_ApplicationDetail = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    ApplicationARN: import_smithy_client.expectString,
+    ApplicationCode: import_smithy_client.expectString,
+    ApplicationDescription: import_smithy_client.expectString,
+    ApplicationName: import_smithy_client.expectString,
+    ApplicationStatus: import_smithy_client.expectString,
+    ApplicationVersionId: import_smithy_client.expectLong,
+    CloudWatchLoggingOptionDescriptions: import_smithy_client._json,
+    CreateTimestamp: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    InputDescriptions: import_smithy_client._json,
+    LastUpdateTimestamp: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    OutputDescriptions: import_smithy_client._json,
+    ReferenceDataSourceDescriptions: import_smithy_client._json
+  });
+}, "de_ApplicationDetail");
+var de_DescribeApplicationResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    ApplicationDetail: (_) => de_ApplicationDetail(_, context)
+  });
+}, "de_DescribeApplicationResponse");
+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)(KinesisAnalyticsServiceException);
+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": `KinesisAnalytics_20150814.${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/AddApplicationCloudWatchLoggingOptionCommand.ts
+var _AddApplicationCloudWatchLoggingOptionCommand = class _AddApplicationCloudWatchLoggingOptionCommand 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("KinesisAnalytics_20150814", "AddApplicationCloudWatchLoggingOption", {}).n("KinesisAnalyticsClient", "AddApplicationCloudWatchLoggingOptionCommand").f(void 0, void 0).ser(se_AddApplicationCloudWatchLoggingOptionCommand).de(de_AddApplicationCloudWatchLoggingOptionCommand).build() {
+};
+__name(_AddApplicationCloudWatchLoggingOptionCommand, "AddApplicationCloudWatchLoggingOptionCommand");
+var AddApplicationCloudWatchLoggingOptionCommand = _AddApplicationCloudWatchLoggingOptionCommand;
+
+// src/commands/AddApplicationInputCommand.ts
+
+
+
+
+var _AddApplicationInputCommand = class _AddApplicationInputCommand 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("KinesisAnalytics_20150814", "AddApplicationInput", {}).n("KinesisAnalyticsClient", "AddApplicationInputCommand").f(void 0, void 0).ser(se_AddApplicationInputCommand).de(de_AddApplicationInputCommand).build() {
+};
+__name(_AddApplicationInputCommand, "AddApplicationInputCommand");
+var AddApplicationInputCommand = _AddApplicationInputCommand;
+
+// src/commands/AddApplicationInputProcessingConfigurationCommand.ts
+
+
+
+
+var _AddApplicationInputProcessingConfigurationCommand = class _AddApplicationInputProcessingConfigurationCommand 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("KinesisAnalytics_20150814", "AddApplicationInputProcessingConfiguration", {}).n("KinesisAnalyticsClient", "AddApplicationInputProcessingConfigurationCommand").f(void 0, void 0).ser(se_AddApplicationInputProcessingConfigurationCommand).de(de_AddApplicationInputProcessingConfigurationCommand).build() {
+};
+__name(_AddApplicationInputProcessingConfigurationCommand, "AddApplicationInputProcessingConfigurationCommand");
+var AddApplicationInputProcessingConfigurationCommand = _AddApplicationInputProcessingConfigurationCommand;
+
+// src/commands/AddApplicationOutputCommand.ts
+
+
+
+
+var _AddApplicationOutputCommand = class _AddApplicationOutputCommand 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("KinesisAnalytics_20150814", "AddApplicationOutput", {}).n("KinesisAnalyticsClient", "AddApplicationOutputCommand").f(void 0, void 0).ser(se_AddApplicationOutputCommand).de(de_AddApplicationOutputCommand).build() {
+};
+__name(_AddApplicationOutputCommand, "AddApplicationOutputCommand");
+var AddApplicationOutputCommand = _AddApplicationOutputCommand;
+
+// src/commands/AddApplicationReferenceDataSourceCommand.ts
+
+
+
+
+var _AddApplicationReferenceDataSourceCommand = class _AddApplicationReferenceDataSourceCommand 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("KinesisAnalytics_20150814", "AddApplicationReferenceDataSource", {}).n("KinesisAnalyticsClient", "AddApplicationReferenceDataSourceCommand").f(void 0, void 0).ser(se_AddApplicationReferenceDataSourceCommand).de(de_AddApplicationReferenceDataSourceCommand).build() {
+};
+__name(_AddApplicationReferenceDataSourceCommand, "AddApplicationReferenceDataSourceCommand");
+var AddApplicationReferenceDataSourceCommand = _AddApplicationReferenceDataSourceCommand;
+
+// src/commands/CreateApplicationCommand.ts
+
+
+
+
+var _CreateApplicationCommand = class _CreateApplicationCommand 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("KinesisAnalytics_20150814", "CreateApplication", {}).n("KinesisAnalyticsClient", "CreateApplicationCommand").f(void 0, void 0).ser(se_CreateApplicationCommand).de(de_CreateApplicationCommand).build() {
+};
+__name(_CreateApplicationCommand, "CreateApplicationCommand");
+var CreateApplicationCommand = _CreateApplicationCommand;
+
+// src/commands/DeleteApplicationCloudWatchLoggingOptionCommand.ts
+
+
+
+
+var _DeleteApplicationCloudWatchLoggingOptionCommand = class _DeleteApplicationCloudWatchLoggingOptionCommand 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("KinesisAnalytics_20150814", "DeleteApplicationCloudWatchLoggingOption", {}).n("KinesisAnalyticsClient", "DeleteApplicationCloudWatchLoggingOptionCommand").f(void 0, void 0).ser(se_DeleteApplicationCloudWatchLoggingOptionCommand).de(de_DeleteApplicationCloudWatchLoggingOptionCommand).build() {
+};
+__name(_DeleteApplicationCloudWatchLoggingOptionCommand, "DeleteApplicationCloudWatchLoggingOptionCommand");
+var DeleteApplicationCloudWatchLoggingOptionCommand = _DeleteApplicationCloudWatchLoggingOptionCommand;
+
+// src/commands/DeleteApplicationCommand.ts
+
+
+
+
+var _DeleteApplicationCommand = class _DeleteApplicationCommand 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("KinesisAnalytics_20150814", "DeleteApplication", {}).n("KinesisAnalyticsClient", "DeleteApplicationCommand").f(void 0, void 0).ser(se_DeleteApplicationCommand).de(de_DeleteApplicationCommand).build() {
+};
+__name(_DeleteApplicationCommand, "DeleteApplicationCommand");
+var DeleteApplicationCommand = _DeleteApplicationCommand;
+
+// src/commands/DeleteApplicationInputProcessingConfigurationCommand.ts
+
+
+
+
+var _DeleteApplicationInputProcessingConfigurationCommand = class _DeleteApplicationInputProcessingConfigurationCommand 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("KinesisAnalytics_20150814", "DeleteApplicationInputProcessingConfiguration", {}).n("KinesisAnalyticsClient", "DeleteApplicationInputProcessingConfigurationCommand").f(void 0, void 0).ser(se_DeleteApplicationInputProcessingConfigurationCommand).de(de_DeleteApplicationInputProcessingConfigurationCommand).build() {
+};
+__name(_DeleteApplicationInputProcessingConfigurationCommand, "DeleteApplicationInputProcessingConfigurationCommand");
+var DeleteApplicationInputProcessingConfigurationCommand = _DeleteApplicationInputProcessingConfigurationCommand;
+
+// src/commands/DeleteApplicationOutputCommand.ts
+
+
+
+
+var _DeleteApplicationOutputCommand = class _DeleteApplicationOutputCommand 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("KinesisAnalytics_20150814", "DeleteApplicationOutput", {}).n("KinesisAnalyticsClient", "DeleteApplicationOutputCommand").f(void 0, void 0).ser(se_DeleteApplicationOutputCommand).de(de_DeleteApplicationOutputCommand).build() {
+};
+__name(_DeleteApplicationOutputCommand, "DeleteApplicationOutputCommand");
+var DeleteApplicationOutputCommand = _DeleteApplicationOutputCommand;
+
+// src/commands/DeleteApplicationReferenceDataSourceCommand.ts
+
+
+
+
+var _DeleteApplicationReferenceDataSourceCommand = class _DeleteApplicationReferenceDataSourceCommand 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("KinesisAnalytics_20150814", "DeleteApplicationReferenceDataSource", {}).n("KinesisAnalyticsClient", "DeleteApplicationReferenceDataSourceCommand").f(void 0, void 0).ser(se_DeleteApplicationReferenceDataSourceCommand).de(de_DeleteApplicationReferenceDataSourceCommand).build() {
+};
+__name(_DeleteApplicationReferenceDataSourceCommand, "DeleteApplicationReferenceDataSourceCommand");
+var DeleteApplicationReferenceDataSourceCommand = _DeleteApplicationReferenceDataSourceCommand;
+
+// src/commands/DescribeApplicationCommand.ts
+
+
+
+
+var _DescribeApplicationCommand = class _DescribeApplicationCommand 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("KinesisAnalytics_20150814", "DescribeApplication", {}).n("KinesisAnalyticsClient", "DescribeApplicationCommand").f(void 0, void 0).ser(se_DescribeApplicationCommand).de(de_DescribeApplicationCommand).build() {
+};
+__name(_DescribeApplicationCommand, "DescribeApplicationCommand");
+var DescribeApplicationCommand = _DescribeApplicationCommand;
+
+// src/commands/DiscoverInputSchemaCommand.ts
+
+
+
+
+var _DiscoverInputSchemaCommand = class _DiscoverInputSchemaCommand 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("KinesisAnalytics_20150814", "DiscoverInputSchema", {}).n("KinesisAnalyticsClient", "DiscoverInputSchemaCommand").f(void 0, void 0).ser(se_DiscoverInputSchemaCommand).de(de_DiscoverInputSchemaCommand).build() {
+};
+__name(_DiscoverInputSchemaCommand, "DiscoverInputSchemaCommand");
+var DiscoverInputSchemaCommand = _DiscoverInputSchemaCommand;
+
+// src/commands/ListApplicationsCommand.ts
+
+
+
+
+var _ListApplicationsCommand = class _ListApplicationsCommand 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("KinesisAnalytics_20150814", "ListApplications", {}).n("KinesisAnalyticsClient", "ListApplicationsCommand").f(void 0, void 0).ser(se_ListApplicationsCommand).de(de_ListApplicationsCommand).build() {
+};
+__name(_ListApplicationsCommand, "ListApplicationsCommand");
+var ListApplicationsCommand = _ListApplicationsCommand;
+
+// 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("KinesisAnalytics_20150814", "ListTagsForResource", {}).n("KinesisAnalyticsClient", "ListTagsForResourceCommand").f(void 0, void 0).ser(se_ListTagsForResourceCommand).de(de_ListTagsForResourceCommand).build() {
+};
+__name(_ListTagsForResourceCommand, "ListTagsForResourceCommand");
+var ListTagsForResourceCommand = _ListTagsForResourceCommand;
+
+// src/commands/StartApplicationCommand.ts
+
+
+
+
+var _StartApplicationCommand = class _StartApplicationCommand 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("KinesisAnalytics_20150814", "StartApplication", {}).n("KinesisAnalyticsClient", "StartApplicationCommand").f(void 0, void 0).ser(se_StartApplicationCommand).de(de_StartApplicationCommand).build() {
+};
+__name(_StartApplicationCommand, "StartApplicationCommand");
+var StartApplicationCommand = _StartApplicationCommand;
+
+// src/commands/StopApplicationCommand.ts
+
+
+
+
+var _StopApplicationCommand = class _StopApplicationCommand 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("KinesisAnalytics_20150814", "StopApplication", {}).n("KinesisAnalyticsClient", "StopApplicationCommand").f(void 0, void 0).ser(se_StopApplicationCommand).de(de_StopApplicationCommand).build() {
+};
+__name(_StopApplicationCommand, "StopApplicationCommand");
+var StopApplicationCommand = _StopApplicationCommand;
+
+// 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("KinesisAnalytics_20150814", "TagResource", {}).n("KinesisAnalyticsClient", "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("KinesisAnalytics_20150814", "UntagResource", {}).n("KinesisAnalyticsClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
+};
+__name(_UntagResourceCommand, "UntagResourceCommand");
+var UntagResourceCommand = _UntagResourceCommand;
+
+// src/commands/UpdateApplicationCommand.ts
+
+
+
+
+var _UpdateApplicationCommand = class _UpdateApplicationCommand 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("KinesisAnalytics_20150814", "UpdateApplication", {}).n("KinesisAnalyticsClient", "UpdateApplicationCommand").f(void 0, void 0).ser(se_UpdateApplicationCommand).de(de_UpdateApplicationCommand).build() {
+};
+__name(_UpdateApplicationCommand, "UpdateApplicationCommand");
+var UpdateApplicationCommand = _UpdateApplicationCommand;
+
+// src/KinesisAnalytics.ts
+var commands = {
+  AddApplicationCloudWatchLoggingOptionCommand,
+  AddApplicationInputCommand,
+  AddApplicationInputProcessingConfigurationCommand,
+  AddApplicationOutputCommand,
+  AddApplicationReferenceDataSourceCommand,
+  CreateApplicationCommand,
+  DeleteApplicationCommand,
+  DeleteApplicationCloudWatchLoggingOptionCommand,
+  DeleteApplicationInputProcessingConfigurationCommand,
+  DeleteApplicationOutputCommand,
+  DeleteApplicationReferenceDataSourceCommand,
+  DescribeApplicationCommand,
+  DiscoverInputSchemaCommand,
+  ListApplicationsCommand,
+  ListTagsForResourceCommand,
+  StartApplicationCommand,
+  StopApplicationCommand,
+  TagResourceCommand,
+  UntagResourceCommand,
+  UpdateApplicationCommand
+};
+var _KinesisAnalytics = class _KinesisAnalytics extends KinesisAnalyticsClient {
+};
+__name(_KinesisAnalytics, "KinesisAnalytics");
+var KinesisAnalytics = _KinesisAnalytics;
+(0, import_smithy_client.createAggregatedClient)(commands, KinesisAnalytics);
+
+// 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 = {
+  AddApplicationCloudWatchLoggingOptionCommand,
+  AddApplicationInputCommand,
+  AddApplicationInputProcessingConfigurationCommand,
+  AddApplicationOutputCommand,
+  AddApplicationReferenceDataSourceCommand,
+  ApplicationStatus,
+  CodeValidationException,
+  ConcurrentModificationException,
+  CreateApplicationCommand,
+  DeleteApplicationCloudWatchLoggingOptionCommand,
+  DeleteApplicationCommand,
+  DeleteApplicationInputProcessingConfigurationCommand,
+  DeleteApplicationOutputCommand,
+  DeleteApplicationReferenceDataSourceCommand,
+  DescribeApplicationCommand,
+  DiscoverInputSchemaCommand,
+  InputStartingPosition,
+  InvalidApplicationConfigurationException,
+  InvalidArgumentException,
+  KinesisAnalytics,
+  KinesisAnalyticsClient,
+  KinesisAnalyticsServiceException,
+  LimitExceededException,
+  ListApplicationsCommand,
+  ListTagsForResourceCommand,
+  RecordFormatType,
+  ResourceInUseException,
+  ResourceNotFoundException,
+  ResourceProvisionedThroughputExceededException,
+  ServiceUnavailableException,
+  StartApplicationCommand,
+  StopApplicationCommand,
+  TagResourceCommand,
+  TooManyTagsException,
+  UnableToDetectSchemaException,
+  UnsupportedOperationException,
+  UntagResourceCommand,
+  UpdateApplicationCommand,
+  __Client
+});