@aws-sdk/client-data-pipeline 3.489.0 → 3.495.0

package/dist-cjs/index.js

@@ -1,12 +1,1666 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DataPipelineServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./DataPipelineClient"), exports);
-tslib_1.__exportStar(require("./DataPipeline"), exports);
-tslib_1.__exportStar(require("./commands"), exports);
-tslib_1.__exportStar(require("./pagination"), exports);
-tslib_1.__exportStar(require("./models"), exports);
-require("@aws-sdk/util-endpoints");
-var DataPipelineServiceException_1 = require("./models/DataPipelineServiceException");
-Object.defineProperty(exports, "DataPipelineServiceException", { enumerable: true, get: function () { return DataPipelineServiceException_1.DataPipelineServiceException; } });
+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, {
+  ActivatePipelineCommand: () => ActivatePipelineCommand,
+  AddTagsCommand: () => AddTagsCommand,
+  CreatePipelineCommand: () => CreatePipelineCommand,
+  DataPipeline: () => DataPipeline,
+  DataPipelineClient: () => DataPipelineClient,
+  DataPipelineServiceException: () => DataPipelineServiceException,
+  DeactivatePipelineCommand: () => DeactivatePipelineCommand,
+  DeletePipelineCommand: () => DeletePipelineCommand,
+  DescribeObjectsCommand: () => DescribeObjectsCommand,
+  DescribePipelinesCommand: () => DescribePipelinesCommand,
+  EvaluateExpressionCommand: () => EvaluateExpressionCommand,
+  GetPipelineDefinitionCommand: () => GetPipelineDefinitionCommand,
+  InternalServiceError: () => InternalServiceError,
+  InvalidRequestException: () => InvalidRequestException,
+  ListPipelinesCommand: () => ListPipelinesCommand,
+  OperatorType: () => OperatorType,
+  PipelineDeletedException: () => PipelineDeletedException,
+  PipelineNotFoundException: () => PipelineNotFoundException,
+  PollForTaskCommand: () => PollForTaskCommand,
+  PutPipelineDefinitionCommand: () => PutPipelineDefinitionCommand,
+  QueryObjectsCommand: () => QueryObjectsCommand,
+  RemoveTagsCommand: () => RemoveTagsCommand,
+  ReportTaskProgressCommand: () => ReportTaskProgressCommand,
+  ReportTaskRunnerHeartbeatCommand: () => ReportTaskRunnerHeartbeatCommand,
+  SetStatusCommand: () => SetStatusCommand,
+  SetTaskStatusCommand: () => SetTaskStatusCommand,
+  TaskNotFoundException: () => TaskNotFoundException,
+  TaskStatus: () => TaskStatus,
+  ValidatePipelineDefinitionCommand: () => ValidatePipelineDefinitionCommand,
+  __Client: () => import_smithy_client.Client,
+  paginateDescribeObjects: () => paginateDescribeObjects,
+  paginateListPipelines: () => paginateListPipelines,
+  paginateQueryObjects: () => paginateQueryObjects
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/DataPipelineClient.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: "datapipeline"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/DataPipelineClient.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/DataPipelineClient.ts
+var _DataPipelineClient = class _DataPipelineClient 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(_DataPipelineClient, "DataPipelineClient");
+var DataPipelineClient = _DataPipelineClient;
+
+// src/DataPipeline.ts
+
+
+// src/commands/ActivatePipelineCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/protocols/Aws_json1_1.ts
+
+
+
+// src/models/DataPipelineServiceException.ts
+
+var _DataPipelineServiceException = class _DataPipelineServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _DataPipelineServiceException.prototype);
+  }
+};
+__name(_DataPipelineServiceException, "DataPipelineServiceException");
+var DataPipelineServiceException = _DataPipelineServiceException;
+
+// src/models/models_0.ts
+var _InternalServiceError = class _InternalServiceError extends DataPipelineServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InternalServiceError",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "InternalServiceError";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _InternalServiceError.prototype);
+  }
+};
+__name(_InternalServiceError, "InternalServiceError");
+var InternalServiceError = _InternalServiceError;
+var _InvalidRequestException = class _InvalidRequestException extends DataPipelineServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidRequestException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidRequestException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidRequestException.prototype);
+  }
+};
+__name(_InvalidRequestException, "InvalidRequestException");
+var InvalidRequestException = _InvalidRequestException;
+var _PipelineDeletedException = class _PipelineDeletedException extends DataPipelineServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "PipelineDeletedException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "PipelineDeletedException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _PipelineDeletedException.prototype);
+  }
+};
+__name(_PipelineDeletedException, "PipelineDeletedException");
+var PipelineDeletedException = _PipelineDeletedException;
+var _PipelineNotFoundException = class _PipelineNotFoundException extends DataPipelineServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "PipelineNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "PipelineNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _PipelineNotFoundException.prototype);
+  }
+};
+__name(_PipelineNotFoundException, "PipelineNotFoundException");
+var PipelineNotFoundException = _PipelineNotFoundException;
+var _TaskNotFoundException = class _TaskNotFoundException extends DataPipelineServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "TaskNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "TaskNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _TaskNotFoundException.prototype);
+  }
+};
+__name(_TaskNotFoundException, "TaskNotFoundException");
+var TaskNotFoundException = _TaskNotFoundException;
+var OperatorType = {
+  Between: "BETWEEN",
+  Equal: "EQ",
+  GreaterThanOrEqual: "GE",
+  LessThanOrEqual: "LE",
+  ReferenceEqual: "REF_EQ"
+};
+var TaskStatus = {
+  FAILED: "FAILED",
+  FALSE: "FALSE",
+  FINISHED: "FINISHED"
+};
+
+// src/protocols/Aws_json1_1.ts
+var se_ActivatePipelineCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ActivatePipeline");
+  let body;
+  body = JSON.stringify(se_ActivatePipelineInput(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ActivatePipelineCommand");
+var se_AddTagsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("AddTags");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_AddTagsCommand");
+var se_CreatePipelineCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreatePipeline");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreatePipelineCommand");
+var se_DeactivatePipelineCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeactivatePipeline");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeactivatePipelineCommand");
+var se_DeletePipelineCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeletePipeline");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeletePipelineCommand");
+var se_DescribeObjectsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeObjects");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeObjectsCommand");
+var se_DescribePipelinesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribePipelines");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribePipelinesCommand");
+var se_EvaluateExpressionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("EvaluateExpression");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_EvaluateExpressionCommand");
+var se_GetPipelineDefinitionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetPipelineDefinition");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetPipelineDefinitionCommand");
+var se_ListPipelinesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListPipelines");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListPipelinesCommand");
+var se_PollForTaskCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("PollForTask");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_PollForTaskCommand");
+var se_PutPipelineDefinitionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("PutPipelineDefinition");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_PutPipelineDefinitionCommand");
+var se_QueryObjectsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("QueryObjects");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_QueryObjectsCommand");
+var se_RemoveTagsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("RemoveTags");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_RemoveTagsCommand");
+var se_ReportTaskProgressCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ReportTaskProgress");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ReportTaskProgressCommand");
+var se_ReportTaskRunnerHeartbeatCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ReportTaskRunnerHeartbeat");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ReportTaskRunnerHeartbeatCommand");
+var se_SetStatusCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("SetStatus");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_SetStatusCommand");
+var se_SetTaskStatusCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("SetTaskStatus");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_SetTaskStatusCommand");
+var se_ValidatePipelineDefinitionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ValidatePipelineDefinition");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ValidatePipelineDefinitionCommand");
+var de_ActivatePipelineCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ActivatePipelineCommandError(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_ActivatePipelineCommand");
+var de_ActivatePipelineCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceError":
+    case "com.amazonaws.datapipeline#InternalServiceError":
+      throw await de_InternalServiceErrorRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.datapipeline#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "PipelineDeletedException":
+    case "com.amazonaws.datapipeline#PipelineDeletedException":
+      throw await de_PipelineDeletedExceptionRes(parsedOutput, context);
+    case "PipelineNotFoundException":
+    case "com.amazonaws.datapipeline#PipelineNotFoundException":
+      throw await de_PipelineNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ActivatePipelineCommandError");
+var de_AddTagsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_AddTagsCommandError(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_AddTagsCommand");
+var de_AddTagsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceError":
+    case "com.amazonaws.datapipeline#InternalServiceError":
+      throw await de_InternalServiceErrorRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.datapipeline#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "PipelineDeletedException":
+    case "com.amazonaws.datapipeline#PipelineDeletedException":
+      throw await de_PipelineDeletedExceptionRes(parsedOutput, context);
+    case "PipelineNotFoundException":
+    case "com.amazonaws.datapipeline#PipelineNotFoundException":
+      throw await de_PipelineNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_AddTagsCommandError");
+var de_CreatePipelineCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreatePipelineCommandError(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_CreatePipelineCommand");
+var de_CreatePipelineCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceError":
+    case "com.amazonaws.datapipeline#InternalServiceError":
+      throw await de_InternalServiceErrorRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.datapipeline#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreatePipelineCommandError");
+var de_DeactivatePipelineCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeactivatePipelineCommandError(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_DeactivatePipelineCommand");
+var de_DeactivatePipelineCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceError":
+    case "com.amazonaws.datapipeline#InternalServiceError":
+      throw await de_InternalServiceErrorRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.datapipeline#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "PipelineDeletedException":
+    case "com.amazonaws.datapipeline#PipelineDeletedException":
+      throw await de_PipelineDeletedExceptionRes(parsedOutput, context);
+    case "PipelineNotFoundException":
+    case "com.amazonaws.datapipeline#PipelineNotFoundException":
+      throw await de_PipelineNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeactivatePipelineCommandError");
+var de_DeletePipelineCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeletePipelineCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_DeletePipelineCommand");
+var de_DeletePipelineCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceError":
+    case "com.amazonaws.datapipeline#InternalServiceError":
+      throw await de_InternalServiceErrorRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.datapipeline#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "PipelineNotFoundException":
+    case "com.amazonaws.datapipeline#PipelineNotFoundException":
+      throw await de_PipelineNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeletePipelineCommandError");
+var de_DescribeObjectsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeObjectsCommandError(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_DescribeObjectsCommand");
+var de_DescribeObjectsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceError":
+    case "com.amazonaws.datapipeline#InternalServiceError":
+      throw await de_InternalServiceErrorRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.datapipeline#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "PipelineDeletedException":
+    case "com.amazonaws.datapipeline#PipelineDeletedException":
+      throw await de_PipelineDeletedExceptionRes(parsedOutput, context);
+    case "PipelineNotFoundException":
+    case "com.amazonaws.datapipeline#PipelineNotFoundException":
+      throw await de_PipelineNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeObjectsCommandError");
+var de_DescribePipelinesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribePipelinesCommandError(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_DescribePipelinesCommand");
+var de_DescribePipelinesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceError":
+    case "com.amazonaws.datapipeline#InternalServiceError":
+      throw await de_InternalServiceErrorRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.datapipeline#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "PipelineDeletedException":
+    case "com.amazonaws.datapipeline#PipelineDeletedException":
+      throw await de_PipelineDeletedExceptionRes(parsedOutput, context);
+    case "PipelineNotFoundException":
+    case "com.amazonaws.datapipeline#PipelineNotFoundException":
+      throw await de_PipelineNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribePipelinesCommandError");
+var de_EvaluateExpressionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_EvaluateExpressionCommandError(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_EvaluateExpressionCommand");
+var de_EvaluateExpressionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceError":
+    case "com.amazonaws.datapipeline#InternalServiceError":
+      throw await de_InternalServiceErrorRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.datapipeline#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "PipelineDeletedException":
+    case "com.amazonaws.datapipeline#PipelineDeletedException":
+      throw await de_PipelineDeletedExceptionRes(parsedOutput, context);
+    case "PipelineNotFoundException":
+    case "com.amazonaws.datapipeline#PipelineNotFoundException":
+      throw await de_PipelineNotFoundExceptionRes(parsedOutput, context);
+    case "TaskNotFoundException":
+    case "com.amazonaws.datapipeline#TaskNotFoundException":
+      throw await de_TaskNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_EvaluateExpressionCommandError");
+var de_GetPipelineDefinitionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetPipelineDefinitionCommandError(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_GetPipelineDefinitionCommand");
+var de_GetPipelineDefinitionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceError":
+    case "com.amazonaws.datapipeline#InternalServiceError":
+      throw await de_InternalServiceErrorRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.datapipeline#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "PipelineDeletedException":
+    case "com.amazonaws.datapipeline#PipelineDeletedException":
+      throw await de_PipelineDeletedExceptionRes(parsedOutput, context);
+    case "PipelineNotFoundException":
+    case "com.amazonaws.datapipeline#PipelineNotFoundException":
+      throw await de_PipelineNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetPipelineDefinitionCommandError");
+var de_ListPipelinesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListPipelinesCommandError(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_ListPipelinesCommand");
+var de_ListPipelinesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceError":
+    case "com.amazonaws.datapipeline#InternalServiceError":
+      throw await de_InternalServiceErrorRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.datapipeline#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListPipelinesCommandError");
+var de_PollForTaskCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_PollForTaskCommandError(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_PollForTaskCommand");
+var de_PollForTaskCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceError":
+    case "com.amazonaws.datapipeline#InternalServiceError":
+      throw await de_InternalServiceErrorRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.datapipeline#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "TaskNotFoundException":
+    case "com.amazonaws.datapipeline#TaskNotFoundException":
+      throw await de_TaskNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_PollForTaskCommandError");
+var de_PutPipelineDefinitionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_PutPipelineDefinitionCommandError(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_PutPipelineDefinitionCommand");
+var de_PutPipelineDefinitionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceError":
+    case "com.amazonaws.datapipeline#InternalServiceError":
+      throw await de_InternalServiceErrorRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.datapipeline#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "PipelineDeletedException":
+    case "com.amazonaws.datapipeline#PipelineDeletedException":
+      throw await de_PipelineDeletedExceptionRes(parsedOutput, context);
+    case "PipelineNotFoundException":
+    case "com.amazonaws.datapipeline#PipelineNotFoundException":
+      throw await de_PipelineNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_PutPipelineDefinitionCommandError");
+var de_QueryObjectsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_QueryObjectsCommandError(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_QueryObjectsCommand");
+var de_QueryObjectsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceError":
+    case "com.amazonaws.datapipeline#InternalServiceError":
+      throw await de_InternalServiceErrorRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.datapipeline#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "PipelineDeletedException":
+    case "com.amazonaws.datapipeline#PipelineDeletedException":
+      throw await de_PipelineDeletedExceptionRes(parsedOutput, context);
+    case "PipelineNotFoundException":
+    case "com.amazonaws.datapipeline#PipelineNotFoundException":
+      throw await de_PipelineNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_QueryObjectsCommandError");
+var de_RemoveTagsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_RemoveTagsCommandError(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_RemoveTagsCommand");
+var de_RemoveTagsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceError":
+    case "com.amazonaws.datapipeline#InternalServiceError":
+      throw await de_InternalServiceErrorRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.datapipeline#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "PipelineDeletedException":
+    case "com.amazonaws.datapipeline#PipelineDeletedException":
+      throw await de_PipelineDeletedExceptionRes(parsedOutput, context);
+    case "PipelineNotFoundException":
+    case "com.amazonaws.datapipeline#PipelineNotFoundException":
+      throw await de_PipelineNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_RemoveTagsCommandError");
+var de_ReportTaskProgressCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ReportTaskProgressCommandError(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_ReportTaskProgressCommand");
+var de_ReportTaskProgressCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceError":
+    case "com.amazonaws.datapipeline#InternalServiceError":
+      throw await de_InternalServiceErrorRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.datapipeline#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "PipelineDeletedException":
+    case "com.amazonaws.datapipeline#PipelineDeletedException":
+      throw await de_PipelineDeletedExceptionRes(parsedOutput, context);
+    case "PipelineNotFoundException":
+    case "com.amazonaws.datapipeline#PipelineNotFoundException":
+      throw await de_PipelineNotFoundExceptionRes(parsedOutput, context);
+    case "TaskNotFoundException":
+    case "com.amazonaws.datapipeline#TaskNotFoundException":
+      throw await de_TaskNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ReportTaskProgressCommandError");
+var de_ReportTaskRunnerHeartbeatCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ReportTaskRunnerHeartbeatCommandError(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_ReportTaskRunnerHeartbeatCommand");
+var de_ReportTaskRunnerHeartbeatCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceError":
+    case "com.amazonaws.datapipeline#InternalServiceError":
+      throw await de_InternalServiceErrorRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.datapipeline#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ReportTaskRunnerHeartbeatCommandError");
+var de_SetStatusCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_SetStatusCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_SetStatusCommand");
+var de_SetStatusCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceError":
+    case "com.amazonaws.datapipeline#InternalServiceError":
+      throw await de_InternalServiceErrorRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.datapipeline#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "PipelineDeletedException":
+    case "com.amazonaws.datapipeline#PipelineDeletedException":
+      throw await de_PipelineDeletedExceptionRes(parsedOutput, context);
+    case "PipelineNotFoundException":
+    case "com.amazonaws.datapipeline#PipelineNotFoundException":
+      throw await de_PipelineNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_SetStatusCommandError");
+var de_SetTaskStatusCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_SetTaskStatusCommandError(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_SetTaskStatusCommand");
+var de_SetTaskStatusCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceError":
+    case "com.amazonaws.datapipeline#InternalServiceError":
+      throw await de_InternalServiceErrorRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.datapipeline#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "PipelineDeletedException":
+    case "com.amazonaws.datapipeline#PipelineDeletedException":
+      throw await de_PipelineDeletedExceptionRes(parsedOutput, context);
+    case "PipelineNotFoundException":
+    case "com.amazonaws.datapipeline#PipelineNotFoundException":
+      throw await de_PipelineNotFoundExceptionRes(parsedOutput, context);
+    case "TaskNotFoundException":
+    case "com.amazonaws.datapipeline#TaskNotFoundException":
+      throw await de_TaskNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_SetTaskStatusCommandError");
+var de_ValidatePipelineDefinitionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ValidatePipelineDefinitionCommandError(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_ValidatePipelineDefinitionCommand");
+var de_ValidatePipelineDefinitionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServiceError":
+    case "com.amazonaws.datapipeline#InternalServiceError":
+      throw await de_InternalServiceErrorRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.datapipeline#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "PipelineDeletedException":
+    case "com.amazonaws.datapipeline#PipelineDeletedException":
+      throw await de_PipelineDeletedExceptionRes(parsedOutput, context);
+    case "PipelineNotFoundException":
+    case "com.amazonaws.datapipeline#PipelineNotFoundException":
+      throw await de_PipelineNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ValidatePipelineDefinitionCommandError");
+var de_InternalServiceErrorRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InternalServiceError({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InternalServiceErrorRes");
+var de_InvalidRequestExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidRequestException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidRequestExceptionRes");
+var de_PipelineDeletedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new PipelineDeletedException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_PipelineDeletedExceptionRes");
+var de_PipelineNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new PipelineNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_PipelineNotFoundExceptionRes");
+var de_TaskNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new TaskNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_TaskNotFoundExceptionRes");
+var se_ActivatePipelineInput = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    parameterValues: import_smithy_client._json,
+    pipelineId: [],
+    startTimestamp: (_) => Math.round(_.getTime() / 1e3)
+  });
+}, "se_ActivatePipelineInput");
+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)(DataPipelineServiceException);
+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": `DataPipeline.${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/ActivatePipelineCommand.ts
+var _ActivatePipelineCommand = class _ActivatePipelineCommand 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("DataPipeline", "ActivatePipeline", {}).n("DataPipelineClient", "ActivatePipelineCommand").f(void 0, void 0).ser(se_ActivatePipelineCommand).de(de_ActivatePipelineCommand).build() {
+};
+__name(_ActivatePipelineCommand, "ActivatePipelineCommand");
+var ActivatePipelineCommand = _ActivatePipelineCommand;
+
+// src/commands/AddTagsCommand.ts
+
+
+
+
+var _AddTagsCommand = class _AddTagsCommand 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("DataPipeline", "AddTags", {}).n("DataPipelineClient", "AddTagsCommand").f(void 0, void 0).ser(se_AddTagsCommand).de(de_AddTagsCommand).build() {
+};
+__name(_AddTagsCommand, "AddTagsCommand");
+var AddTagsCommand = _AddTagsCommand;
+
+// src/commands/CreatePipelineCommand.ts
+
+
+
+
+var _CreatePipelineCommand = class _CreatePipelineCommand 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("DataPipeline", "CreatePipeline", {}).n("DataPipelineClient", "CreatePipelineCommand").f(void 0, void 0).ser(se_CreatePipelineCommand).de(de_CreatePipelineCommand).build() {
+};
+__name(_CreatePipelineCommand, "CreatePipelineCommand");
+var CreatePipelineCommand = _CreatePipelineCommand;
+
+// src/commands/DeactivatePipelineCommand.ts
+
+
+
+
+var _DeactivatePipelineCommand = class _DeactivatePipelineCommand 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("DataPipeline", "DeactivatePipeline", {}).n("DataPipelineClient", "DeactivatePipelineCommand").f(void 0, void 0).ser(se_DeactivatePipelineCommand).de(de_DeactivatePipelineCommand).build() {
+};
+__name(_DeactivatePipelineCommand, "DeactivatePipelineCommand");
+var DeactivatePipelineCommand = _DeactivatePipelineCommand;
+
+// src/commands/DeletePipelineCommand.ts
+
+
+
+
+var _DeletePipelineCommand = class _DeletePipelineCommand 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("DataPipeline", "DeletePipeline", {}).n("DataPipelineClient", "DeletePipelineCommand").f(void 0, void 0).ser(se_DeletePipelineCommand).de(de_DeletePipelineCommand).build() {
+};
+__name(_DeletePipelineCommand, "DeletePipelineCommand");
+var DeletePipelineCommand = _DeletePipelineCommand;
+
+// src/commands/DescribeObjectsCommand.ts
+
+
+
+
+var _DescribeObjectsCommand = class _DescribeObjectsCommand 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("DataPipeline", "DescribeObjects", {}).n("DataPipelineClient", "DescribeObjectsCommand").f(void 0, void 0).ser(se_DescribeObjectsCommand).de(de_DescribeObjectsCommand).build() {
+};
+__name(_DescribeObjectsCommand, "DescribeObjectsCommand");
+var DescribeObjectsCommand = _DescribeObjectsCommand;
+
+// src/commands/DescribePipelinesCommand.ts
+
+
+
+
+var _DescribePipelinesCommand = class _DescribePipelinesCommand 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("DataPipeline", "DescribePipelines", {}).n("DataPipelineClient", "DescribePipelinesCommand").f(void 0, void 0).ser(se_DescribePipelinesCommand).de(de_DescribePipelinesCommand).build() {
+};
+__name(_DescribePipelinesCommand, "DescribePipelinesCommand");
+var DescribePipelinesCommand = _DescribePipelinesCommand;
+
+// src/commands/EvaluateExpressionCommand.ts
+
+
+
+
+var _EvaluateExpressionCommand = class _EvaluateExpressionCommand 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("DataPipeline", "EvaluateExpression", {}).n("DataPipelineClient", "EvaluateExpressionCommand").f(void 0, void 0).ser(se_EvaluateExpressionCommand).de(de_EvaluateExpressionCommand).build() {
+};
+__name(_EvaluateExpressionCommand, "EvaluateExpressionCommand");
+var EvaluateExpressionCommand = _EvaluateExpressionCommand;
+
+// src/commands/GetPipelineDefinitionCommand.ts
+
+
+
+
+var _GetPipelineDefinitionCommand = class _GetPipelineDefinitionCommand 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("DataPipeline", "GetPipelineDefinition", {}).n("DataPipelineClient", "GetPipelineDefinitionCommand").f(void 0, void 0).ser(se_GetPipelineDefinitionCommand).de(de_GetPipelineDefinitionCommand).build() {
+};
+__name(_GetPipelineDefinitionCommand, "GetPipelineDefinitionCommand");
+var GetPipelineDefinitionCommand = _GetPipelineDefinitionCommand;
+
+// src/commands/ListPipelinesCommand.ts
+
+
+
+
+var _ListPipelinesCommand = class _ListPipelinesCommand 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("DataPipeline", "ListPipelines", {}).n("DataPipelineClient", "ListPipelinesCommand").f(void 0, void 0).ser(se_ListPipelinesCommand).de(de_ListPipelinesCommand).build() {
+};
+__name(_ListPipelinesCommand, "ListPipelinesCommand");
+var ListPipelinesCommand = _ListPipelinesCommand;
+
+// src/commands/PollForTaskCommand.ts
+
+
+
+
+var _PollForTaskCommand = class _PollForTaskCommand 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("DataPipeline", "PollForTask", {}).n("DataPipelineClient", "PollForTaskCommand").f(void 0, void 0).ser(se_PollForTaskCommand).de(de_PollForTaskCommand).build() {
+};
+__name(_PollForTaskCommand, "PollForTaskCommand");
+var PollForTaskCommand = _PollForTaskCommand;
+
+// src/commands/PutPipelineDefinitionCommand.ts
+
+
+
+
+var _PutPipelineDefinitionCommand = class _PutPipelineDefinitionCommand 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("DataPipeline", "PutPipelineDefinition", {}).n("DataPipelineClient", "PutPipelineDefinitionCommand").f(void 0, void 0).ser(se_PutPipelineDefinitionCommand).de(de_PutPipelineDefinitionCommand).build() {
+};
+__name(_PutPipelineDefinitionCommand, "PutPipelineDefinitionCommand");
+var PutPipelineDefinitionCommand = _PutPipelineDefinitionCommand;
+
+// src/commands/QueryObjectsCommand.ts
+
+
+
+
+var _QueryObjectsCommand = class _QueryObjectsCommand 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("DataPipeline", "QueryObjects", {}).n("DataPipelineClient", "QueryObjectsCommand").f(void 0, void 0).ser(se_QueryObjectsCommand).de(de_QueryObjectsCommand).build() {
+};
+__name(_QueryObjectsCommand, "QueryObjectsCommand");
+var QueryObjectsCommand = _QueryObjectsCommand;
+
+// src/commands/RemoveTagsCommand.ts
+
+
+
+
+var _RemoveTagsCommand = class _RemoveTagsCommand 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("DataPipeline", "RemoveTags", {}).n("DataPipelineClient", "RemoveTagsCommand").f(void 0, void 0).ser(se_RemoveTagsCommand).de(de_RemoveTagsCommand).build() {
+};
+__name(_RemoveTagsCommand, "RemoveTagsCommand");
+var RemoveTagsCommand = _RemoveTagsCommand;
+
+// src/commands/ReportTaskProgressCommand.ts
+
+
+
+
+var _ReportTaskProgressCommand = class _ReportTaskProgressCommand 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("DataPipeline", "ReportTaskProgress", {}).n("DataPipelineClient", "ReportTaskProgressCommand").f(void 0, void 0).ser(se_ReportTaskProgressCommand).de(de_ReportTaskProgressCommand).build() {
+};
+__name(_ReportTaskProgressCommand, "ReportTaskProgressCommand");
+var ReportTaskProgressCommand = _ReportTaskProgressCommand;
+
+// src/commands/ReportTaskRunnerHeartbeatCommand.ts
+
+
+
+
+var _ReportTaskRunnerHeartbeatCommand = class _ReportTaskRunnerHeartbeatCommand 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("DataPipeline", "ReportTaskRunnerHeartbeat", {}).n("DataPipelineClient", "ReportTaskRunnerHeartbeatCommand").f(void 0, void 0).ser(se_ReportTaskRunnerHeartbeatCommand).de(de_ReportTaskRunnerHeartbeatCommand).build() {
+};
+__name(_ReportTaskRunnerHeartbeatCommand, "ReportTaskRunnerHeartbeatCommand");
+var ReportTaskRunnerHeartbeatCommand = _ReportTaskRunnerHeartbeatCommand;
+
+// src/commands/SetStatusCommand.ts
+
+
+
+
+var _SetStatusCommand = class _SetStatusCommand 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("DataPipeline", "SetStatus", {}).n("DataPipelineClient", "SetStatusCommand").f(void 0, void 0).ser(se_SetStatusCommand).de(de_SetStatusCommand).build() {
+};
+__name(_SetStatusCommand, "SetStatusCommand");
+var SetStatusCommand = _SetStatusCommand;
+
+// src/commands/SetTaskStatusCommand.ts
+
+
+
+
+var _SetTaskStatusCommand = class _SetTaskStatusCommand 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("DataPipeline", "SetTaskStatus", {}).n("DataPipelineClient", "SetTaskStatusCommand").f(void 0, void 0).ser(se_SetTaskStatusCommand).de(de_SetTaskStatusCommand).build() {
+};
+__name(_SetTaskStatusCommand, "SetTaskStatusCommand");
+var SetTaskStatusCommand = _SetTaskStatusCommand;
+
+// src/commands/ValidatePipelineDefinitionCommand.ts
+
+
+
+
+var _ValidatePipelineDefinitionCommand = class _ValidatePipelineDefinitionCommand 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("DataPipeline", "ValidatePipelineDefinition", {}).n("DataPipelineClient", "ValidatePipelineDefinitionCommand").f(void 0, void 0).ser(se_ValidatePipelineDefinitionCommand).de(de_ValidatePipelineDefinitionCommand).build() {
+};
+__name(_ValidatePipelineDefinitionCommand, "ValidatePipelineDefinitionCommand");
+var ValidatePipelineDefinitionCommand = _ValidatePipelineDefinitionCommand;
+
+// src/DataPipeline.ts
+var commands = {
+  ActivatePipelineCommand,
+  AddTagsCommand,
+  CreatePipelineCommand,
+  DeactivatePipelineCommand,
+  DeletePipelineCommand,
+  DescribeObjectsCommand,
+  DescribePipelinesCommand,
+  EvaluateExpressionCommand,
+  GetPipelineDefinitionCommand,
+  ListPipelinesCommand,
+  PollForTaskCommand,
+  PutPipelineDefinitionCommand,
+  QueryObjectsCommand,
+  RemoveTagsCommand,
+  ReportTaskProgressCommand,
+  ReportTaskRunnerHeartbeatCommand,
+  SetStatusCommand,
+  SetTaskStatusCommand,
+  ValidatePipelineDefinitionCommand
+};
+var _DataPipeline = class _DataPipeline extends DataPipelineClient {
+};
+__name(_DataPipeline, "DataPipeline");
+var DataPipeline = _DataPipeline;
+(0, import_smithy_client.createAggregatedClient)(commands, DataPipeline);
+
+// src/pagination/DescribeObjectsPaginator.ts
+var import_core = require("@smithy/core");
+var paginateDescribeObjects = (0, import_core.createPaginator)(DataPipelineClient, DescribeObjectsCommand, "marker", "marker", "");
+
+// src/pagination/ListPipelinesPaginator.ts
+
+var paginateListPipelines = (0, import_core.createPaginator)(DataPipelineClient, ListPipelinesCommand, "marker", "marker", "");
+
+// src/pagination/QueryObjectsPaginator.ts
+
+var paginateQueryObjects = (0, import_core.createPaginator)(DataPipelineClient, QueryObjectsCommand, "marker", "marker", "limit");
+
+// 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 = {
+  ActivatePipelineCommand,
+  AddTagsCommand,
+  CreatePipelineCommand,
+  DataPipeline,
+  DataPipelineClient,
+  DataPipelineServiceException,
+  DeactivatePipelineCommand,
+  DeletePipelineCommand,
+  DescribeObjectsCommand,
+  DescribePipelinesCommand,
+  EvaluateExpressionCommand,
+  GetPipelineDefinitionCommand,
+  InternalServiceError,
+  InvalidRequestException,
+  ListPipelinesCommand,
+  OperatorType,
+  PipelineDeletedException,
+  PipelineNotFoundException,
+  PollForTaskCommand,
+  PutPipelineDefinitionCommand,
+  QueryObjectsCommand,
+  RemoveTagsCommand,
+  ReportTaskProgressCommand,
+  ReportTaskRunnerHeartbeatCommand,
+  SetStatusCommand,
+  SetTaskStatusCommand,
+  TaskNotFoundException,
+  TaskStatus,
+  ValidatePipelineDefinitionCommand,
+  __Client,
+  paginateDescribeObjects,
+  paginateListPipelines,
+  paginateQueryObjects
+});