@aws-sdk/client-servicediscovery 3.489.0 → 3.495.0

package/dist-cjs/index.js

@@ -1,12 +1,2731 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ServiceDiscoveryServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./ServiceDiscoveryClient"), exports);
-tslib_1.__exportStar(require("./ServiceDiscovery"), 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 ServiceDiscoveryServiceException_1 = require("./models/ServiceDiscoveryServiceException");
-Object.defineProperty(exports, "ServiceDiscoveryServiceException", { enumerable: true, get: function () { return ServiceDiscoveryServiceException_1.ServiceDiscoveryServiceException; } });
+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, {
+  CreateHttpNamespaceCommand: () => CreateHttpNamespaceCommand,
+  CreatePrivateDnsNamespaceCommand: () => CreatePrivateDnsNamespaceCommand,
+  CreatePublicDnsNamespaceCommand: () => CreatePublicDnsNamespaceCommand,
+  CreateServiceCommand: () => CreateServiceCommand,
+  CustomHealthNotFound: () => CustomHealthNotFound,
+  CustomHealthStatus: () => CustomHealthStatus,
+  DeleteNamespaceCommand: () => DeleteNamespaceCommand,
+  DeleteServiceCommand: () => DeleteServiceCommand,
+  DeregisterInstanceCommand: () => DeregisterInstanceCommand,
+  DiscoverInstancesCommand: () => DiscoverInstancesCommand,
+  DiscoverInstancesRevisionCommand: () => DiscoverInstancesRevisionCommand,
+  DuplicateRequest: () => DuplicateRequest,
+  FilterCondition: () => FilterCondition,
+  GetInstanceCommand: () => GetInstanceCommand,
+  GetInstancesHealthStatusCommand: () => GetInstancesHealthStatusCommand,
+  GetNamespaceCommand: () => GetNamespaceCommand,
+  GetOperationCommand: () => GetOperationCommand,
+  GetServiceCommand: () => GetServiceCommand,
+  HealthCheckType: () => HealthCheckType,
+  HealthStatus: () => HealthStatus,
+  HealthStatusFilter: () => HealthStatusFilter,
+  InstanceNotFound: () => InstanceNotFound,
+  InvalidInput: () => InvalidInput,
+  ListInstancesCommand: () => ListInstancesCommand,
+  ListNamespacesCommand: () => ListNamespacesCommand,
+  ListOperationsCommand: () => ListOperationsCommand,
+  ListServicesCommand: () => ListServicesCommand,
+  ListTagsForResourceCommand: () => ListTagsForResourceCommand,
+  NamespaceAlreadyExists: () => NamespaceAlreadyExists,
+  NamespaceFilterName: () => NamespaceFilterName,
+  NamespaceNotFound: () => NamespaceNotFound,
+  NamespaceType: () => NamespaceType,
+  OperationFilterName: () => OperationFilterName,
+  OperationNotFound: () => OperationNotFound,
+  OperationStatus: () => OperationStatus,
+  OperationTargetType: () => OperationTargetType,
+  OperationType: () => OperationType,
+  RecordType: () => RecordType,
+  RegisterInstanceCommand: () => RegisterInstanceCommand,
+  RequestLimitExceeded: () => RequestLimitExceeded,
+  ResourceInUse: () => ResourceInUse,
+  ResourceLimitExceeded: () => ResourceLimitExceeded,
+  ResourceNotFoundException: () => ResourceNotFoundException,
+  RoutingPolicy: () => RoutingPolicy,
+  ServiceAlreadyExists: () => ServiceAlreadyExists,
+  ServiceDiscovery: () => ServiceDiscovery,
+  ServiceDiscoveryClient: () => ServiceDiscoveryClient,
+  ServiceDiscoveryServiceException: () => ServiceDiscoveryServiceException,
+  ServiceFilterName: () => ServiceFilterName,
+  ServiceNotFound: () => ServiceNotFound,
+  ServiceType: () => ServiceType,
+  ServiceTypeOption: () => ServiceTypeOption,
+  TagResourceCommand: () => TagResourceCommand,
+  TooManyTagsException: () => TooManyTagsException,
+  UntagResourceCommand: () => UntagResourceCommand,
+  UpdateHttpNamespaceCommand: () => UpdateHttpNamespaceCommand,
+  UpdateInstanceCustomHealthStatusCommand: () => UpdateInstanceCustomHealthStatusCommand,
+  UpdatePrivateDnsNamespaceCommand: () => UpdatePrivateDnsNamespaceCommand,
+  UpdatePublicDnsNamespaceCommand: () => UpdatePublicDnsNamespaceCommand,
+  UpdateServiceCommand: () => UpdateServiceCommand,
+  __Client: () => import_smithy_client.Client,
+  paginateGetInstancesHealthStatus: () => paginateGetInstancesHealthStatus,
+  paginateListInstances: () => paginateListInstances,
+  paginateListNamespaces: () => paginateListNamespaces,
+  paginateListOperations: () => paginateListOperations,
+  paginateListServices: () => paginateListServices
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/ServiceDiscoveryClient.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: "servicediscovery"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/ServiceDiscoveryClient.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/ServiceDiscoveryClient.ts
+var _ServiceDiscoveryClient = class _ServiceDiscoveryClient 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(_ServiceDiscoveryClient, "ServiceDiscoveryClient");
+var ServiceDiscoveryClient = _ServiceDiscoveryClient;
+
+// src/ServiceDiscovery.ts
+
+
+// src/commands/CreateHttpNamespaceCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/protocols/Aws_json1_1.ts
+
+
+var import_uuid = require("uuid");
+
+// src/models/ServiceDiscoveryServiceException.ts
+
+var _ServiceDiscoveryServiceException = class _ServiceDiscoveryServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _ServiceDiscoveryServiceException.prototype);
+  }
+};
+__name(_ServiceDiscoveryServiceException, "ServiceDiscoveryServiceException");
+var ServiceDiscoveryServiceException = _ServiceDiscoveryServiceException;
+
+// src/models/models_0.ts
+var _DuplicateRequest = class _DuplicateRequest extends ServiceDiscoveryServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "DuplicateRequest",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "DuplicateRequest";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _DuplicateRequest.prototype);
+    this.Message = opts.Message;
+    this.DuplicateOperationId = opts.DuplicateOperationId;
+  }
+};
+__name(_DuplicateRequest, "DuplicateRequest");
+var DuplicateRequest = _DuplicateRequest;
+var _InvalidInput = class _InvalidInput extends ServiceDiscoveryServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidInput",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidInput";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidInput.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_InvalidInput, "InvalidInput");
+var InvalidInput = _InvalidInput;
+var _NamespaceAlreadyExists = class _NamespaceAlreadyExists extends ServiceDiscoveryServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "NamespaceAlreadyExists",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "NamespaceAlreadyExists";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _NamespaceAlreadyExists.prototype);
+    this.Message = opts.Message;
+    this.CreatorRequestId = opts.CreatorRequestId;
+    this.NamespaceId = opts.NamespaceId;
+  }
+};
+__name(_NamespaceAlreadyExists, "NamespaceAlreadyExists");
+var NamespaceAlreadyExists = _NamespaceAlreadyExists;
+var _ResourceLimitExceeded = class _ResourceLimitExceeded extends ServiceDiscoveryServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ResourceLimitExceeded",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ResourceLimitExceeded";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ResourceLimitExceeded.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_ResourceLimitExceeded, "ResourceLimitExceeded");
+var ResourceLimitExceeded = _ResourceLimitExceeded;
+var _TooManyTagsException = class _TooManyTagsException extends ServiceDiscoveryServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "TooManyTagsException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "TooManyTagsException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _TooManyTagsException.prototype);
+    this.Message = opts.Message;
+    this.ResourceName = opts.ResourceName;
+  }
+};
+__name(_TooManyTagsException, "TooManyTagsException");
+var TooManyTagsException = _TooManyTagsException;
+var RecordType = {
+  A: "A",
+  AAAA: "AAAA",
+  CNAME: "CNAME",
+  SRV: "SRV"
+};
+var RoutingPolicy = {
+  MULTIVALUE: "MULTIVALUE",
+  WEIGHTED: "WEIGHTED"
+};
+var HealthCheckType = {
+  HTTP: "HTTP",
+  HTTPS: "HTTPS",
+  TCP: "TCP"
+};
+var ServiceTypeOption = {
+  HTTP: "HTTP"
+};
+var ServiceType = {
+  DNS: "DNS",
+  DNS_HTTP: "DNS_HTTP",
+  HTTP: "HTTP"
+};
+var _NamespaceNotFound = class _NamespaceNotFound extends ServiceDiscoveryServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "NamespaceNotFound",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "NamespaceNotFound";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _NamespaceNotFound.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_NamespaceNotFound, "NamespaceNotFound");
+var NamespaceNotFound = _NamespaceNotFound;
+var _ServiceAlreadyExists = class _ServiceAlreadyExists extends ServiceDiscoveryServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ServiceAlreadyExists",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ServiceAlreadyExists";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ServiceAlreadyExists.prototype);
+    this.Message = opts.Message;
+    this.CreatorRequestId = opts.CreatorRequestId;
+    this.ServiceId = opts.ServiceId;
+  }
+};
+__name(_ServiceAlreadyExists, "ServiceAlreadyExists");
+var ServiceAlreadyExists = _ServiceAlreadyExists;
+var _CustomHealthNotFound = class _CustomHealthNotFound extends ServiceDiscoveryServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "CustomHealthNotFound",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "CustomHealthNotFound";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _CustomHealthNotFound.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_CustomHealthNotFound, "CustomHealthNotFound");
+var CustomHealthNotFound = _CustomHealthNotFound;
+var CustomHealthStatus = {
+  HEALTHY: "HEALTHY",
+  UNHEALTHY: "UNHEALTHY"
+};
+var _ResourceInUse = class _ResourceInUse extends ServiceDiscoveryServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ResourceInUse",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ResourceInUse";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ResourceInUse.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_ResourceInUse, "ResourceInUse");
+var ResourceInUse = _ResourceInUse;
+var _ServiceNotFound = class _ServiceNotFound extends ServiceDiscoveryServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ServiceNotFound",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ServiceNotFound";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ServiceNotFound.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_ServiceNotFound, "ServiceNotFound");
+var ServiceNotFound = _ServiceNotFound;
+var _InstanceNotFound = class _InstanceNotFound extends ServiceDiscoveryServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InstanceNotFound",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InstanceNotFound";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InstanceNotFound.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_InstanceNotFound, "InstanceNotFound");
+var InstanceNotFound = _InstanceNotFound;
+var HealthStatusFilter = {
+  ALL: "ALL",
+  HEALTHY: "HEALTHY",
+  HEALTHY_OR_ELSE_ALL: "HEALTHY_OR_ELSE_ALL",
+  UNHEALTHY: "UNHEALTHY"
+};
+var HealthStatus = {
+  HEALTHY: "HEALTHY",
+  UNHEALTHY: "UNHEALTHY",
+  UNKNOWN: "UNKNOWN"
+};
+var _RequestLimitExceeded = class _RequestLimitExceeded extends ServiceDiscoveryServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "RequestLimitExceeded",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "RequestLimitExceeded";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _RequestLimitExceeded.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_RequestLimitExceeded, "RequestLimitExceeded");
+var RequestLimitExceeded = _RequestLimitExceeded;
+var FilterCondition = {
+  BEGINS_WITH: "BEGINS_WITH",
+  BETWEEN: "BETWEEN",
+  EQ: "EQ",
+  IN: "IN"
+};
+var NamespaceType = {
+  DNS_PRIVATE: "DNS_PRIVATE",
+  DNS_PUBLIC: "DNS_PUBLIC",
+  HTTP: "HTTP"
+};
+var OperationStatus = {
+  FAIL: "FAIL",
+  PENDING: "PENDING",
+  SUBMITTED: "SUBMITTED",
+  SUCCESS: "SUCCESS"
+};
+var OperationTargetType = {
+  INSTANCE: "INSTANCE",
+  NAMESPACE: "NAMESPACE",
+  SERVICE: "SERVICE"
+};
+var OperationType = {
+  CREATE_NAMESPACE: "CREATE_NAMESPACE",
+  DELETE_NAMESPACE: "DELETE_NAMESPACE",
+  DEREGISTER_INSTANCE: "DEREGISTER_INSTANCE",
+  REGISTER_INSTANCE: "REGISTER_INSTANCE",
+  UPDATE_NAMESPACE: "UPDATE_NAMESPACE",
+  UPDATE_SERVICE: "UPDATE_SERVICE"
+};
+var _OperationNotFound = class _OperationNotFound extends ServiceDiscoveryServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "OperationNotFound",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "OperationNotFound";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _OperationNotFound.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_OperationNotFound, "OperationNotFound");
+var OperationNotFound = _OperationNotFound;
+var NamespaceFilterName = {
+  HTTP_NAME: "HTTP_NAME",
+  NAME: "NAME",
+  TYPE: "TYPE"
+};
+var OperationFilterName = {
+  NAMESPACE_ID: "NAMESPACE_ID",
+  SERVICE_ID: "SERVICE_ID",
+  STATUS: "STATUS",
+  TYPE: "TYPE",
+  UPDATE_DATE: "UPDATE_DATE"
+};
+var ServiceFilterName = {
+  NAMESPACE_ID: "NAMESPACE_ID"
+};
+var _ResourceNotFoundException = class _ResourceNotFoundException extends ServiceDiscoveryServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ResourceNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ResourceNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_ResourceNotFoundException, "ResourceNotFoundException");
+var ResourceNotFoundException = _ResourceNotFoundException;
+
+// src/protocols/Aws_json1_1.ts
+var se_CreateHttpNamespaceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateHttpNamespace");
+  let body;
+  body = JSON.stringify(se_CreateHttpNamespaceRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateHttpNamespaceCommand");
+var se_CreatePrivateDnsNamespaceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreatePrivateDnsNamespace");
+  let body;
+  body = JSON.stringify(se_CreatePrivateDnsNamespaceRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreatePrivateDnsNamespaceCommand");
+var se_CreatePublicDnsNamespaceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreatePublicDnsNamespace");
+  let body;
+  body = JSON.stringify(se_CreatePublicDnsNamespaceRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreatePublicDnsNamespaceCommand");
+var se_CreateServiceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateService");
+  let body;
+  body = JSON.stringify(se_CreateServiceRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateServiceCommand");
+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_DeleteServiceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteService");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteServiceCommand");
+var se_DeregisterInstanceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeregisterInstance");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeregisterInstanceCommand");
+var se_DiscoverInstancesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DiscoverInstances");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  let { hostname: resolvedHostname } = await context.endpoint();
+  if (context.disableHostPrefix !== true) {
+    resolvedHostname = "data-" + resolvedHostname;
+    if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
+      throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+    }
+  }
+  return buildHttpRpcRequest(context, headers, "/", resolvedHostname, body);
+}, "se_DiscoverInstancesCommand");
+var se_DiscoverInstancesRevisionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DiscoverInstancesRevision");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  let { hostname: resolvedHostname } = await context.endpoint();
+  if (context.disableHostPrefix !== true) {
+    resolvedHostname = "data-" + resolvedHostname;
+    if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
+      throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+    }
+  }
+  return buildHttpRpcRequest(context, headers, "/", resolvedHostname, body);
+}, "se_DiscoverInstancesRevisionCommand");
+var se_GetInstanceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetInstance");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetInstanceCommand");
+var se_GetInstancesHealthStatusCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetInstancesHealthStatus");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetInstancesHealthStatusCommand");
+var se_GetNamespaceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetNamespace");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetNamespaceCommand");
+var se_GetOperationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetOperation");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetOperationCommand");
+var se_GetServiceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetService");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetServiceCommand");
+var se_ListInstancesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListInstances");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListInstancesCommand");
+var se_ListNamespacesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListNamespaces");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListNamespacesCommand");
+var se_ListOperationsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListOperations");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListOperationsCommand");
+var se_ListServicesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListServices");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListServicesCommand");
+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_RegisterInstanceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("RegisterInstance");
+  let body;
+  body = JSON.stringify(se_RegisterInstanceRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_RegisterInstanceCommand");
+var se_TagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("TagResource");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_TagResourceCommand");
+var se_UntagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UntagResource");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UntagResourceCommand");
+var se_UpdateHttpNamespaceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateHttpNamespace");
+  let body;
+  body = JSON.stringify(se_UpdateHttpNamespaceRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateHttpNamespaceCommand");
+var se_UpdateInstanceCustomHealthStatusCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateInstanceCustomHealthStatus");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateInstanceCustomHealthStatusCommand");
+var se_UpdatePrivateDnsNamespaceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdatePrivateDnsNamespace");
+  let body;
+  body = JSON.stringify(se_UpdatePrivateDnsNamespaceRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdatePrivateDnsNamespaceCommand");
+var se_UpdatePublicDnsNamespaceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdatePublicDnsNamespace");
+  let body;
+  body = JSON.stringify(se_UpdatePublicDnsNamespaceRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdatePublicDnsNamespaceCommand");
+var se_UpdateServiceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateService");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateServiceCommand");
+var de_CreateHttpNamespaceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateHttpNamespaceCommandError(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_CreateHttpNamespaceCommand");
+var de_CreateHttpNamespaceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DuplicateRequest":
+    case "com.amazonaws.servicediscovery#DuplicateRequest":
+      throw await de_DuplicateRequestRes(parsedOutput, context);
+    case "InvalidInput":
+    case "com.amazonaws.servicediscovery#InvalidInput":
+      throw await de_InvalidInputRes(parsedOutput, context);
+    case "NamespaceAlreadyExists":
+    case "com.amazonaws.servicediscovery#NamespaceAlreadyExists":
+      throw await de_NamespaceAlreadyExistsRes(parsedOutput, context);
+    case "ResourceLimitExceeded":
+    case "com.amazonaws.servicediscovery#ResourceLimitExceeded":
+      throw await de_ResourceLimitExceededRes(parsedOutput, context);
+    case "TooManyTagsException":
+    case "com.amazonaws.servicediscovery#TooManyTagsException":
+      throw await de_TooManyTagsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateHttpNamespaceCommandError");
+var de_CreatePrivateDnsNamespaceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreatePrivateDnsNamespaceCommandError(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_CreatePrivateDnsNamespaceCommand");
+var de_CreatePrivateDnsNamespaceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DuplicateRequest":
+    case "com.amazonaws.servicediscovery#DuplicateRequest":
+      throw await de_DuplicateRequestRes(parsedOutput, context);
+    case "InvalidInput":
+    case "com.amazonaws.servicediscovery#InvalidInput":
+      throw await de_InvalidInputRes(parsedOutput, context);
+    case "NamespaceAlreadyExists":
+    case "com.amazonaws.servicediscovery#NamespaceAlreadyExists":
+      throw await de_NamespaceAlreadyExistsRes(parsedOutput, context);
+    case "ResourceLimitExceeded":
+    case "com.amazonaws.servicediscovery#ResourceLimitExceeded":
+      throw await de_ResourceLimitExceededRes(parsedOutput, context);
+    case "TooManyTagsException":
+    case "com.amazonaws.servicediscovery#TooManyTagsException":
+      throw await de_TooManyTagsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreatePrivateDnsNamespaceCommandError");
+var de_CreatePublicDnsNamespaceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreatePublicDnsNamespaceCommandError(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_CreatePublicDnsNamespaceCommand");
+var de_CreatePublicDnsNamespaceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DuplicateRequest":
+    case "com.amazonaws.servicediscovery#DuplicateRequest":
+      throw await de_DuplicateRequestRes(parsedOutput, context);
+    case "InvalidInput":
+    case "com.amazonaws.servicediscovery#InvalidInput":
+      throw await de_InvalidInputRes(parsedOutput, context);
+    case "NamespaceAlreadyExists":
+    case "com.amazonaws.servicediscovery#NamespaceAlreadyExists":
+      throw await de_NamespaceAlreadyExistsRes(parsedOutput, context);
+    case "ResourceLimitExceeded":
+    case "com.amazonaws.servicediscovery#ResourceLimitExceeded":
+      throw await de_ResourceLimitExceededRes(parsedOutput, context);
+    case "TooManyTagsException":
+    case "com.amazonaws.servicediscovery#TooManyTagsException":
+      throw await de_TooManyTagsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreatePublicDnsNamespaceCommandError");
+var de_CreateServiceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateServiceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_CreateServiceResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateServiceCommand");
+var de_CreateServiceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidInput":
+    case "com.amazonaws.servicediscovery#InvalidInput":
+      throw await de_InvalidInputRes(parsedOutput, context);
+    case "NamespaceNotFound":
+    case "com.amazonaws.servicediscovery#NamespaceNotFound":
+      throw await de_NamespaceNotFoundRes(parsedOutput, context);
+    case "ResourceLimitExceeded":
+    case "com.amazonaws.servicediscovery#ResourceLimitExceeded":
+      throw await de_ResourceLimitExceededRes(parsedOutput, context);
+    case "ServiceAlreadyExists":
+    case "com.amazonaws.servicediscovery#ServiceAlreadyExists":
+      throw await de_ServiceAlreadyExistsRes(parsedOutput, context);
+    case "TooManyTagsException":
+    case "com.amazonaws.servicediscovery#TooManyTagsException":
+      throw await de_TooManyTagsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateServiceCommandError");
+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 "DuplicateRequest":
+    case "com.amazonaws.servicediscovery#DuplicateRequest":
+      throw await de_DuplicateRequestRes(parsedOutput, context);
+    case "InvalidInput":
+    case "com.amazonaws.servicediscovery#InvalidInput":
+      throw await de_InvalidInputRes(parsedOutput, context);
+    case "NamespaceNotFound":
+    case "com.amazonaws.servicediscovery#NamespaceNotFound":
+      throw await de_NamespaceNotFoundRes(parsedOutput, context);
+    case "ResourceInUse":
+    case "com.amazonaws.servicediscovery#ResourceInUse":
+      throw await de_ResourceInUseRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteNamespaceCommandError");
+var de_DeleteServiceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteServiceCommandError(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_DeleteServiceCommand");
+var de_DeleteServiceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidInput":
+    case "com.amazonaws.servicediscovery#InvalidInput":
+      throw await de_InvalidInputRes(parsedOutput, context);
+    case "ResourceInUse":
+    case "com.amazonaws.servicediscovery#ResourceInUse":
+      throw await de_ResourceInUseRes(parsedOutput, context);
+    case "ServiceNotFound":
+    case "com.amazonaws.servicediscovery#ServiceNotFound":
+      throw await de_ServiceNotFoundRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteServiceCommandError");
+var de_DeregisterInstanceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeregisterInstanceCommandError(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_DeregisterInstanceCommand");
+var de_DeregisterInstanceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DuplicateRequest":
+    case "com.amazonaws.servicediscovery#DuplicateRequest":
+      throw await de_DuplicateRequestRes(parsedOutput, context);
+    case "InstanceNotFound":
+    case "com.amazonaws.servicediscovery#InstanceNotFound":
+      throw await de_InstanceNotFoundRes(parsedOutput, context);
+    case "InvalidInput":
+    case "com.amazonaws.servicediscovery#InvalidInput":
+      throw await de_InvalidInputRes(parsedOutput, context);
+    case "ResourceInUse":
+    case "com.amazonaws.servicediscovery#ResourceInUse":
+      throw await de_ResourceInUseRes(parsedOutput, context);
+    case "ServiceNotFound":
+    case "com.amazonaws.servicediscovery#ServiceNotFound":
+      throw await de_ServiceNotFoundRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeregisterInstanceCommandError");
+var de_DiscoverInstancesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DiscoverInstancesCommandError(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_DiscoverInstancesCommand");
+var de_DiscoverInstancesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidInput":
+    case "com.amazonaws.servicediscovery#InvalidInput":
+      throw await de_InvalidInputRes(parsedOutput, context);
+    case "NamespaceNotFound":
+    case "com.amazonaws.servicediscovery#NamespaceNotFound":
+      throw await de_NamespaceNotFoundRes(parsedOutput, context);
+    case "RequestLimitExceeded":
+    case "com.amazonaws.servicediscovery#RequestLimitExceeded":
+      throw await de_RequestLimitExceededRes(parsedOutput, context);
+    case "ServiceNotFound":
+    case "com.amazonaws.servicediscovery#ServiceNotFound":
+      throw await de_ServiceNotFoundRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DiscoverInstancesCommandError");
+var de_DiscoverInstancesRevisionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DiscoverInstancesRevisionCommandError(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_DiscoverInstancesRevisionCommand");
+var de_DiscoverInstancesRevisionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidInput":
+    case "com.amazonaws.servicediscovery#InvalidInput":
+      throw await de_InvalidInputRes(parsedOutput, context);
+    case "NamespaceNotFound":
+    case "com.amazonaws.servicediscovery#NamespaceNotFound":
+      throw await de_NamespaceNotFoundRes(parsedOutput, context);
+    case "RequestLimitExceeded":
+    case "com.amazonaws.servicediscovery#RequestLimitExceeded":
+      throw await de_RequestLimitExceededRes(parsedOutput, context);
+    case "ServiceNotFound":
+    case "com.amazonaws.servicediscovery#ServiceNotFound":
+      throw await de_ServiceNotFoundRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DiscoverInstancesRevisionCommandError");
+var de_GetInstanceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetInstanceCommandError(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_GetInstanceCommand");
+var de_GetInstanceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InstanceNotFound":
+    case "com.amazonaws.servicediscovery#InstanceNotFound":
+      throw await de_InstanceNotFoundRes(parsedOutput, context);
+    case "InvalidInput":
+    case "com.amazonaws.servicediscovery#InvalidInput":
+      throw await de_InvalidInputRes(parsedOutput, context);
+    case "ServiceNotFound":
+    case "com.amazonaws.servicediscovery#ServiceNotFound":
+      throw await de_ServiceNotFoundRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetInstanceCommandError");
+var de_GetInstancesHealthStatusCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetInstancesHealthStatusCommandError(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_GetInstancesHealthStatusCommand");
+var de_GetInstancesHealthStatusCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InstanceNotFound":
+    case "com.amazonaws.servicediscovery#InstanceNotFound":
+      throw await de_InstanceNotFoundRes(parsedOutput, context);
+    case "InvalidInput":
+    case "com.amazonaws.servicediscovery#InvalidInput":
+      throw await de_InvalidInputRes(parsedOutput, context);
+    case "ServiceNotFound":
+    case "com.amazonaws.servicediscovery#ServiceNotFound":
+      throw await de_ServiceNotFoundRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetInstancesHealthStatusCommandError");
+var de_GetNamespaceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetNamespaceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_GetNamespaceResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetNamespaceCommand");
+var de_GetNamespaceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidInput":
+    case "com.amazonaws.servicediscovery#InvalidInput":
+      throw await de_InvalidInputRes(parsedOutput, context);
+    case "NamespaceNotFound":
+    case "com.amazonaws.servicediscovery#NamespaceNotFound":
+      throw await de_NamespaceNotFoundRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetNamespaceCommandError");
+var de_GetOperationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetOperationCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_GetOperationResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetOperationCommand");
+var de_GetOperationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidInput":
+    case "com.amazonaws.servicediscovery#InvalidInput":
+      throw await de_InvalidInputRes(parsedOutput, context);
+    case "OperationNotFound":
+    case "com.amazonaws.servicediscovery#OperationNotFound":
+      throw await de_OperationNotFoundRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetOperationCommandError");
+var de_GetServiceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetServiceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_GetServiceResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetServiceCommand");
+var de_GetServiceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidInput":
+    case "com.amazonaws.servicediscovery#InvalidInput":
+      throw await de_InvalidInputRes(parsedOutput, context);
+    case "ServiceNotFound":
+    case "com.amazonaws.servicediscovery#ServiceNotFound":
+      throw await de_ServiceNotFoundRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetServiceCommandError");
+var de_ListInstancesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListInstancesCommandError(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_ListInstancesCommand");
+var de_ListInstancesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidInput":
+    case "com.amazonaws.servicediscovery#InvalidInput":
+      throw await de_InvalidInputRes(parsedOutput, context);
+    case "ServiceNotFound":
+    case "com.amazonaws.servicediscovery#ServiceNotFound":
+      throw await de_ServiceNotFoundRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListInstancesCommandError");
+var de_ListNamespacesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListNamespacesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListNamespacesResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListNamespacesCommand");
+var de_ListNamespacesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidInput":
+    case "com.amazonaws.servicediscovery#InvalidInput":
+      throw await de_InvalidInputRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListNamespacesCommandError");
+var de_ListOperationsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListOperationsCommandError(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_ListOperationsCommand");
+var de_ListOperationsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidInput":
+    case "com.amazonaws.servicediscovery#InvalidInput":
+      throw await de_InvalidInputRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListOperationsCommandError");
+var de_ListServicesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListServicesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListServicesResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListServicesCommand");
+var de_ListServicesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidInput":
+    case "com.amazonaws.servicediscovery#InvalidInput":
+      throw await de_InvalidInputRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListServicesCommandError");
+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 "InvalidInput":
+    case "com.amazonaws.servicediscovery#InvalidInput":
+      throw await de_InvalidInputRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.servicediscovery#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListTagsForResourceCommandError");
+var de_RegisterInstanceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_RegisterInstanceCommandError(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_RegisterInstanceCommand");
+var de_RegisterInstanceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DuplicateRequest":
+    case "com.amazonaws.servicediscovery#DuplicateRequest":
+      throw await de_DuplicateRequestRes(parsedOutput, context);
+    case "InvalidInput":
+    case "com.amazonaws.servicediscovery#InvalidInput":
+      throw await de_InvalidInputRes(parsedOutput, context);
+    case "ResourceInUse":
+    case "com.amazonaws.servicediscovery#ResourceInUse":
+      throw await de_ResourceInUseRes(parsedOutput, context);
+    case "ResourceLimitExceeded":
+    case "com.amazonaws.servicediscovery#ResourceLimitExceeded":
+      throw await de_ResourceLimitExceededRes(parsedOutput, context);
+    case "ServiceNotFound":
+    case "com.amazonaws.servicediscovery#ServiceNotFound":
+      throw await de_ServiceNotFoundRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_RegisterInstanceCommandError");
+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 "InvalidInput":
+    case "com.amazonaws.servicediscovery#InvalidInput":
+      throw await de_InvalidInputRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.servicediscovery#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "TooManyTagsException":
+    case "com.amazonaws.servicediscovery#TooManyTagsException":
+      throw await de_TooManyTagsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_TagResourceCommandError");
+var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UntagResourceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UntagResourceCommand");
+var de_UntagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidInput":
+    case "com.amazonaws.servicediscovery#InvalidInput":
+      throw await de_InvalidInputRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.servicediscovery#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UntagResourceCommandError");
+var de_UpdateHttpNamespaceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateHttpNamespaceCommandError(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_UpdateHttpNamespaceCommand");
+var de_UpdateHttpNamespaceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DuplicateRequest":
+    case "com.amazonaws.servicediscovery#DuplicateRequest":
+      throw await de_DuplicateRequestRes(parsedOutput, context);
+    case "InvalidInput":
+    case "com.amazonaws.servicediscovery#InvalidInput":
+      throw await de_InvalidInputRes(parsedOutput, context);
+    case "NamespaceNotFound":
+    case "com.amazonaws.servicediscovery#NamespaceNotFound":
+      throw await de_NamespaceNotFoundRes(parsedOutput, context);
+    case "ResourceInUse":
+    case "com.amazonaws.servicediscovery#ResourceInUse":
+      throw await de_ResourceInUseRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateHttpNamespaceCommandError");
+var de_UpdateInstanceCustomHealthStatusCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateInstanceCustomHealthStatusCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_UpdateInstanceCustomHealthStatusCommand");
+var de_UpdateInstanceCustomHealthStatusCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "CustomHealthNotFound":
+    case "com.amazonaws.servicediscovery#CustomHealthNotFound":
+      throw await de_CustomHealthNotFoundRes(parsedOutput, context);
+    case "InstanceNotFound":
+    case "com.amazonaws.servicediscovery#InstanceNotFound":
+      throw await de_InstanceNotFoundRes(parsedOutput, context);
+    case "InvalidInput":
+    case "com.amazonaws.servicediscovery#InvalidInput":
+      throw await de_InvalidInputRes(parsedOutput, context);
+    case "ServiceNotFound":
+    case "com.amazonaws.servicediscovery#ServiceNotFound":
+      throw await de_ServiceNotFoundRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateInstanceCustomHealthStatusCommandError");
+var de_UpdatePrivateDnsNamespaceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdatePrivateDnsNamespaceCommandError(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_UpdatePrivateDnsNamespaceCommand");
+var de_UpdatePrivateDnsNamespaceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DuplicateRequest":
+    case "com.amazonaws.servicediscovery#DuplicateRequest":
+      throw await de_DuplicateRequestRes(parsedOutput, context);
+    case "InvalidInput":
+    case "com.amazonaws.servicediscovery#InvalidInput":
+      throw await de_InvalidInputRes(parsedOutput, context);
+    case "NamespaceNotFound":
+    case "com.amazonaws.servicediscovery#NamespaceNotFound":
+      throw await de_NamespaceNotFoundRes(parsedOutput, context);
+    case "ResourceInUse":
+    case "com.amazonaws.servicediscovery#ResourceInUse":
+      throw await de_ResourceInUseRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdatePrivateDnsNamespaceCommandError");
+var de_UpdatePublicDnsNamespaceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdatePublicDnsNamespaceCommandError(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_UpdatePublicDnsNamespaceCommand");
+var de_UpdatePublicDnsNamespaceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DuplicateRequest":
+    case "com.amazonaws.servicediscovery#DuplicateRequest":
+      throw await de_DuplicateRequestRes(parsedOutput, context);
+    case "InvalidInput":
+    case "com.amazonaws.servicediscovery#InvalidInput":
+      throw await de_InvalidInputRes(parsedOutput, context);
+    case "NamespaceNotFound":
+    case "com.amazonaws.servicediscovery#NamespaceNotFound":
+      throw await de_NamespaceNotFoundRes(parsedOutput, context);
+    case "ResourceInUse":
+    case "com.amazonaws.servicediscovery#ResourceInUse":
+      throw await de_ResourceInUseRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdatePublicDnsNamespaceCommandError");
+var de_UpdateServiceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateServiceCommandError(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_UpdateServiceCommand");
+var de_UpdateServiceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DuplicateRequest":
+    case "com.amazonaws.servicediscovery#DuplicateRequest":
+      throw await de_DuplicateRequestRes(parsedOutput, context);
+    case "InvalidInput":
+    case "com.amazonaws.servicediscovery#InvalidInput":
+      throw await de_InvalidInputRes(parsedOutput, context);
+    case "ServiceNotFound":
+    case "com.amazonaws.servicediscovery#ServiceNotFound":
+      throw await de_ServiceNotFoundRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateServiceCommandError");
+var de_CustomHealthNotFoundRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new CustomHealthNotFound({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_CustomHealthNotFoundRes");
+var de_DuplicateRequestRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new DuplicateRequest({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_DuplicateRequestRes");
+var de_InstanceNotFoundRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InstanceNotFound({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InstanceNotFoundRes");
+var de_InvalidInputRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidInput({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidInputRes");
+var de_NamespaceAlreadyExistsRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new NamespaceAlreadyExists({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_NamespaceAlreadyExistsRes");
+var de_NamespaceNotFoundRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new NamespaceNotFound({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_NamespaceNotFoundRes");
+var de_OperationNotFoundRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new OperationNotFound({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_OperationNotFoundRes");
+var de_RequestLimitExceededRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new RequestLimitExceeded({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_RequestLimitExceededRes");
+var de_ResourceInUseRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ResourceInUse({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ResourceInUseRes");
+var de_ResourceLimitExceededRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ResourceLimitExceeded({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ResourceLimitExceededRes");
+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_ServiceAlreadyExistsRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ServiceAlreadyExists({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ServiceAlreadyExistsRes");
+var de_ServiceNotFoundRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ServiceNotFound({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ServiceNotFoundRes");
+var de_TooManyTagsExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new TooManyTagsException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_TooManyTagsExceptionRes");
+var se_CreateHttpNamespaceRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    CreatorRequestId: [true, (_) => _ ?? (0, import_uuid.v4)()],
+    Description: [],
+    Name: [],
+    Tags: import_smithy_client._json
+  });
+}, "se_CreateHttpNamespaceRequest");
+var se_CreatePrivateDnsNamespaceRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    CreatorRequestId: [true, (_) => _ ?? (0, import_uuid.v4)()],
+    Description: [],
+    Name: [],
+    Properties: import_smithy_client._json,
+    Tags: import_smithy_client._json,
+    Vpc: []
+  });
+}, "se_CreatePrivateDnsNamespaceRequest");
+var se_CreatePublicDnsNamespaceRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    CreatorRequestId: [true, (_) => _ ?? (0, import_uuid.v4)()],
+    Description: [],
+    Name: [],
+    Properties: import_smithy_client._json,
+    Tags: import_smithy_client._json
+  });
+}, "se_CreatePublicDnsNamespaceRequest");
+var se_CreateServiceRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    CreatorRequestId: [true, (_) => _ ?? (0, import_uuid.v4)()],
+    Description: [],
+    DnsConfig: import_smithy_client._json,
+    HealthCheckConfig: import_smithy_client._json,
+    HealthCheckCustomConfig: import_smithy_client._json,
+    Name: [],
+    NamespaceId: [],
+    Tags: import_smithy_client._json,
+    Type: []
+  });
+}, "se_CreateServiceRequest");
+var se_RegisterInstanceRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Attributes: import_smithy_client._json,
+    CreatorRequestId: [true, (_) => _ ?? (0, import_uuid.v4)()],
+    InstanceId: [],
+    ServiceId: []
+  });
+}, "se_RegisterInstanceRequest");
+var se_UpdateHttpNamespaceRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Id: [],
+    Namespace: import_smithy_client._json,
+    UpdaterRequestId: [true, (_) => _ ?? (0, import_uuid.v4)()]
+  });
+}, "se_UpdateHttpNamespaceRequest");
+var se_UpdatePrivateDnsNamespaceRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Id: [],
+    Namespace: import_smithy_client._json,
+    UpdaterRequestId: [true, (_) => _ ?? (0, import_uuid.v4)()]
+  });
+}, "se_UpdatePrivateDnsNamespaceRequest");
+var se_UpdatePublicDnsNamespaceRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Id: [],
+    Namespace: import_smithy_client._json,
+    UpdaterRequestId: [true, (_) => _ ?? (0, import_uuid.v4)()]
+  });
+}, "se_UpdatePublicDnsNamespaceRequest");
+var de_CreateServiceResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Service: (_) => de_Service(_, context)
+  });
+}, "de_CreateServiceResponse");
+var de_GetNamespaceResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Namespace: (_) => de_Namespace(_, context)
+  });
+}, "de_GetNamespaceResponse");
+var de_GetOperationResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Operation: (_) => de_Operation(_, context)
+  });
+}, "de_GetOperationResponse");
+var de_GetServiceResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Service: (_) => de_Service(_, context)
+  });
+}, "de_GetServiceResponse");
+var de_ListNamespacesResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Namespaces: (_) => de_NamespaceSummariesList(_, context),
+    NextToken: import_smithy_client.expectString
+  });
+}, "de_ListNamespacesResponse");
+var de_ListServicesResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    NextToken: import_smithy_client.expectString,
+    Services: (_) => de_ServiceSummariesList(_, context)
+  });
+}, "de_ListServicesResponse");
+var de_Namespace = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Arn: import_smithy_client.expectString,
+    CreateDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    CreatorRequestId: import_smithy_client.expectString,
+    Description: import_smithy_client.expectString,
+    Id: import_smithy_client.expectString,
+    Name: import_smithy_client.expectString,
+    Properties: import_smithy_client._json,
+    ServiceCount: import_smithy_client.expectInt32,
+    Type: import_smithy_client.expectString
+  });
+}, "de_Namespace");
+var de_NamespaceSummariesList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_NamespaceSummary(entry, context);
+  });
+  return retVal;
+}, "de_NamespaceSummariesList");
+var de_NamespaceSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Arn: import_smithy_client.expectString,
+    CreateDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Description: import_smithy_client.expectString,
+    Id: import_smithy_client.expectString,
+    Name: import_smithy_client.expectString,
+    Properties: import_smithy_client._json,
+    ServiceCount: import_smithy_client.expectInt32,
+    Type: import_smithy_client.expectString
+  });
+}, "de_NamespaceSummary");
+var de_Operation = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    CreateDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    ErrorCode: import_smithy_client.expectString,
+    ErrorMessage: import_smithy_client.expectString,
+    Id: import_smithy_client.expectString,
+    Status: import_smithy_client.expectString,
+    Targets: import_smithy_client._json,
+    Type: import_smithy_client.expectString,
+    UpdateDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_)))
+  });
+}, "de_Operation");
+var de_Service = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Arn: import_smithy_client.expectString,
+    CreateDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    CreatorRequestId: import_smithy_client.expectString,
+    Description: import_smithy_client.expectString,
+    DnsConfig: import_smithy_client._json,
+    HealthCheckConfig: import_smithy_client._json,
+    HealthCheckCustomConfig: import_smithy_client._json,
+    Id: import_smithy_client.expectString,
+    InstanceCount: import_smithy_client.expectInt32,
+    Name: import_smithy_client.expectString,
+    NamespaceId: import_smithy_client.expectString,
+    Type: import_smithy_client.expectString
+  });
+}, "de_Service");
+var de_ServiceSummariesList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_ServiceSummary(entry, context);
+  });
+  return retVal;
+}, "de_ServiceSummariesList");
+var de_ServiceSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Arn: import_smithy_client.expectString,
+    CreateDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Description: import_smithy_client.expectString,
+    DnsConfig: import_smithy_client._json,
+    HealthCheckConfig: import_smithy_client._json,
+    HealthCheckCustomConfig: import_smithy_client._json,
+    Id: import_smithy_client.expectString,
+    InstanceCount: import_smithy_client.expectInt32,
+    Name: import_smithy_client.expectString,
+    Type: import_smithy_client.expectString
+  });
+}, "de_ServiceSummary");
+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)(ServiceDiscoveryServiceException);
+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": `Route53AutoNaming_v20170314.${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/CreateHttpNamespaceCommand.ts
+var _CreateHttpNamespaceCommand = class _CreateHttpNamespaceCommand 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("Route53AutoNaming_v20170314", "CreateHttpNamespace", {}).n("ServiceDiscoveryClient", "CreateHttpNamespaceCommand").f(void 0, void 0).ser(se_CreateHttpNamespaceCommand).de(de_CreateHttpNamespaceCommand).build() {
+};
+__name(_CreateHttpNamespaceCommand, "CreateHttpNamespaceCommand");
+var CreateHttpNamespaceCommand = _CreateHttpNamespaceCommand;
+
+// src/commands/CreatePrivateDnsNamespaceCommand.ts
+
+
+
+
+var _CreatePrivateDnsNamespaceCommand = class _CreatePrivateDnsNamespaceCommand 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("Route53AutoNaming_v20170314", "CreatePrivateDnsNamespace", {}).n("ServiceDiscoveryClient", "CreatePrivateDnsNamespaceCommand").f(void 0, void 0).ser(se_CreatePrivateDnsNamespaceCommand).de(de_CreatePrivateDnsNamespaceCommand).build() {
+};
+__name(_CreatePrivateDnsNamespaceCommand, "CreatePrivateDnsNamespaceCommand");
+var CreatePrivateDnsNamespaceCommand = _CreatePrivateDnsNamespaceCommand;
+
+// src/commands/CreatePublicDnsNamespaceCommand.ts
+
+
+
+
+var _CreatePublicDnsNamespaceCommand = class _CreatePublicDnsNamespaceCommand 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("Route53AutoNaming_v20170314", "CreatePublicDnsNamespace", {}).n("ServiceDiscoveryClient", "CreatePublicDnsNamespaceCommand").f(void 0, void 0).ser(se_CreatePublicDnsNamespaceCommand).de(de_CreatePublicDnsNamespaceCommand).build() {
+};
+__name(_CreatePublicDnsNamespaceCommand, "CreatePublicDnsNamespaceCommand");
+var CreatePublicDnsNamespaceCommand = _CreatePublicDnsNamespaceCommand;
+
+// src/commands/CreateServiceCommand.ts
+
+
+
+
+var _CreateServiceCommand = class _CreateServiceCommand 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("Route53AutoNaming_v20170314", "CreateService", {}).n("ServiceDiscoveryClient", "CreateServiceCommand").f(void 0, void 0).ser(se_CreateServiceCommand).de(de_CreateServiceCommand).build() {
+};
+__name(_CreateServiceCommand, "CreateServiceCommand");
+var CreateServiceCommand = _CreateServiceCommand;
+
+// 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("Route53AutoNaming_v20170314", "DeleteNamespace", {}).n("ServiceDiscoveryClient", "DeleteNamespaceCommand").f(void 0, void 0).ser(se_DeleteNamespaceCommand).de(de_DeleteNamespaceCommand).build() {
+};
+__name(_DeleteNamespaceCommand, "DeleteNamespaceCommand");
+var DeleteNamespaceCommand = _DeleteNamespaceCommand;
+
+// src/commands/DeleteServiceCommand.ts
+
+
+
+
+var _DeleteServiceCommand = class _DeleteServiceCommand 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("Route53AutoNaming_v20170314", "DeleteService", {}).n("ServiceDiscoveryClient", "DeleteServiceCommand").f(void 0, void 0).ser(se_DeleteServiceCommand).de(de_DeleteServiceCommand).build() {
+};
+__name(_DeleteServiceCommand, "DeleteServiceCommand");
+var DeleteServiceCommand = _DeleteServiceCommand;
+
+// src/commands/DeregisterInstanceCommand.ts
+
+
+
+
+var _DeregisterInstanceCommand = class _DeregisterInstanceCommand 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("Route53AutoNaming_v20170314", "DeregisterInstance", {}).n("ServiceDiscoveryClient", "DeregisterInstanceCommand").f(void 0, void 0).ser(se_DeregisterInstanceCommand).de(de_DeregisterInstanceCommand).build() {
+};
+__name(_DeregisterInstanceCommand, "DeregisterInstanceCommand");
+var DeregisterInstanceCommand = _DeregisterInstanceCommand;
+
+// src/commands/DiscoverInstancesCommand.ts
+
+
+
+
+var _DiscoverInstancesCommand = class _DiscoverInstancesCommand 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("Route53AutoNaming_v20170314", "DiscoverInstances", {}).n("ServiceDiscoveryClient", "DiscoverInstancesCommand").f(void 0, void 0).ser(se_DiscoverInstancesCommand).de(de_DiscoverInstancesCommand).build() {
+};
+__name(_DiscoverInstancesCommand, "DiscoverInstancesCommand");
+var DiscoverInstancesCommand = _DiscoverInstancesCommand;
+
+// src/commands/DiscoverInstancesRevisionCommand.ts
+
+
+
+
+var _DiscoverInstancesRevisionCommand = class _DiscoverInstancesRevisionCommand 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("Route53AutoNaming_v20170314", "DiscoverInstancesRevision", {}).n("ServiceDiscoveryClient", "DiscoverInstancesRevisionCommand").f(void 0, void 0).ser(se_DiscoverInstancesRevisionCommand).de(de_DiscoverInstancesRevisionCommand).build() {
+};
+__name(_DiscoverInstancesRevisionCommand, "DiscoverInstancesRevisionCommand");
+var DiscoverInstancesRevisionCommand = _DiscoverInstancesRevisionCommand;
+
+// src/commands/GetInstanceCommand.ts
+
+
+
+
+var _GetInstanceCommand = class _GetInstanceCommand 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("Route53AutoNaming_v20170314", "GetInstance", {}).n("ServiceDiscoveryClient", "GetInstanceCommand").f(void 0, void 0).ser(se_GetInstanceCommand).de(de_GetInstanceCommand).build() {
+};
+__name(_GetInstanceCommand, "GetInstanceCommand");
+var GetInstanceCommand = _GetInstanceCommand;
+
+// src/commands/GetInstancesHealthStatusCommand.ts
+
+
+
+
+var _GetInstancesHealthStatusCommand = class _GetInstancesHealthStatusCommand 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("Route53AutoNaming_v20170314", "GetInstancesHealthStatus", {}).n("ServiceDiscoveryClient", "GetInstancesHealthStatusCommand").f(void 0, void 0).ser(se_GetInstancesHealthStatusCommand).de(de_GetInstancesHealthStatusCommand).build() {
+};
+__name(_GetInstancesHealthStatusCommand, "GetInstancesHealthStatusCommand");
+var GetInstancesHealthStatusCommand = _GetInstancesHealthStatusCommand;
+
+// src/commands/GetNamespaceCommand.ts
+
+
+
+
+var _GetNamespaceCommand = class _GetNamespaceCommand 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("Route53AutoNaming_v20170314", "GetNamespace", {}).n("ServiceDiscoveryClient", "GetNamespaceCommand").f(void 0, void 0).ser(se_GetNamespaceCommand).de(de_GetNamespaceCommand).build() {
+};
+__name(_GetNamespaceCommand, "GetNamespaceCommand");
+var GetNamespaceCommand = _GetNamespaceCommand;
+
+// src/commands/GetOperationCommand.ts
+
+
+
+
+var _GetOperationCommand = class _GetOperationCommand 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("Route53AutoNaming_v20170314", "GetOperation", {}).n("ServiceDiscoveryClient", "GetOperationCommand").f(void 0, void 0).ser(se_GetOperationCommand).de(de_GetOperationCommand).build() {
+};
+__name(_GetOperationCommand, "GetOperationCommand");
+var GetOperationCommand = _GetOperationCommand;
+
+// src/commands/GetServiceCommand.ts
+
+
+
+
+var _GetServiceCommand = class _GetServiceCommand 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("Route53AutoNaming_v20170314", "GetService", {}).n("ServiceDiscoveryClient", "GetServiceCommand").f(void 0, void 0).ser(se_GetServiceCommand).de(de_GetServiceCommand).build() {
+};
+__name(_GetServiceCommand, "GetServiceCommand");
+var GetServiceCommand = _GetServiceCommand;
+
+// src/commands/ListInstancesCommand.ts
+
+
+
+
+var _ListInstancesCommand = class _ListInstancesCommand 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("Route53AutoNaming_v20170314", "ListInstances", {}).n("ServiceDiscoveryClient", "ListInstancesCommand").f(void 0, void 0).ser(se_ListInstancesCommand).de(de_ListInstancesCommand).build() {
+};
+__name(_ListInstancesCommand, "ListInstancesCommand");
+var ListInstancesCommand = _ListInstancesCommand;
+
+// src/commands/ListNamespacesCommand.ts
+
+
+
+
+var _ListNamespacesCommand = class _ListNamespacesCommand 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("Route53AutoNaming_v20170314", "ListNamespaces", {}).n("ServiceDiscoveryClient", "ListNamespacesCommand").f(void 0, void 0).ser(se_ListNamespacesCommand).de(de_ListNamespacesCommand).build() {
+};
+__name(_ListNamespacesCommand, "ListNamespacesCommand");
+var ListNamespacesCommand = _ListNamespacesCommand;
+
+// src/commands/ListOperationsCommand.ts
+
+
+
+
+var _ListOperationsCommand = class _ListOperationsCommand 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("Route53AutoNaming_v20170314", "ListOperations", {}).n("ServiceDiscoveryClient", "ListOperationsCommand").f(void 0, void 0).ser(se_ListOperationsCommand).de(de_ListOperationsCommand).build() {
+};
+__name(_ListOperationsCommand, "ListOperationsCommand");
+var ListOperationsCommand = _ListOperationsCommand;
+
+// src/commands/ListServicesCommand.ts
+
+
+
+
+var _ListServicesCommand = class _ListServicesCommand 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("Route53AutoNaming_v20170314", "ListServices", {}).n("ServiceDiscoveryClient", "ListServicesCommand").f(void 0, void 0).ser(se_ListServicesCommand).de(de_ListServicesCommand).build() {
+};
+__name(_ListServicesCommand, "ListServicesCommand");
+var ListServicesCommand = _ListServicesCommand;
+
+// 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("Route53AutoNaming_v20170314", "ListTagsForResource", {}).n("ServiceDiscoveryClient", "ListTagsForResourceCommand").f(void 0, void 0).ser(se_ListTagsForResourceCommand).de(de_ListTagsForResourceCommand).build() {
+};
+__name(_ListTagsForResourceCommand, "ListTagsForResourceCommand");
+var ListTagsForResourceCommand = _ListTagsForResourceCommand;
+
+// src/commands/RegisterInstanceCommand.ts
+
+
+
+
+var _RegisterInstanceCommand = class _RegisterInstanceCommand 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("Route53AutoNaming_v20170314", "RegisterInstance", {}).n("ServiceDiscoveryClient", "RegisterInstanceCommand").f(void 0, void 0).ser(se_RegisterInstanceCommand).de(de_RegisterInstanceCommand).build() {
+};
+__name(_RegisterInstanceCommand, "RegisterInstanceCommand");
+var RegisterInstanceCommand = _RegisterInstanceCommand;
+
+// 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("Route53AutoNaming_v20170314", "TagResource", {}).n("ServiceDiscoveryClient", "TagResourceCommand").f(void 0, void 0).ser(se_TagResourceCommand).de(de_TagResourceCommand).build() {
+};
+__name(_TagResourceCommand, "TagResourceCommand");
+var TagResourceCommand = _TagResourceCommand;
+
+// src/commands/UntagResourceCommand.ts
+
+
+
+
+var _UntagResourceCommand = class _UntagResourceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Route53AutoNaming_v20170314", "UntagResource", {}).n("ServiceDiscoveryClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
+};
+__name(_UntagResourceCommand, "UntagResourceCommand");
+var UntagResourceCommand = _UntagResourceCommand;
+
+// src/commands/UpdateHttpNamespaceCommand.ts
+
+
+
+
+var _UpdateHttpNamespaceCommand = class _UpdateHttpNamespaceCommand 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("Route53AutoNaming_v20170314", "UpdateHttpNamespace", {}).n("ServiceDiscoveryClient", "UpdateHttpNamespaceCommand").f(void 0, void 0).ser(se_UpdateHttpNamespaceCommand).de(de_UpdateHttpNamespaceCommand).build() {
+};
+__name(_UpdateHttpNamespaceCommand, "UpdateHttpNamespaceCommand");
+var UpdateHttpNamespaceCommand = _UpdateHttpNamespaceCommand;
+
+// src/commands/UpdateInstanceCustomHealthStatusCommand.ts
+
+
+
+
+var _UpdateInstanceCustomHealthStatusCommand = class _UpdateInstanceCustomHealthStatusCommand 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("Route53AutoNaming_v20170314", "UpdateInstanceCustomHealthStatus", {}).n("ServiceDiscoveryClient", "UpdateInstanceCustomHealthStatusCommand").f(void 0, void 0).ser(se_UpdateInstanceCustomHealthStatusCommand).de(de_UpdateInstanceCustomHealthStatusCommand).build() {
+};
+__name(_UpdateInstanceCustomHealthStatusCommand, "UpdateInstanceCustomHealthStatusCommand");
+var UpdateInstanceCustomHealthStatusCommand = _UpdateInstanceCustomHealthStatusCommand;
+
+// src/commands/UpdatePrivateDnsNamespaceCommand.ts
+
+
+
+
+var _UpdatePrivateDnsNamespaceCommand = class _UpdatePrivateDnsNamespaceCommand 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("Route53AutoNaming_v20170314", "UpdatePrivateDnsNamespace", {}).n("ServiceDiscoveryClient", "UpdatePrivateDnsNamespaceCommand").f(void 0, void 0).ser(se_UpdatePrivateDnsNamespaceCommand).de(de_UpdatePrivateDnsNamespaceCommand).build() {
+};
+__name(_UpdatePrivateDnsNamespaceCommand, "UpdatePrivateDnsNamespaceCommand");
+var UpdatePrivateDnsNamespaceCommand = _UpdatePrivateDnsNamespaceCommand;
+
+// src/commands/UpdatePublicDnsNamespaceCommand.ts
+
+
+
+
+var _UpdatePublicDnsNamespaceCommand = class _UpdatePublicDnsNamespaceCommand 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("Route53AutoNaming_v20170314", "UpdatePublicDnsNamespace", {}).n("ServiceDiscoveryClient", "UpdatePublicDnsNamespaceCommand").f(void 0, void 0).ser(se_UpdatePublicDnsNamespaceCommand).de(de_UpdatePublicDnsNamespaceCommand).build() {
+};
+__name(_UpdatePublicDnsNamespaceCommand, "UpdatePublicDnsNamespaceCommand");
+var UpdatePublicDnsNamespaceCommand = _UpdatePublicDnsNamespaceCommand;
+
+// src/commands/UpdateServiceCommand.ts
+
+
+
+
+var _UpdateServiceCommand = class _UpdateServiceCommand 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("Route53AutoNaming_v20170314", "UpdateService", {}).n("ServiceDiscoveryClient", "UpdateServiceCommand").f(void 0, void 0).ser(se_UpdateServiceCommand).de(de_UpdateServiceCommand).build() {
+};
+__name(_UpdateServiceCommand, "UpdateServiceCommand");
+var UpdateServiceCommand = _UpdateServiceCommand;
+
+// src/ServiceDiscovery.ts
+var commands = {
+  CreateHttpNamespaceCommand,
+  CreatePrivateDnsNamespaceCommand,
+  CreatePublicDnsNamespaceCommand,
+  CreateServiceCommand,
+  DeleteNamespaceCommand,
+  DeleteServiceCommand,
+  DeregisterInstanceCommand,
+  DiscoverInstancesCommand,
+  DiscoverInstancesRevisionCommand,
+  GetInstanceCommand,
+  GetInstancesHealthStatusCommand,
+  GetNamespaceCommand,
+  GetOperationCommand,
+  GetServiceCommand,
+  ListInstancesCommand,
+  ListNamespacesCommand,
+  ListOperationsCommand,
+  ListServicesCommand,
+  ListTagsForResourceCommand,
+  RegisterInstanceCommand,
+  TagResourceCommand,
+  UntagResourceCommand,
+  UpdateHttpNamespaceCommand,
+  UpdateInstanceCustomHealthStatusCommand,
+  UpdatePrivateDnsNamespaceCommand,
+  UpdatePublicDnsNamespaceCommand,
+  UpdateServiceCommand
+};
+var _ServiceDiscovery = class _ServiceDiscovery extends ServiceDiscoveryClient {
+};
+__name(_ServiceDiscovery, "ServiceDiscovery");
+var ServiceDiscovery = _ServiceDiscovery;
+(0, import_smithy_client.createAggregatedClient)(commands, ServiceDiscovery);
+
+// src/pagination/GetInstancesHealthStatusPaginator.ts
+var import_core = require("@smithy/core");
+var paginateGetInstancesHealthStatus = (0, import_core.createPaginator)(ServiceDiscoveryClient, GetInstancesHealthStatusCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListInstancesPaginator.ts
+
+var paginateListInstances = (0, import_core.createPaginator)(ServiceDiscoveryClient, ListInstancesCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListNamespacesPaginator.ts
+
+var paginateListNamespaces = (0, import_core.createPaginator)(ServiceDiscoveryClient, ListNamespacesCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListOperationsPaginator.ts
+
+var paginateListOperations = (0, import_core.createPaginator)(ServiceDiscoveryClient, ListOperationsCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListServicesPaginator.ts
+
+var paginateListServices = (0, import_core.createPaginator)(ServiceDiscoveryClient, ListServicesCommand, "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 = {
+  CreateHttpNamespaceCommand,
+  CreatePrivateDnsNamespaceCommand,
+  CreatePublicDnsNamespaceCommand,
+  CreateServiceCommand,
+  CustomHealthNotFound,
+  CustomHealthStatus,
+  DeleteNamespaceCommand,
+  DeleteServiceCommand,
+  DeregisterInstanceCommand,
+  DiscoverInstancesCommand,
+  DiscoverInstancesRevisionCommand,
+  DuplicateRequest,
+  FilterCondition,
+  GetInstanceCommand,
+  GetInstancesHealthStatusCommand,
+  GetNamespaceCommand,
+  GetOperationCommand,
+  GetServiceCommand,
+  HealthCheckType,
+  HealthStatus,
+  HealthStatusFilter,
+  InstanceNotFound,
+  InvalidInput,
+  ListInstancesCommand,
+  ListNamespacesCommand,
+  ListOperationsCommand,
+  ListServicesCommand,
+  ListTagsForResourceCommand,
+  NamespaceAlreadyExists,
+  NamespaceFilterName,
+  NamespaceNotFound,
+  NamespaceType,
+  OperationFilterName,
+  OperationNotFound,
+  OperationStatus,
+  OperationTargetType,
+  OperationType,
+  RecordType,
+  RegisterInstanceCommand,
+  RequestLimitExceeded,
+  ResourceInUse,
+  ResourceLimitExceeded,
+  ResourceNotFoundException,
+  RoutingPolicy,
+  ServiceAlreadyExists,
+  ServiceDiscovery,
+  ServiceDiscoveryClient,
+  ServiceDiscoveryServiceException,
+  ServiceFilterName,
+  ServiceNotFound,
+  ServiceType,
+  ServiceTypeOption,
+  TagResourceCommand,
+  TooManyTagsException,
+  UntagResourceCommand,
+  UpdateHttpNamespaceCommand,
+  UpdateInstanceCustomHealthStatusCommand,
+  UpdatePrivateDnsNamespaceCommand,
+  UpdatePublicDnsNamespaceCommand,
+  UpdateServiceCommand,
+  __Client,
+  paginateGetInstancesHealthStatus,
+  paginateListInstances,
+  paginateListNamespaces,
+  paginateListOperations,
+  paginateListServices
+});