@aws-sdk/client-iotthingsgraph 3.489.0 → 3.495.0

package/dist-cjs/index.js

@@ -1,12 +1,3174 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IoTThingsGraphServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./IoTThingsGraphClient"), exports);
-tslib_1.__exportStar(require("./IoTThingsGraph"), 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 IoTThingsGraphServiceException_1 = require("./models/IoTThingsGraphServiceException");
-Object.defineProperty(exports, "IoTThingsGraphServiceException", { enumerable: true, get: function () { return IoTThingsGraphServiceException_1.IoTThingsGraphServiceException; } });
+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, {
+  AssociateEntityToThingCommand: () => AssociateEntityToThingCommand,
+  CreateFlowTemplateCommand: () => CreateFlowTemplateCommand,
+  CreateSystemInstanceCommand: () => CreateSystemInstanceCommand,
+  CreateSystemTemplateCommand: () => CreateSystemTemplateCommand,
+  DefinitionLanguage: () => DefinitionLanguage,
+  DeleteFlowTemplateCommand: () => DeleteFlowTemplateCommand,
+  DeleteNamespaceCommand: () => DeleteNamespaceCommand,
+  DeleteSystemInstanceCommand: () => DeleteSystemInstanceCommand,
+  DeleteSystemTemplateCommand: () => DeleteSystemTemplateCommand,
+  DeploySystemInstanceCommand: () => DeploySystemInstanceCommand,
+  DeploymentTarget: () => DeploymentTarget,
+  DeprecateFlowTemplateCommand: () => DeprecateFlowTemplateCommand,
+  DeprecateSystemTemplateCommand: () => DeprecateSystemTemplateCommand,
+  DescribeNamespaceCommand: () => DescribeNamespaceCommand,
+  DissociateEntityFromThingCommand: () => DissociateEntityFromThingCommand,
+  EntityFilterName: () => EntityFilterName,
+  EntityType: () => EntityType,
+  FlowExecutionEventType: () => FlowExecutionEventType,
+  FlowExecutionStatus: () => FlowExecutionStatus,
+  FlowTemplateFilterName: () => FlowTemplateFilterName,
+  GetEntitiesCommand: () => GetEntitiesCommand,
+  GetFlowTemplateCommand: () => GetFlowTemplateCommand,
+  GetFlowTemplateRevisionsCommand: () => GetFlowTemplateRevisionsCommand,
+  GetNamespaceDeletionStatusCommand: () => GetNamespaceDeletionStatusCommand,
+  GetSystemInstanceCommand: () => GetSystemInstanceCommand,
+  GetSystemTemplateCommand: () => GetSystemTemplateCommand,
+  GetSystemTemplateRevisionsCommand: () => GetSystemTemplateRevisionsCommand,
+  GetUploadStatusCommand: () => GetUploadStatusCommand,
+  InternalFailureException: () => InternalFailureException,
+  InvalidRequestException: () => InvalidRequestException,
+  IoTThingsGraph: () => IoTThingsGraph,
+  IoTThingsGraphClient: () => IoTThingsGraphClient,
+  IoTThingsGraphServiceException: () => IoTThingsGraphServiceException,
+  LimitExceededException: () => LimitExceededException,
+  ListFlowExecutionMessagesCommand: () => ListFlowExecutionMessagesCommand,
+  ListTagsForResourceCommand: () => ListTagsForResourceCommand,
+  NamespaceDeletionStatus: () => NamespaceDeletionStatus,
+  NamespaceDeletionStatusErrorCodes: () => NamespaceDeletionStatusErrorCodes,
+  ResourceAlreadyExistsException: () => ResourceAlreadyExistsException,
+  ResourceInUseException: () => ResourceInUseException,
+  ResourceNotFoundException: () => ResourceNotFoundException,
+  SearchEntitiesCommand: () => SearchEntitiesCommand,
+  SearchFlowExecutionsCommand: () => SearchFlowExecutionsCommand,
+  SearchFlowTemplatesCommand: () => SearchFlowTemplatesCommand,
+  SearchSystemInstancesCommand: () => SearchSystemInstancesCommand,
+  SearchSystemTemplatesCommand: () => SearchSystemTemplatesCommand,
+  SearchThingsCommand: () => SearchThingsCommand,
+  SystemInstanceDeploymentStatus: () => SystemInstanceDeploymentStatus,
+  SystemInstanceFilterName: () => SystemInstanceFilterName,
+  SystemTemplateFilterName: () => SystemTemplateFilterName,
+  TagResourceCommand: () => TagResourceCommand,
+  ThrottlingException: () => ThrottlingException,
+  UndeploySystemInstanceCommand: () => UndeploySystemInstanceCommand,
+  UntagResourceCommand: () => UntagResourceCommand,
+  UpdateFlowTemplateCommand: () => UpdateFlowTemplateCommand,
+  UpdateSystemTemplateCommand: () => UpdateSystemTemplateCommand,
+  UploadEntityDefinitionsCommand: () => UploadEntityDefinitionsCommand,
+  UploadStatus: () => UploadStatus,
+  __Client: () => import_smithy_client.Client,
+  paginateGetFlowTemplateRevisions: () => paginateGetFlowTemplateRevisions,
+  paginateGetSystemTemplateRevisions: () => paginateGetSystemTemplateRevisions,
+  paginateListFlowExecutionMessages: () => paginateListFlowExecutionMessages,
+  paginateListTagsForResource: () => paginateListTagsForResource,
+  paginateSearchEntities: () => paginateSearchEntities,
+  paginateSearchFlowExecutions: () => paginateSearchFlowExecutions,
+  paginateSearchFlowTemplates: () => paginateSearchFlowTemplates,
+  paginateSearchSystemInstances: () => paginateSearchSystemInstances,
+  paginateSearchSystemTemplates: () => paginateSearchSystemTemplates,
+  paginateSearchThings: () => paginateSearchThings
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/IoTThingsGraphClient.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: "iotthingsgraph"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/IoTThingsGraphClient.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/IoTThingsGraphClient.ts
+var _IoTThingsGraphClient = class _IoTThingsGraphClient 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(_IoTThingsGraphClient, "IoTThingsGraphClient");
+var IoTThingsGraphClient = _IoTThingsGraphClient;
+
+// src/IoTThingsGraph.ts
+
+
+// src/commands/AssociateEntityToThingCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/protocols/Aws_json1_1.ts
+
+
+
+// src/models/IoTThingsGraphServiceException.ts
+
+var _IoTThingsGraphServiceException = class _IoTThingsGraphServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _IoTThingsGraphServiceException.prototype);
+  }
+};
+__name(_IoTThingsGraphServiceException, "IoTThingsGraphServiceException");
+var IoTThingsGraphServiceException = _IoTThingsGraphServiceException;
+
+// src/models/models_0.ts
+var _InternalFailureException = class _InternalFailureException extends IoTThingsGraphServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InternalFailureException",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "InternalFailureException";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _InternalFailureException.prototype);
+  }
+};
+__name(_InternalFailureException, "InternalFailureException");
+var InternalFailureException = _InternalFailureException;
+var _InvalidRequestException = class _InvalidRequestException extends IoTThingsGraphServiceException {
+  /**
+   * @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 _ResourceNotFoundException = class _ResourceNotFoundException extends IoTThingsGraphServiceException {
+  /**
+   * @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 _ThrottlingException = class _ThrottlingException extends IoTThingsGraphServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ThrottlingException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ThrottlingException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ThrottlingException.prototype);
+  }
+};
+__name(_ThrottlingException, "ThrottlingException");
+var ThrottlingException = _ThrottlingException;
+var DefinitionLanguage = {
+  GRAPHQL: "GRAPHQL"
+};
+var _LimitExceededException = class _LimitExceededException extends IoTThingsGraphServiceException {
+  /**
+   * @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 _ResourceAlreadyExistsException = class _ResourceAlreadyExistsException extends IoTThingsGraphServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ResourceAlreadyExistsException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ResourceAlreadyExistsException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ResourceAlreadyExistsException.prototype);
+  }
+};
+__name(_ResourceAlreadyExistsException, "ResourceAlreadyExistsException");
+var ResourceAlreadyExistsException = _ResourceAlreadyExistsException;
+var DeploymentTarget = {
+  CLOUD: "CLOUD",
+  GREENGRASS: "GREENGRASS"
+};
+var SystemInstanceDeploymentStatus = {
+  BOOTSTRAP: "BOOTSTRAP",
+  DELETED_IN_TARGET: "DELETED_IN_TARGET",
+  DEPLOYED_IN_TARGET: "DEPLOYED_IN_TARGET",
+  DEPLOY_IN_PROGRESS: "DEPLOY_IN_PROGRESS",
+  FAILED: "FAILED",
+  NOT_DEPLOYED: "NOT_DEPLOYED",
+  PENDING_DELETE: "PENDING_DELETE",
+  UNDEPLOY_IN_PROGRESS: "UNDEPLOY_IN_PROGRESS"
+};
+var _ResourceInUseException = class _ResourceInUseException extends IoTThingsGraphServiceException {
+  /**
+   * @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 EntityType = {
+  ACTION: "ACTION",
+  CAPABILITY: "CAPABILITY",
+  DEVICE: "DEVICE",
+  DEVICE_MODEL: "DEVICE_MODEL",
+  ENUM: "ENUM",
+  EVENT: "EVENT",
+  MAPPING: "MAPPING",
+  PROPERTY: "PROPERTY",
+  SERVICE: "SERVICE",
+  STATE: "STATE"
+};
+var EntityFilterName = {
+  NAME: "NAME",
+  NAMESPACE: "NAMESPACE",
+  REFERENCED_ENTITY_ID: "REFERENCED_ENTITY_ID",
+  SEMANTIC_TYPE_PATH: "SEMANTIC_TYPE_PATH"
+};
+var FlowExecutionEventType = {
+  ACKNOWLEDGE_TASK_MESSAGE: "ACKNOWLEDGE_TASK_MESSAGE",
+  ACTIVITY_FAILED: "ACTIVITY_FAILED",
+  ACTIVITY_SCHEDULED: "ACTIVITY_SCHEDULED",
+  ACTIVITY_STARTED: "ACTIVITY_STARTED",
+  ACTIVITY_SUCCEEDED: "ACTIVITY_SUCCEEDED",
+  EXECUTION_ABORTED: "EXECUTION_ABORTED",
+  EXECUTION_FAILED: "EXECUTION_FAILED",
+  EXECUTION_STARTED: "EXECUTION_STARTED",
+  EXECUTION_SUCCEEDED: "EXECUTION_SUCCEEDED",
+  SCHEDULE_NEXT_READY_STEPS_TASK: "SCHEDULE_NEXT_READY_STEPS_TASK",
+  START_FLOW_EXECUTION_TASK: "START_FLOW_EXECUTION_TASK",
+  STEP_FAILED: "STEP_FAILED",
+  STEP_STARTED: "STEP_STARTED",
+  STEP_SUCCEEDED: "STEP_SUCCEEDED",
+  THING_ACTION_TASK: "THING_ACTION_TASK",
+  THING_ACTION_TASK_FAILED: "THING_ACTION_TASK_FAILED",
+  THING_ACTION_TASK_SUCCEEDED: "THING_ACTION_TASK_SUCCEEDED"
+};
+var FlowExecutionStatus = {
+  ABORTED: "ABORTED",
+  FAILED: "FAILED",
+  RUNNING: "RUNNING",
+  SUCCEEDED: "SUCCEEDED"
+};
+var FlowTemplateFilterName = {
+  DEVICE_MODEL_ID: "DEVICE_MODEL_ID"
+};
+var NamespaceDeletionStatusErrorCodes = {
+  VALIDATION_FAILED: "VALIDATION_FAILED"
+};
+var NamespaceDeletionStatus = {
+  FAILED: "FAILED",
+  IN_PROGRESS: "IN_PROGRESS",
+  SUCCEEDED: "SUCCEEDED"
+};
+var UploadStatus = {
+  FAILED: "FAILED",
+  IN_PROGRESS: "IN_PROGRESS",
+  SUCCEEDED: "SUCCEEDED"
+};
+var SystemInstanceFilterName = {
+  GREENGRASS_GROUP_NAME: "GREENGRASS_GROUP_NAME",
+  STATUS: "STATUS",
+  SYSTEM_TEMPLATE_ID: "SYSTEM_TEMPLATE_ID"
+};
+var SystemTemplateFilterName = {
+  FLOW_TEMPLATE_ID: "FLOW_TEMPLATE_ID"
+};
+
+// src/protocols/Aws_json1_1.ts
+var se_AssociateEntityToThingCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("AssociateEntityToThing");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_AssociateEntityToThingCommand");
+var se_CreateFlowTemplateCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateFlowTemplate");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateFlowTemplateCommand");
+var se_CreateSystemInstanceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateSystemInstance");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateSystemInstanceCommand");
+var se_CreateSystemTemplateCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateSystemTemplate");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateSystemTemplateCommand");
+var se_DeleteFlowTemplateCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteFlowTemplate");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteFlowTemplateCommand");
+var se_DeleteNamespaceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteNamespace");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteNamespaceCommand");
+var se_DeleteSystemInstanceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteSystemInstance");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteSystemInstanceCommand");
+var se_DeleteSystemTemplateCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteSystemTemplate");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteSystemTemplateCommand");
+var se_DeploySystemInstanceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeploySystemInstance");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeploySystemInstanceCommand");
+var se_DeprecateFlowTemplateCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeprecateFlowTemplate");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeprecateFlowTemplateCommand");
+var se_DeprecateSystemTemplateCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeprecateSystemTemplate");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeprecateSystemTemplateCommand");
+var se_DescribeNamespaceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeNamespace");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeNamespaceCommand");
+var se_DissociateEntityFromThingCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DissociateEntityFromThing");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DissociateEntityFromThingCommand");
+var se_GetEntitiesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetEntities");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetEntitiesCommand");
+var se_GetFlowTemplateCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetFlowTemplate");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetFlowTemplateCommand");
+var se_GetFlowTemplateRevisionsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetFlowTemplateRevisions");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetFlowTemplateRevisionsCommand");
+var se_GetNamespaceDeletionStatusCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetNamespaceDeletionStatus");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetNamespaceDeletionStatusCommand");
+var se_GetSystemInstanceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetSystemInstance");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetSystemInstanceCommand");
+var se_GetSystemTemplateCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetSystemTemplate");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetSystemTemplateCommand");
+var se_GetSystemTemplateRevisionsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetSystemTemplateRevisions");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetSystemTemplateRevisionsCommand");
+var se_GetUploadStatusCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetUploadStatus");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetUploadStatusCommand");
+var se_ListFlowExecutionMessagesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListFlowExecutionMessages");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListFlowExecutionMessagesCommand");
+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_SearchEntitiesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("SearchEntities");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_SearchEntitiesCommand");
+var se_SearchFlowExecutionsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("SearchFlowExecutions");
+  let body;
+  body = JSON.stringify(se_SearchFlowExecutionsRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_SearchFlowExecutionsCommand");
+var se_SearchFlowTemplatesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("SearchFlowTemplates");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_SearchFlowTemplatesCommand");
+var se_SearchSystemInstancesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("SearchSystemInstances");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_SearchSystemInstancesCommand");
+var se_SearchSystemTemplatesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("SearchSystemTemplates");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_SearchSystemTemplatesCommand");
+var se_SearchThingsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("SearchThings");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_SearchThingsCommand");
+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_UndeploySystemInstanceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UndeploySystemInstance");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UndeploySystemInstanceCommand");
+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_UpdateFlowTemplateCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateFlowTemplate");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateFlowTemplateCommand");
+var se_UpdateSystemTemplateCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateSystemTemplate");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateSystemTemplateCommand");
+var se_UploadEntityDefinitionsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UploadEntityDefinitions");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UploadEntityDefinitionsCommand");
+var de_AssociateEntityToThingCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_AssociateEntityToThingCommandError(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_AssociateEntityToThingCommand");
+var de_AssociateEntityToThingCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalFailureException":
+    case "com.amazonaws.iotthingsgraph#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.iotthingsgraph#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.iotthingsgraph#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.iotthingsgraph#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_AssociateEntityToThingCommandError");
+var de_CreateFlowTemplateCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateFlowTemplateCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_CreateFlowTemplateResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateFlowTemplateCommand");
+var de_CreateFlowTemplateCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalFailureException":
+    case "com.amazonaws.iotthingsgraph#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.iotthingsgraph#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.iotthingsgraph#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceAlreadyExistsException":
+    case "com.amazonaws.iotthingsgraph#ResourceAlreadyExistsException":
+      throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.iotthingsgraph#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateFlowTemplateCommandError");
+var de_CreateSystemInstanceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateSystemInstanceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_CreateSystemInstanceResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateSystemInstanceCommand");
+var de_CreateSystemInstanceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalFailureException":
+    case "com.amazonaws.iotthingsgraph#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.iotthingsgraph#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.iotthingsgraph#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceAlreadyExistsException":
+    case "com.amazonaws.iotthingsgraph#ResourceAlreadyExistsException":
+      throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.iotthingsgraph#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateSystemInstanceCommandError");
+var de_CreateSystemTemplateCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateSystemTemplateCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_CreateSystemTemplateResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateSystemTemplateCommand");
+var de_CreateSystemTemplateCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalFailureException":
+    case "com.amazonaws.iotthingsgraph#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.iotthingsgraph#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceAlreadyExistsException":
+    case "com.amazonaws.iotthingsgraph#ResourceAlreadyExistsException":
+      throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.iotthingsgraph#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateSystemTemplateCommandError");
+var de_DeleteFlowTemplateCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteFlowTemplateCommandError(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_DeleteFlowTemplateCommand");
+var de_DeleteFlowTemplateCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalFailureException":
+    case "com.amazonaws.iotthingsgraph#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.iotthingsgraph#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceInUseException":
+    case "com.amazonaws.iotthingsgraph#ResourceInUseException":
+      throw await de_ResourceInUseExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.iotthingsgraph#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteFlowTemplateCommandError");
+var de_DeleteNamespaceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteNamespaceCommandError(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_DeleteNamespaceCommand");
+var de_DeleteNamespaceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalFailureException":
+    case "com.amazonaws.iotthingsgraph#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.iotthingsgraph#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteNamespaceCommandError");
+var de_DeleteSystemInstanceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteSystemInstanceCommandError(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_DeleteSystemInstanceCommand");
+var de_DeleteSystemInstanceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalFailureException":
+    case "com.amazonaws.iotthingsgraph#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.iotthingsgraph#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceInUseException":
+    case "com.amazonaws.iotthingsgraph#ResourceInUseException":
+      throw await de_ResourceInUseExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.iotthingsgraph#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteSystemInstanceCommandError");
+var de_DeleteSystemTemplateCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteSystemTemplateCommandError(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_DeleteSystemTemplateCommand");
+var de_DeleteSystemTemplateCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalFailureException":
+    case "com.amazonaws.iotthingsgraph#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.iotthingsgraph#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceInUseException":
+    case "com.amazonaws.iotthingsgraph#ResourceInUseException":
+      throw await de_ResourceInUseExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.iotthingsgraph#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteSystemTemplateCommandError");
+var de_DeploySystemInstanceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeploySystemInstanceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DeploySystemInstanceResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeploySystemInstanceCommand");
+var de_DeploySystemInstanceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalFailureException":
+    case "com.amazonaws.iotthingsgraph#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.iotthingsgraph#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceInUseException":
+    case "com.amazonaws.iotthingsgraph#ResourceInUseException":
+      throw await de_ResourceInUseExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.iotthingsgraph#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.iotthingsgraph#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeploySystemInstanceCommandError");
+var de_DeprecateFlowTemplateCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeprecateFlowTemplateCommandError(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_DeprecateFlowTemplateCommand");
+var de_DeprecateFlowTemplateCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalFailureException":
+    case "com.amazonaws.iotthingsgraph#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.iotthingsgraph#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.iotthingsgraph#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.iotthingsgraph#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeprecateFlowTemplateCommandError");
+var de_DeprecateSystemTemplateCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeprecateSystemTemplateCommandError(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_DeprecateSystemTemplateCommand");
+var de_DeprecateSystemTemplateCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalFailureException":
+    case "com.amazonaws.iotthingsgraph#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.iotthingsgraph#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.iotthingsgraph#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.iotthingsgraph#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeprecateSystemTemplateCommandError");
+var de_DescribeNamespaceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeNamespaceCommandError(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_DescribeNamespaceCommand");
+var de_DescribeNamespaceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalFailureException":
+    case "com.amazonaws.iotthingsgraph#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.iotthingsgraph#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.iotthingsgraph#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.iotthingsgraph#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeNamespaceCommandError");
+var de_DissociateEntityFromThingCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DissociateEntityFromThingCommandError(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_DissociateEntityFromThingCommand");
+var de_DissociateEntityFromThingCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalFailureException":
+    case "com.amazonaws.iotthingsgraph#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.iotthingsgraph#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.iotthingsgraph#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.iotthingsgraph#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DissociateEntityFromThingCommandError");
+var de_GetEntitiesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetEntitiesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_GetEntitiesResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetEntitiesCommand");
+var de_GetEntitiesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalFailureException":
+    case "com.amazonaws.iotthingsgraph#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.iotthingsgraph#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.iotthingsgraph#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.iotthingsgraph#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetEntitiesCommandError");
+var de_GetFlowTemplateCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetFlowTemplateCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_GetFlowTemplateResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetFlowTemplateCommand");
+var de_GetFlowTemplateCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalFailureException":
+    case "com.amazonaws.iotthingsgraph#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.iotthingsgraph#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.iotthingsgraph#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.iotthingsgraph#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetFlowTemplateCommandError");
+var de_GetFlowTemplateRevisionsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetFlowTemplateRevisionsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_GetFlowTemplateRevisionsResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetFlowTemplateRevisionsCommand");
+var de_GetFlowTemplateRevisionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalFailureException":
+    case "com.amazonaws.iotthingsgraph#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.iotthingsgraph#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.iotthingsgraph#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.iotthingsgraph#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetFlowTemplateRevisionsCommandError");
+var de_GetNamespaceDeletionStatusCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetNamespaceDeletionStatusCommandError(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_GetNamespaceDeletionStatusCommand");
+var de_GetNamespaceDeletionStatusCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalFailureException":
+    case "com.amazonaws.iotthingsgraph#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.iotthingsgraph#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.iotthingsgraph#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetNamespaceDeletionStatusCommandError");
+var de_GetSystemInstanceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetSystemInstanceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_GetSystemInstanceResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetSystemInstanceCommand");
+var de_GetSystemInstanceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalFailureException":
+    case "com.amazonaws.iotthingsgraph#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.iotthingsgraph#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.iotthingsgraph#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.iotthingsgraph#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetSystemInstanceCommandError");
+var de_GetSystemTemplateCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetSystemTemplateCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_GetSystemTemplateResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetSystemTemplateCommand");
+var de_GetSystemTemplateCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalFailureException":
+    case "com.amazonaws.iotthingsgraph#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.iotthingsgraph#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.iotthingsgraph#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.iotthingsgraph#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetSystemTemplateCommandError");
+var de_GetSystemTemplateRevisionsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetSystemTemplateRevisionsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_GetSystemTemplateRevisionsResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetSystemTemplateRevisionsCommand");
+var de_GetSystemTemplateRevisionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalFailureException":
+    case "com.amazonaws.iotthingsgraph#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.iotthingsgraph#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.iotthingsgraph#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.iotthingsgraph#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetSystemTemplateRevisionsCommandError");
+var de_GetUploadStatusCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetUploadStatusCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_GetUploadStatusResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetUploadStatusCommand");
+var de_GetUploadStatusCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalFailureException":
+    case "com.amazonaws.iotthingsgraph#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.iotthingsgraph#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.iotthingsgraph#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.iotthingsgraph#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetUploadStatusCommandError");
+var de_ListFlowExecutionMessagesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListFlowExecutionMessagesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListFlowExecutionMessagesResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListFlowExecutionMessagesCommand");
+var de_ListFlowExecutionMessagesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalFailureException":
+    case "com.amazonaws.iotthingsgraph#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.iotthingsgraph#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.iotthingsgraph#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.iotthingsgraph#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListFlowExecutionMessagesCommandError");
+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 "InternalFailureException":
+    case "com.amazonaws.iotthingsgraph#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.iotthingsgraph#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceAlreadyExistsException":
+    case "com.amazonaws.iotthingsgraph#ResourceAlreadyExistsException":
+      throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.iotthingsgraph#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListTagsForResourceCommandError");
+var de_SearchEntitiesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_SearchEntitiesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_SearchEntitiesResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_SearchEntitiesCommand");
+var de_SearchEntitiesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalFailureException":
+    case "com.amazonaws.iotthingsgraph#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.iotthingsgraph#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.iotthingsgraph#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_SearchEntitiesCommandError");
+var de_SearchFlowExecutionsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_SearchFlowExecutionsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_SearchFlowExecutionsResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_SearchFlowExecutionsCommand");
+var de_SearchFlowExecutionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalFailureException":
+    case "com.amazonaws.iotthingsgraph#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.iotthingsgraph#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.iotthingsgraph#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.iotthingsgraph#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_SearchFlowExecutionsCommandError");
+var de_SearchFlowTemplatesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_SearchFlowTemplatesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_SearchFlowTemplatesResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_SearchFlowTemplatesCommand");
+var de_SearchFlowTemplatesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalFailureException":
+    case "com.amazonaws.iotthingsgraph#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.iotthingsgraph#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.iotthingsgraph#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_SearchFlowTemplatesCommandError");
+var de_SearchSystemInstancesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_SearchSystemInstancesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_SearchSystemInstancesResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_SearchSystemInstancesCommand");
+var de_SearchSystemInstancesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalFailureException":
+    case "com.amazonaws.iotthingsgraph#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.iotthingsgraph#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.iotthingsgraph#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_SearchSystemInstancesCommandError");
+var de_SearchSystemTemplatesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_SearchSystemTemplatesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_SearchSystemTemplatesResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_SearchSystemTemplatesCommand");
+var de_SearchSystemTemplatesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalFailureException":
+    case "com.amazonaws.iotthingsgraph#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.iotthingsgraph#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.iotthingsgraph#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_SearchSystemTemplatesCommandError");
+var de_SearchThingsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_SearchThingsCommandError(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_SearchThingsCommand");
+var de_SearchThingsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalFailureException":
+    case "com.amazonaws.iotthingsgraph#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.iotthingsgraph#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.iotthingsgraph#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.iotthingsgraph#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_SearchThingsCommandError");
+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 "InternalFailureException":
+    case "com.amazonaws.iotthingsgraph#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.iotthingsgraph#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceAlreadyExistsException":
+    case "com.amazonaws.iotthingsgraph#ResourceAlreadyExistsException":
+      throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.iotthingsgraph#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_TagResourceCommandError");
+var de_UndeploySystemInstanceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UndeploySystemInstanceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_UndeploySystemInstanceResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UndeploySystemInstanceCommand");
+var de_UndeploySystemInstanceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalFailureException":
+    case "com.amazonaws.iotthingsgraph#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.iotthingsgraph#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceInUseException":
+    case "com.amazonaws.iotthingsgraph#ResourceInUseException":
+      throw await de_ResourceInUseExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.iotthingsgraph#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.iotthingsgraph#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UndeploySystemInstanceCommandError");
+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 "InternalFailureException":
+    case "com.amazonaws.iotthingsgraph#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.iotthingsgraph#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceAlreadyExistsException":
+    case "com.amazonaws.iotthingsgraph#ResourceAlreadyExistsException":
+      throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.iotthingsgraph#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UntagResourceCommandError");
+var de_UpdateFlowTemplateCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateFlowTemplateCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_UpdateFlowTemplateResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateFlowTemplateCommand");
+var de_UpdateFlowTemplateCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalFailureException":
+    case "com.amazonaws.iotthingsgraph#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.iotthingsgraph#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.iotthingsgraph#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.iotthingsgraph#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateFlowTemplateCommandError");
+var de_UpdateSystemTemplateCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateSystemTemplateCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_UpdateSystemTemplateResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateSystemTemplateCommand");
+var de_UpdateSystemTemplateCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalFailureException":
+    case "com.amazonaws.iotthingsgraph#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.iotthingsgraph#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.iotthingsgraph#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.iotthingsgraph#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateSystemTemplateCommandError");
+var de_UploadEntityDefinitionsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UploadEntityDefinitionsCommandError(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_UploadEntityDefinitionsCommand");
+var de_UploadEntityDefinitionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalFailureException":
+    case "com.amazonaws.iotthingsgraph#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.iotthingsgraph#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.iotthingsgraph#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UploadEntityDefinitionsCommandError");
+var de_InternalFailureExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InternalFailureException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InternalFailureExceptionRes");
+var de_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_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_ResourceAlreadyExistsExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ResourceAlreadyExistsException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ResourceAlreadyExistsExceptionRes");
+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_ThrottlingExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ThrottlingException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ThrottlingExceptionRes");
+var se_SearchFlowExecutionsRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    endTime: (_) => Math.round(_.getTime() / 1e3),
+    flowExecutionId: [],
+    maxResults: [],
+    nextToken: [],
+    startTime: (_) => Math.round(_.getTime() / 1e3),
+    systemInstanceId: []
+  });
+}, "se_SearchFlowExecutionsRequest");
+var de_CreateFlowTemplateResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    summary: (_) => de_FlowTemplateSummary(_, context)
+  });
+}, "de_CreateFlowTemplateResponse");
+var de_CreateSystemInstanceResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    summary: (_) => de_SystemInstanceSummary(_, context)
+  });
+}, "de_CreateSystemInstanceResponse");
+var de_CreateSystemTemplateResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    summary: (_) => de_SystemTemplateSummary(_, context)
+  });
+}, "de_CreateSystemTemplateResponse");
+var de_DeploySystemInstanceResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    greengrassDeploymentId: import_smithy_client.expectString,
+    summary: (_) => de_SystemInstanceSummary(_, context)
+  });
+}, "de_DeploySystemInstanceResponse");
+var de_EntityDescription = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    arn: import_smithy_client.expectString,
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    definition: import_smithy_client._json,
+    id: import_smithy_client.expectString,
+    type: import_smithy_client.expectString
+  });
+}, "de_EntityDescription");
+var de_EntityDescriptions = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_EntityDescription(entry, context);
+  });
+  return retVal;
+}, "de_EntityDescriptions");
+var de_FlowExecutionMessage = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    eventType: import_smithy_client.expectString,
+    messageId: import_smithy_client.expectString,
+    payload: import_smithy_client.expectString,
+    timestamp: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_)))
+  });
+}, "de_FlowExecutionMessage");
+var de_FlowExecutionMessages = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_FlowExecutionMessage(entry, context);
+  });
+  return retVal;
+}, "de_FlowExecutionMessages");
+var de_FlowExecutionSummaries = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_FlowExecutionSummary(entry, context);
+  });
+  return retVal;
+}, "de_FlowExecutionSummaries");
+var de_FlowExecutionSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    flowExecutionId: import_smithy_client.expectString,
+    flowTemplateId: import_smithy_client.expectString,
+    status: import_smithy_client.expectString,
+    systemInstanceId: import_smithy_client.expectString,
+    updatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_)))
+  });
+}, "de_FlowExecutionSummary");
+var de_FlowTemplateDescription = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    definition: import_smithy_client._json,
+    summary: (_) => de_FlowTemplateSummary(_, context),
+    validatedNamespaceVersion: import_smithy_client.expectLong
+  });
+}, "de_FlowTemplateDescription");
+var de_FlowTemplateSummaries = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_FlowTemplateSummary(entry, context);
+  });
+  return retVal;
+}, "de_FlowTemplateSummaries");
+var de_FlowTemplateSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    arn: import_smithy_client.expectString,
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    id: import_smithy_client.expectString,
+    revisionNumber: import_smithy_client.expectLong
+  });
+}, "de_FlowTemplateSummary");
+var de_GetEntitiesResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    descriptions: (_) => de_EntityDescriptions(_, context)
+  });
+}, "de_GetEntitiesResponse");
+var de_GetFlowTemplateResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    description: (_) => de_FlowTemplateDescription(_, context)
+  });
+}, "de_GetFlowTemplateResponse");
+var de_GetFlowTemplateRevisionsResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    nextToken: import_smithy_client.expectString,
+    summaries: (_) => de_FlowTemplateSummaries(_, context)
+  });
+}, "de_GetFlowTemplateRevisionsResponse");
+var de_GetSystemInstanceResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    description: (_) => de_SystemInstanceDescription(_, context)
+  });
+}, "de_GetSystemInstanceResponse");
+var de_GetSystemTemplateResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    description: (_) => de_SystemTemplateDescription(_, context)
+  });
+}, "de_GetSystemTemplateResponse");
+var de_GetSystemTemplateRevisionsResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    nextToken: import_smithy_client.expectString,
+    summaries: (_) => de_SystemTemplateSummaries(_, context)
+  });
+}, "de_GetSystemTemplateRevisionsResponse");
+var de_GetUploadStatusResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    createdDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    failureReason: import_smithy_client._json,
+    namespaceArn: import_smithy_client.expectString,
+    namespaceName: import_smithy_client.expectString,
+    namespaceVersion: import_smithy_client.expectLong,
+    uploadId: import_smithy_client.expectString,
+    uploadStatus: import_smithy_client.expectString
+  });
+}, "de_GetUploadStatusResponse");
+var de_ListFlowExecutionMessagesResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    messages: (_) => de_FlowExecutionMessages(_, context),
+    nextToken: import_smithy_client.expectString
+  });
+}, "de_ListFlowExecutionMessagesResponse");
+var de_SearchEntitiesResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    descriptions: (_) => de_EntityDescriptions(_, context),
+    nextToken: import_smithy_client.expectString
+  });
+}, "de_SearchEntitiesResponse");
+var de_SearchFlowExecutionsResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    nextToken: import_smithy_client.expectString,
+    summaries: (_) => de_FlowExecutionSummaries(_, context)
+  });
+}, "de_SearchFlowExecutionsResponse");
+var de_SearchFlowTemplatesResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    nextToken: import_smithy_client.expectString,
+    summaries: (_) => de_FlowTemplateSummaries(_, context)
+  });
+}, "de_SearchFlowTemplatesResponse");
+var de_SearchSystemInstancesResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    nextToken: import_smithy_client.expectString,
+    summaries: (_) => de_SystemInstanceSummaries(_, context)
+  });
+}, "de_SearchSystemInstancesResponse");
+var de_SearchSystemTemplatesResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    nextToken: import_smithy_client.expectString,
+    summaries: (_) => de_SystemTemplateSummaries(_, context)
+  });
+}, "de_SearchSystemTemplatesResponse");
+var de_SystemInstanceDescription = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    definition: import_smithy_client._json,
+    flowActionsRoleArn: import_smithy_client.expectString,
+    metricsConfiguration: import_smithy_client._json,
+    s3BucketName: import_smithy_client.expectString,
+    summary: (_) => de_SystemInstanceSummary(_, context),
+    validatedDependencyRevisions: import_smithy_client._json,
+    validatedNamespaceVersion: import_smithy_client.expectLong
+  });
+}, "de_SystemInstanceDescription");
+var de_SystemInstanceSummaries = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_SystemInstanceSummary(entry, context);
+  });
+  return retVal;
+}, "de_SystemInstanceSummaries");
+var de_SystemInstanceSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    arn: import_smithy_client.expectString,
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    greengrassGroupId: import_smithy_client.expectString,
+    greengrassGroupName: import_smithy_client.expectString,
+    greengrassGroupVersionId: import_smithy_client.expectString,
+    id: import_smithy_client.expectString,
+    status: import_smithy_client.expectString,
+    target: import_smithy_client.expectString,
+    updatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_)))
+  });
+}, "de_SystemInstanceSummary");
+var de_SystemTemplateDescription = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    definition: import_smithy_client._json,
+    summary: (_) => de_SystemTemplateSummary(_, context),
+    validatedNamespaceVersion: import_smithy_client.expectLong
+  });
+}, "de_SystemTemplateDescription");
+var de_SystemTemplateSummaries = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_SystemTemplateSummary(entry, context);
+  });
+  return retVal;
+}, "de_SystemTemplateSummaries");
+var de_SystemTemplateSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    arn: import_smithy_client.expectString,
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    id: import_smithy_client.expectString,
+    revisionNumber: import_smithy_client.expectLong
+  });
+}, "de_SystemTemplateSummary");
+var de_UndeploySystemInstanceResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    summary: (_) => de_SystemInstanceSummary(_, context)
+  });
+}, "de_UndeploySystemInstanceResponse");
+var de_UpdateFlowTemplateResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    summary: (_) => de_FlowTemplateSummary(_, context)
+  });
+}, "de_UpdateFlowTemplateResponse");
+var de_UpdateSystemTemplateResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    summary: (_) => de_SystemTemplateSummary(_, context)
+  });
+}, "de_UpdateSystemTemplateResponse");
+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)(IoTThingsGraphServiceException);
+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": `IotThingsGraphFrontEndService.${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/AssociateEntityToThingCommand.ts
+var _AssociateEntityToThingCommand = class _AssociateEntityToThingCommand 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("IotThingsGraphFrontEndService", "AssociateEntityToThing", {}).n("IoTThingsGraphClient", "AssociateEntityToThingCommand").f(void 0, void 0).ser(se_AssociateEntityToThingCommand).de(de_AssociateEntityToThingCommand).build() {
+};
+__name(_AssociateEntityToThingCommand, "AssociateEntityToThingCommand");
+var AssociateEntityToThingCommand = _AssociateEntityToThingCommand;
+
+// src/commands/CreateFlowTemplateCommand.ts
+
+
+
+
+var _CreateFlowTemplateCommand = class _CreateFlowTemplateCommand 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("IotThingsGraphFrontEndService", "CreateFlowTemplate", {}).n("IoTThingsGraphClient", "CreateFlowTemplateCommand").f(void 0, void 0).ser(se_CreateFlowTemplateCommand).de(de_CreateFlowTemplateCommand).build() {
+};
+__name(_CreateFlowTemplateCommand, "CreateFlowTemplateCommand");
+var CreateFlowTemplateCommand = _CreateFlowTemplateCommand;
+
+// src/commands/CreateSystemInstanceCommand.ts
+
+
+
+
+var _CreateSystemInstanceCommand = class _CreateSystemInstanceCommand 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("IotThingsGraphFrontEndService", "CreateSystemInstance", {}).n("IoTThingsGraphClient", "CreateSystemInstanceCommand").f(void 0, void 0).ser(se_CreateSystemInstanceCommand).de(de_CreateSystemInstanceCommand).build() {
+};
+__name(_CreateSystemInstanceCommand, "CreateSystemInstanceCommand");
+var CreateSystemInstanceCommand = _CreateSystemInstanceCommand;
+
+// src/commands/CreateSystemTemplateCommand.ts
+
+
+
+
+var _CreateSystemTemplateCommand = class _CreateSystemTemplateCommand 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("IotThingsGraphFrontEndService", "CreateSystemTemplate", {}).n("IoTThingsGraphClient", "CreateSystemTemplateCommand").f(void 0, void 0).ser(se_CreateSystemTemplateCommand).de(de_CreateSystemTemplateCommand).build() {
+};
+__name(_CreateSystemTemplateCommand, "CreateSystemTemplateCommand");
+var CreateSystemTemplateCommand = _CreateSystemTemplateCommand;
+
+// src/commands/DeleteFlowTemplateCommand.ts
+
+
+
+
+var _DeleteFlowTemplateCommand = class _DeleteFlowTemplateCommand 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("IotThingsGraphFrontEndService", "DeleteFlowTemplate", {}).n("IoTThingsGraphClient", "DeleteFlowTemplateCommand").f(void 0, void 0).ser(se_DeleteFlowTemplateCommand).de(de_DeleteFlowTemplateCommand).build() {
+};
+__name(_DeleteFlowTemplateCommand, "DeleteFlowTemplateCommand");
+var DeleteFlowTemplateCommand = _DeleteFlowTemplateCommand;
+
+// src/commands/DeleteNamespaceCommand.ts
+
+
+
+
+var _DeleteNamespaceCommand = class _DeleteNamespaceCommand 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("IotThingsGraphFrontEndService", "DeleteNamespace", {}).n("IoTThingsGraphClient", "DeleteNamespaceCommand").f(void 0, void 0).ser(se_DeleteNamespaceCommand).de(de_DeleteNamespaceCommand).build() {
+};
+__name(_DeleteNamespaceCommand, "DeleteNamespaceCommand");
+var DeleteNamespaceCommand = _DeleteNamespaceCommand;
+
+// src/commands/DeleteSystemInstanceCommand.ts
+
+
+
+
+var _DeleteSystemInstanceCommand = class _DeleteSystemInstanceCommand 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("IotThingsGraphFrontEndService", "DeleteSystemInstance", {}).n("IoTThingsGraphClient", "DeleteSystemInstanceCommand").f(void 0, void 0).ser(se_DeleteSystemInstanceCommand).de(de_DeleteSystemInstanceCommand).build() {
+};
+__name(_DeleteSystemInstanceCommand, "DeleteSystemInstanceCommand");
+var DeleteSystemInstanceCommand = _DeleteSystemInstanceCommand;
+
+// src/commands/DeleteSystemTemplateCommand.ts
+
+
+
+
+var _DeleteSystemTemplateCommand = class _DeleteSystemTemplateCommand 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("IotThingsGraphFrontEndService", "DeleteSystemTemplate", {}).n("IoTThingsGraphClient", "DeleteSystemTemplateCommand").f(void 0, void 0).ser(se_DeleteSystemTemplateCommand).de(de_DeleteSystemTemplateCommand).build() {
+};
+__name(_DeleteSystemTemplateCommand, "DeleteSystemTemplateCommand");
+var DeleteSystemTemplateCommand = _DeleteSystemTemplateCommand;
+
+// src/commands/DeploySystemInstanceCommand.ts
+
+
+
+
+var _DeploySystemInstanceCommand = class _DeploySystemInstanceCommand 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("IotThingsGraphFrontEndService", "DeploySystemInstance", {}).n("IoTThingsGraphClient", "DeploySystemInstanceCommand").f(void 0, void 0).ser(se_DeploySystemInstanceCommand).de(de_DeploySystemInstanceCommand).build() {
+};
+__name(_DeploySystemInstanceCommand, "DeploySystemInstanceCommand");
+var DeploySystemInstanceCommand = _DeploySystemInstanceCommand;
+
+// src/commands/DeprecateFlowTemplateCommand.ts
+
+
+
+
+var _DeprecateFlowTemplateCommand = class _DeprecateFlowTemplateCommand 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("IotThingsGraphFrontEndService", "DeprecateFlowTemplate", {}).n("IoTThingsGraphClient", "DeprecateFlowTemplateCommand").f(void 0, void 0).ser(se_DeprecateFlowTemplateCommand).de(de_DeprecateFlowTemplateCommand).build() {
+};
+__name(_DeprecateFlowTemplateCommand, "DeprecateFlowTemplateCommand");
+var DeprecateFlowTemplateCommand = _DeprecateFlowTemplateCommand;
+
+// src/commands/DeprecateSystemTemplateCommand.ts
+
+
+
+
+var _DeprecateSystemTemplateCommand = class _DeprecateSystemTemplateCommand 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("IotThingsGraphFrontEndService", "DeprecateSystemTemplate", {}).n("IoTThingsGraphClient", "DeprecateSystemTemplateCommand").f(void 0, void 0).ser(se_DeprecateSystemTemplateCommand).de(de_DeprecateSystemTemplateCommand).build() {
+};
+__name(_DeprecateSystemTemplateCommand, "DeprecateSystemTemplateCommand");
+var DeprecateSystemTemplateCommand = _DeprecateSystemTemplateCommand;
+
+// src/commands/DescribeNamespaceCommand.ts
+
+
+
+
+var _DescribeNamespaceCommand = class _DescribeNamespaceCommand 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("IotThingsGraphFrontEndService", "DescribeNamespace", {}).n("IoTThingsGraphClient", "DescribeNamespaceCommand").f(void 0, void 0).ser(se_DescribeNamespaceCommand).de(de_DescribeNamespaceCommand).build() {
+};
+__name(_DescribeNamespaceCommand, "DescribeNamespaceCommand");
+var DescribeNamespaceCommand = _DescribeNamespaceCommand;
+
+// src/commands/DissociateEntityFromThingCommand.ts
+
+
+
+
+var _DissociateEntityFromThingCommand = class _DissociateEntityFromThingCommand 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("IotThingsGraphFrontEndService", "DissociateEntityFromThing", {}).n("IoTThingsGraphClient", "DissociateEntityFromThingCommand").f(void 0, void 0).ser(se_DissociateEntityFromThingCommand).de(de_DissociateEntityFromThingCommand).build() {
+};
+__name(_DissociateEntityFromThingCommand, "DissociateEntityFromThingCommand");
+var DissociateEntityFromThingCommand = _DissociateEntityFromThingCommand;
+
+// src/commands/GetEntitiesCommand.ts
+
+
+
+
+var _GetEntitiesCommand = class _GetEntitiesCommand 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("IotThingsGraphFrontEndService", "GetEntities", {}).n("IoTThingsGraphClient", "GetEntitiesCommand").f(void 0, void 0).ser(se_GetEntitiesCommand).de(de_GetEntitiesCommand).build() {
+};
+__name(_GetEntitiesCommand, "GetEntitiesCommand");
+var GetEntitiesCommand = _GetEntitiesCommand;
+
+// src/commands/GetFlowTemplateCommand.ts
+
+
+
+
+var _GetFlowTemplateCommand = class _GetFlowTemplateCommand 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("IotThingsGraphFrontEndService", "GetFlowTemplate", {}).n("IoTThingsGraphClient", "GetFlowTemplateCommand").f(void 0, void 0).ser(se_GetFlowTemplateCommand).de(de_GetFlowTemplateCommand).build() {
+};
+__name(_GetFlowTemplateCommand, "GetFlowTemplateCommand");
+var GetFlowTemplateCommand = _GetFlowTemplateCommand;
+
+// src/commands/GetFlowTemplateRevisionsCommand.ts
+
+
+
+
+var _GetFlowTemplateRevisionsCommand = class _GetFlowTemplateRevisionsCommand 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("IotThingsGraphFrontEndService", "GetFlowTemplateRevisions", {}).n("IoTThingsGraphClient", "GetFlowTemplateRevisionsCommand").f(void 0, void 0).ser(se_GetFlowTemplateRevisionsCommand).de(de_GetFlowTemplateRevisionsCommand).build() {
+};
+__name(_GetFlowTemplateRevisionsCommand, "GetFlowTemplateRevisionsCommand");
+var GetFlowTemplateRevisionsCommand = _GetFlowTemplateRevisionsCommand;
+
+// src/commands/GetNamespaceDeletionStatusCommand.ts
+
+
+
+
+var _GetNamespaceDeletionStatusCommand = class _GetNamespaceDeletionStatusCommand 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("IotThingsGraphFrontEndService", "GetNamespaceDeletionStatus", {}).n("IoTThingsGraphClient", "GetNamespaceDeletionStatusCommand").f(void 0, void 0).ser(se_GetNamespaceDeletionStatusCommand).de(de_GetNamespaceDeletionStatusCommand).build() {
+};
+__name(_GetNamespaceDeletionStatusCommand, "GetNamespaceDeletionStatusCommand");
+var GetNamespaceDeletionStatusCommand = _GetNamespaceDeletionStatusCommand;
+
+// src/commands/GetSystemInstanceCommand.ts
+
+
+
+
+var _GetSystemInstanceCommand = class _GetSystemInstanceCommand 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("IotThingsGraphFrontEndService", "GetSystemInstance", {}).n("IoTThingsGraphClient", "GetSystemInstanceCommand").f(void 0, void 0).ser(se_GetSystemInstanceCommand).de(de_GetSystemInstanceCommand).build() {
+};
+__name(_GetSystemInstanceCommand, "GetSystemInstanceCommand");
+var GetSystemInstanceCommand = _GetSystemInstanceCommand;
+
+// src/commands/GetSystemTemplateCommand.ts
+
+
+
+
+var _GetSystemTemplateCommand = class _GetSystemTemplateCommand 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("IotThingsGraphFrontEndService", "GetSystemTemplate", {}).n("IoTThingsGraphClient", "GetSystemTemplateCommand").f(void 0, void 0).ser(se_GetSystemTemplateCommand).de(de_GetSystemTemplateCommand).build() {
+};
+__name(_GetSystemTemplateCommand, "GetSystemTemplateCommand");
+var GetSystemTemplateCommand = _GetSystemTemplateCommand;
+
+// src/commands/GetSystemTemplateRevisionsCommand.ts
+
+
+
+
+var _GetSystemTemplateRevisionsCommand = class _GetSystemTemplateRevisionsCommand 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("IotThingsGraphFrontEndService", "GetSystemTemplateRevisions", {}).n("IoTThingsGraphClient", "GetSystemTemplateRevisionsCommand").f(void 0, void 0).ser(se_GetSystemTemplateRevisionsCommand).de(de_GetSystemTemplateRevisionsCommand).build() {
+};
+__name(_GetSystemTemplateRevisionsCommand, "GetSystemTemplateRevisionsCommand");
+var GetSystemTemplateRevisionsCommand = _GetSystemTemplateRevisionsCommand;
+
+// src/commands/GetUploadStatusCommand.ts
+
+
+
+
+var _GetUploadStatusCommand = class _GetUploadStatusCommand 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("IotThingsGraphFrontEndService", "GetUploadStatus", {}).n("IoTThingsGraphClient", "GetUploadStatusCommand").f(void 0, void 0).ser(se_GetUploadStatusCommand).de(de_GetUploadStatusCommand).build() {
+};
+__name(_GetUploadStatusCommand, "GetUploadStatusCommand");
+var GetUploadStatusCommand = _GetUploadStatusCommand;
+
+// src/commands/ListFlowExecutionMessagesCommand.ts
+
+
+
+
+var _ListFlowExecutionMessagesCommand = class _ListFlowExecutionMessagesCommand 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("IotThingsGraphFrontEndService", "ListFlowExecutionMessages", {}).n("IoTThingsGraphClient", "ListFlowExecutionMessagesCommand").f(void 0, void 0).ser(se_ListFlowExecutionMessagesCommand).de(de_ListFlowExecutionMessagesCommand).build() {
+};
+__name(_ListFlowExecutionMessagesCommand, "ListFlowExecutionMessagesCommand");
+var ListFlowExecutionMessagesCommand = _ListFlowExecutionMessagesCommand;
+
+// 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("IotThingsGraphFrontEndService", "ListTagsForResource", {}).n("IoTThingsGraphClient", "ListTagsForResourceCommand").f(void 0, void 0).ser(se_ListTagsForResourceCommand).de(de_ListTagsForResourceCommand).build() {
+};
+__name(_ListTagsForResourceCommand, "ListTagsForResourceCommand");
+var ListTagsForResourceCommand = _ListTagsForResourceCommand;
+
+// src/commands/SearchEntitiesCommand.ts
+
+
+
+
+var _SearchEntitiesCommand = class _SearchEntitiesCommand 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("IotThingsGraphFrontEndService", "SearchEntities", {}).n("IoTThingsGraphClient", "SearchEntitiesCommand").f(void 0, void 0).ser(se_SearchEntitiesCommand).de(de_SearchEntitiesCommand).build() {
+};
+__name(_SearchEntitiesCommand, "SearchEntitiesCommand");
+var SearchEntitiesCommand = _SearchEntitiesCommand;
+
+// src/commands/SearchFlowExecutionsCommand.ts
+
+
+
+
+var _SearchFlowExecutionsCommand = class _SearchFlowExecutionsCommand 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("IotThingsGraphFrontEndService", "SearchFlowExecutions", {}).n("IoTThingsGraphClient", "SearchFlowExecutionsCommand").f(void 0, void 0).ser(se_SearchFlowExecutionsCommand).de(de_SearchFlowExecutionsCommand).build() {
+};
+__name(_SearchFlowExecutionsCommand, "SearchFlowExecutionsCommand");
+var SearchFlowExecutionsCommand = _SearchFlowExecutionsCommand;
+
+// src/commands/SearchFlowTemplatesCommand.ts
+
+
+
+
+var _SearchFlowTemplatesCommand = class _SearchFlowTemplatesCommand 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("IotThingsGraphFrontEndService", "SearchFlowTemplates", {}).n("IoTThingsGraphClient", "SearchFlowTemplatesCommand").f(void 0, void 0).ser(se_SearchFlowTemplatesCommand).de(de_SearchFlowTemplatesCommand).build() {
+};
+__name(_SearchFlowTemplatesCommand, "SearchFlowTemplatesCommand");
+var SearchFlowTemplatesCommand = _SearchFlowTemplatesCommand;
+
+// src/commands/SearchSystemInstancesCommand.ts
+
+
+
+
+var _SearchSystemInstancesCommand = class _SearchSystemInstancesCommand 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("IotThingsGraphFrontEndService", "SearchSystemInstances", {}).n("IoTThingsGraphClient", "SearchSystemInstancesCommand").f(void 0, void 0).ser(se_SearchSystemInstancesCommand).de(de_SearchSystemInstancesCommand).build() {
+};
+__name(_SearchSystemInstancesCommand, "SearchSystemInstancesCommand");
+var SearchSystemInstancesCommand = _SearchSystemInstancesCommand;
+
+// src/commands/SearchSystemTemplatesCommand.ts
+
+
+
+
+var _SearchSystemTemplatesCommand = class _SearchSystemTemplatesCommand 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("IotThingsGraphFrontEndService", "SearchSystemTemplates", {}).n("IoTThingsGraphClient", "SearchSystemTemplatesCommand").f(void 0, void 0).ser(se_SearchSystemTemplatesCommand).de(de_SearchSystemTemplatesCommand).build() {
+};
+__name(_SearchSystemTemplatesCommand, "SearchSystemTemplatesCommand");
+var SearchSystemTemplatesCommand = _SearchSystemTemplatesCommand;
+
+// src/commands/SearchThingsCommand.ts
+
+
+
+
+var _SearchThingsCommand = class _SearchThingsCommand 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("IotThingsGraphFrontEndService", "SearchThings", {}).n("IoTThingsGraphClient", "SearchThingsCommand").f(void 0, void 0).ser(se_SearchThingsCommand).de(de_SearchThingsCommand).build() {
+};
+__name(_SearchThingsCommand, "SearchThingsCommand");
+var SearchThingsCommand = _SearchThingsCommand;
+
+// 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("IotThingsGraphFrontEndService", "TagResource", {}).n("IoTThingsGraphClient", "TagResourceCommand").f(void 0, void 0).ser(se_TagResourceCommand).de(de_TagResourceCommand).build() {
+};
+__name(_TagResourceCommand, "TagResourceCommand");
+var TagResourceCommand = _TagResourceCommand;
+
+// src/commands/UndeploySystemInstanceCommand.ts
+
+
+
+
+var _UndeploySystemInstanceCommand = class _UndeploySystemInstanceCommand 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("IotThingsGraphFrontEndService", "UndeploySystemInstance", {}).n("IoTThingsGraphClient", "UndeploySystemInstanceCommand").f(void 0, void 0).ser(se_UndeploySystemInstanceCommand).de(de_UndeploySystemInstanceCommand).build() {
+};
+__name(_UndeploySystemInstanceCommand, "UndeploySystemInstanceCommand");
+var UndeploySystemInstanceCommand = _UndeploySystemInstanceCommand;
+
+// 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("IotThingsGraphFrontEndService", "UntagResource", {}).n("IoTThingsGraphClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
+};
+__name(_UntagResourceCommand, "UntagResourceCommand");
+var UntagResourceCommand = _UntagResourceCommand;
+
+// src/commands/UpdateFlowTemplateCommand.ts
+
+
+
+
+var _UpdateFlowTemplateCommand = class _UpdateFlowTemplateCommand 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("IotThingsGraphFrontEndService", "UpdateFlowTemplate", {}).n("IoTThingsGraphClient", "UpdateFlowTemplateCommand").f(void 0, void 0).ser(se_UpdateFlowTemplateCommand).de(de_UpdateFlowTemplateCommand).build() {
+};
+__name(_UpdateFlowTemplateCommand, "UpdateFlowTemplateCommand");
+var UpdateFlowTemplateCommand = _UpdateFlowTemplateCommand;
+
+// src/commands/UpdateSystemTemplateCommand.ts
+
+
+
+
+var _UpdateSystemTemplateCommand = class _UpdateSystemTemplateCommand 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("IotThingsGraphFrontEndService", "UpdateSystemTemplate", {}).n("IoTThingsGraphClient", "UpdateSystemTemplateCommand").f(void 0, void 0).ser(se_UpdateSystemTemplateCommand).de(de_UpdateSystemTemplateCommand).build() {
+};
+__name(_UpdateSystemTemplateCommand, "UpdateSystemTemplateCommand");
+var UpdateSystemTemplateCommand = _UpdateSystemTemplateCommand;
+
+// src/commands/UploadEntityDefinitionsCommand.ts
+
+
+
+
+var _UploadEntityDefinitionsCommand = class _UploadEntityDefinitionsCommand 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("IotThingsGraphFrontEndService", "UploadEntityDefinitions", {}).n("IoTThingsGraphClient", "UploadEntityDefinitionsCommand").f(void 0, void 0).ser(se_UploadEntityDefinitionsCommand).de(de_UploadEntityDefinitionsCommand).build() {
+};
+__name(_UploadEntityDefinitionsCommand, "UploadEntityDefinitionsCommand");
+var UploadEntityDefinitionsCommand = _UploadEntityDefinitionsCommand;
+
+// src/IoTThingsGraph.ts
+var commands = {
+  AssociateEntityToThingCommand,
+  CreateFlowTemplateCommand,
+  CreateSystemInstanceCommand,
+  CreateSystemTemplateCommand,
+  DeleteFlowTemplateCommand,
+  DeleteNamespaceCommand,
+  DeleteSystemInstanceCommand,
+  DeleteSystemTemplateCommand,
+  DeploySystemInstanceCommand,
+  DeprecateFlowTemplateCommand,
+  DeprecateSystemTemplateCommand,
+  DescribeNamespaceCommand,
+  DissociateEntityFromThingCommand,
+  GetEntitiesCommand,
+  GetFlowTemplateCommand,
+  GetFlowTemplateRevisionsCommand,
+  GetNamespaceDeletionStatusCommand,
+  GetSystemInstanceCommand,
+  GetSystemTemplateCommand,
+  GetSystemTemplateRevisionsCommand,
+  GetUploadStatusCommand,
+  ListFlowExecutionMessagesCommand,
+  ListTagsForResourceCommand,
+  SearchEntitiesCommand,
+  SearchFlowExecutionsCommand,
+  SearchFlowTemplatesCommand,
+  SearchSystemInstancesCommand,
+  SearchSystemTemplatesCommand,
+  SearchThingsCommand,
+  TagResourceCommand,
+  UndeploySystemInstanceCommand,
+  UntagResourceCommand,
+  UpdateFlowTemplateCommand,
+  UpdateSystemTemplateCommand,
+  UploadEntityDefinitionsCommand
+};
+var _IoTThingsGraph = class _IoTThingsGraph extends IoTThingsGraphClient {
+};
+__name(_IoTThingsGraph, "IoTThingsGraph");
+var IoTThingsGraph = _IoTThingsGraph;
+(0, import_smithy_client.createAggregatedClient)(commands, IoTThingsGraph);
+
+// src/pagination/GetFlowTemplateRevisionsPaginator.ts
+var import_core = require("@smithy/core");
+var paginateGetFlowTemplateRevisions = (0, import_core.createPaginator)(IoTThingsGraphClient, GetFlowTemplateRevisionsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/GetSystemTemplateRevisionsPaginator.ts
+
+var paginateGetSystemTemplateRevisions = (0, import_core.createPaginator)(IoTThingsGraphClient, GetSystemTemplateRevisionsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListFlowExecutionMessagesPaginator.ts
+
+var paginateListFlowExecutionMessages = (0, import_core.createPaginator)(IoTThingsGraphClient, ListFlowExecutionMessagesCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListTagsForResourcePaginator.ts
+
+var paginateListTagsForResource = (0, import_core.createPaginator)(IoTThingsGraphClient, ListTagsForResourceCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/SearchEntitiesPaginator.ts
+
+var paginateSearchEntities = (0, import_core.createPaginator)(IoTThingsGraphClient, SearchEntitiesCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/SearchFlowExecutionsPaginator.ts
+
+var paginateSearchFlowExecutions = (0, import_core.createPaginator)(IoTThingsGraphClient, SearchFlowExecutionsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/SearchFlowTemplatesPaginator.ts
+
+var paginateSearchFlowTemplates = (0, import_core.createPaginator)(IoTThingsGraphClient, SearchFlowTemplatesCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/SearchSystemInstancesPaginator.ts
+
+var paginateSearchSystemInstances = (0, import_core.createPaginator)(IoTThingsGraphClient, SearchSystemInstancesCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/SearchSystemTemplatesPaginator.ts
+
+var paginateSearchSystemTemplates = (0, import_core.createPaginator)(IoTThingsGraphClient, SearchSystemTemplatesCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/SearchThingsPaginator.ts
+
+var paginateSearchThings = (0, import_core.createPaginator)(IoTThingsGraphClient, SearchThingsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/index.ts
+var import_util_endpoints = require("@aws-sdk/util-endpoints");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AssociateEntityToThingCommand,
+  CreateFlowTemplateCommand,
+  CreateSystemInstanceCommand,
+  CreateSystemTemplateCommand,
+  DefinitionLanguage,
+  DeleteFlowTemplateCommand,
+  DeleteNamespaceCommand,
+  DeleteSystemInstanceCommand,
+  DeleteSystemTemplateCommand,
+  DeploySystemInstanceCommand,
+  DeploymentTarget,
+  DeprecateFlowTemplateCommand,
+  DeprecateSystemTemplateCommand,
+  DescribeNamespaceCommand,
+  DissociateEntityFromThingCommand,
+  EntityFilterName,
+  EntityType,
+  FlowExecutionEventType,
+  FlowExecutionStatus,
+  FlowTemplateFilterName,
+  GetEntitiesCommand,
+  GetFlowTemplateCommand,
+  GetFlowTemplateRevisionsCommand,
+  GetNamespaceDeletionStatusCommand,
+  GetSystemInstanceCommand,
+  GetSystemTemplateCommand,
+  GetSystemTemplateRevisionsCommand,
+  GetUploadStatusCommand,
+  InternalFailureException,
+  InvalidRequestException,
+  IoTThingsGraph,
+  IoTThingsGraphClient,
+  IoTThingsGraphServiceException,
+  LimitExceededException,
+  ListFlowExecutionMessagesCommand,
+  ListTagsForResourceCommand,
+  NamespaceDeletionStatus,
+  NamespaceDeletionStatusErrorCodes,
+  ResourceAlreadyExistsException,
+  ResourceInUseException,
+  ResourceNotFoundException,
+  SearchEntitiesCommand,
+  SearchFlowExecutionsCommand,
+  SearchFlowTemplatesCommand,
+  SearchSystemInstancesCommand,
+  SearchSystemTemplatesCommand,
+  SearchThingsCommand,
+  SystemInstanceDeploymentStatus,
+  SystemInstanceFilterName,
+  SystemTemplateFilterName,
+  TagResourceCommand,
+  ThrottlingException,
+  UndeploySystemInstanceCommand,
+  UntagResourceCommand,
+  UpdateFlowTemplateCommand,
+  UpdateSystemTemplateCommand,
+  UploadEntityDefinitionsCommand,
+  UploadStatus,
+  __Client,
+  paginateGetFlowTemplateRevisions,
+  paginateGetSystemTemplateRevisions,
+  paginateListFlowExecutionMessages,
+  paginateListTagsForResource,
+  paginateSearchEntities,
+  paginateSearchFlowExecutions,
+  paginateSearchFlowTemplates,
+  paginateSearchSystemInstances,
+  paginateSearchSystemTemplates,
+  paginateSearchThings
+});