@aws-sdk/client-managedblockchain 3.490.0 → 3.496.0

package/dist-cjs/index.js

@@ -1,12 +1,3063 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ManagedBlockchainServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./ManagedBlockchainClient"), exports);
-tslib_1.__exportStar(require("./ManagedBlockchain"), 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 ManagedBlockchainServiceException_1 = require("./models/ManagedBlockchainServiceException");
-Object.defineProperty(exports, "ManagedBlockchainServiceException", { enumerable: true, get: function () { return ManagedBlockchainServiceException_1.ManagedBlockchainServiceException; } });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AccessDeniedException: () => AccessDeniedException,
+  AccessorNetworkType: () => AccessorNetworkType,
+  AccessorStatus: () => AccessorStatus,
+  AccessorType: () => AccessorType,
+  CreateAccessorCommand: () => CreateAccessorCommand,
+  CreateMemberCommand: () => CreateMemberCommand,
+  CreateMemberInputFilterSensitiveLog: () => CreateMemberInputFilterSensitiveLog,
+  CreateNetworkCommand: () => CreateNetworkCommand,
+  CreateNetworkInputFilterSensitiveLog: () => CreateNetworkInputFilterSensitiveLog,
+  CreateNodeCommand: () => CreateNodeCommand,
+  CreateProposalCommand: () => CreateProposalCommand,
+  DeleteAccessorCommand: () => DeleteAccessorCommand,
+  DeleteMemberCommand: () => DeleteMemberCommand,
+  DeleteNodeCommand: () => DeleteNodeCommand,
+  Edition: () => Edition,
+  Framework: () => Framework,
+  GetAccessorCommand: () => GetAccessorCommand,
+  GetMemberCommand: () => GetMemberCommand,
+  GetNetworkCommand: () => GetNetworkCommand,
+  GetNodeCommand: () => GetNodeCommand,
+  GetProposalCommand: () => GetProposalCommand,
+  IllegalActionException: () => IllegalActionException,
+  InternalServiceErrorException: () => InternalServiceErrorException,
+  InvalidRequestException: () => InvalidRequestException,
+  InvitationStatus: () => InvitationStatus,
+  ListAccessorsCommand: () => ListAccessorsCommand,
+  ListInvitationsCommand: () => ListInvitationsCommand,
+  ListMembersCommand: () => ListMembersCommand,
+  ListNetworksCommand: () => ListNetworksCommand,
+  ListNodesCommand: () => ListNodesCommand,
+  ListProposalVotesCommand: () => ListProposalVotesCommand,
+  ListProposalsCommand: () => ListProposalsCommand,
+  ListTagsForResourceCommand: () => ListTagsForResourceCommand,
+  ManagedBlockchain: () => ManagedBlockchain,
+  ManagedBlockchainClient: () => ManagedBlockchainClient,
+  ManagedBlockchainServiceException: () => ManagedBlockchainServiceException,
+  MemberConfigurationFilterSensitiveLog: () => MemberConfigurationFilterSensitiveLog,
+  MemberFabricConfigurationFilterSensitiveLog: () => MemberFabricConfigurationFilterSensitiveLog,
+  MemberFrameworkConfigurationFilterSensitiveLog: () => MemberFrameworkConfigurationFilterSensitiveLog,
+  MemberStatus: () => MemberStatus,
+  NetworkStatus: () => NetworkStatus,
+  NodeStatus: () => NodeStatus,
+  ProposalStatus: () => ProposalStatus,
+  RejectInvitationCommand: () => RejectInvitationCommand,
+  ResourceAlreadyExistsException: () => ResourceAlreadyExistsException,
+  ResourceLimitExceededException: () => ResourceLimitExceededException,
+  ResourceNotFoundException: () => ResourceNotFoundException,
+  ResourceNotReadyException: () => ResourceNotReadyException,
+  StateDBType: () => StateDBType,
+  TagResourceCommand: () => TagResourceCommand,
+  ThresholdComparator: () => ThresholdComparator,
+  ThrottlingException: () => ThrottlingException,
+  TooManyTagsException: () => TooManyTagsException,
+  UntagResourceCommand: () => UntagResourceCommand,
+  UpdateMemberCommand: () => UpdateMemberCommand,
+  UpdateNodeCommand: () => UpdateNodeCommand,
+  VoteOnProposalCommand: () => VoteOnProposalCommand,
+  VoteValue: () => VoteValue,
+  __Client: () => import_smithy_client.Client,
+  paginateListAccessors: () => paginateListAccessors,
+  paginateListInvitations: () => paginateListInvitations,
+  paginateListMembers: () => paginateListMembers,
+  paginateListNetworks: () => paginateListNetworks,
+  paginateListNodes: () => paginateListNodes,
+  paginateListProposalVotes: () => paginateListProposalVotes,
+  paginateListProposals: () => paginateListProposals
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/ManagedBlockchainClient.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: "managedblockchain"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/ManagedBlockchainClient.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/ManagedBlockchainClient.ts
+var _ManagedBlockchainClient = class _ManagedBlockchainClient 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(_ManagedBlockchainClient, "ManagedBlockchainClient");
+var ManagedBlockchainClient = _ManagedBlockchainClient;
+
+// src/ManagedBlockchain.ts
+
+
+// src/commands/CreateAccessorCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/protocols/Aws_restJson1.ts
+var import_core = require("@smithy/core");
+
+var import_uuid = require("uuid");
+
+// src/models/ManagedBlockchainServiceException.ts
+
+var _ManagedBlockchainServiceException = class _ManagedBlockchainServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _ManagedBlockchainServiceException.prototype);
+  }
+};
+__name(_ManagedBlockchainServiceException, "ManagedBlockchainServiceException");
+var ManagedBlockchainServiceException = _ManagedBlockchainServiceException;
+
+// src/models/models_0.ts
+
+var _AccessDeniedException = class _AccessDeniedException extends ManagedBlockchainServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "AccessDeniedException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "AccessDeniedException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _AccessDeniedException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_AccessDeniedException, "AccessDeniedException");
+var AccessDeniedException = _AccessDeniedException;
+var AccessorNetworkType = {
+  ETHEREUM_GOERLI: "ETHEREUM_GOERLI",
+  ETHEREUM_MAINNET: "ETHEREUM_MAINNET",
+  ETHEREUM_MAINNET_AND_GOERLI: "ETHEREUM_MAINNET_AND_GOERLI",
+  POLYGON_MAINNET: "POLYGON_MAINNET",
+  POLYGON_MUMBAI: "POLYGON_MUMBAI"
+};
+var AccessorStatus = {
+  AVAILABLE: "AVAILABLE",
+  DELETED: "DELETED",
+  PENDING_DELETION: "PENDING_DELETION"
+};
+var AccessorType = {
+  BILLING_TOKEN: "BILLING_TOKEN"
+};
+var ThresholdComparator = {
+  GREATER_THAN: "GREATER_THAN",
+  GREATER_THAN_OR_EQUAL_TO: "GREATER_THAN_OR_EQUAL_TO"
+};
+var _InternalServiceErrorException = class _InternalServiceErrorException extends ManagedBlockchainServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InternalServiceErrorException",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "InternalServiceErrorException";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _InternalServiceErrorException.prototype);
+  }
+};
+__name(_InternalServiceErrorException, "InternalServiceErrorException");
+var InternalServiceErrorException = _InternalServiceErrorException;
+var _InvalidRequestException = class _InvalidRequestException extends ManagedBlockchainServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidRequestException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidRequestException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidRequestException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_InvalidRequestException, "InvalidRequestException");
+var InvalidRequestException = _InvalidRequestException;
+var _ResourceAlreadyExistsException = class _ResourceAlreadyExistsException extends ManagedBlockchainServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ResourceAlreadyExistsException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ResourceAlreadyExistsException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ResourceAlreadyExistsException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_ResourceAlreadyExistsException, "ResourceAlreadyExistsException");
+var ResourceAlreadyExistsException = _ResourceAlreadyExistsException;
+var _ResourceLimitExceededException = class _ResourceLimitExceededException extends ManagedBlockchainServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ResourceLimitExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ResourceLimitExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ResourceLimitExceededException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_ResourceLimitExceededException, "ResourceLimitExceededException");
+var ResourceLimitExceededException = _ResourceLimitExceededException;
+var _ThrottlingException = class _ThrottlingException extends ManagedBlockchainServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ThrottlingException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ThrottlingException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ThrottlingException.prototype);
+  }
+};
+__name(_ThrottlingException, "ThrottlingException");
+var ThrottlingException = _ThrottlingException;
+var _TooManyTagsException = class _TooManyTagsException extends ManagedBlockchainServiceException {
+  /**
+   * @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 _ResourceNotFoundException = class _ResourceNotFoundException extends ManagedBlockchainServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ResourceNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ResourceNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
+    this.Message = opts.Message;
+    this.ResourceName = opts.ResourceName;
+  }
+};
+__name(_ResourceNotFoundException, "ResourceNotFoundException");
+var ResourceNotFoundException = _ResourceNotFoundException;
+var _ResourceNotReadyException = class _ResourceNotReadyException extends ManagedBlockchainServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ResourceNotReadyException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ResourceNotReadyException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ResourceNotReadyException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_ResourceNotReadyException, "ResourceNotReadyException");
+var ResourceNotReadyException = _ResourceNotReadyException;
+var Framework = {
+  ETHEREUM: "ETHEREUM",
+  HYPERLEDGER_FABRIC: "HYPERLEDGER_FABRIC"
+};
+var Edition = {
+  STANDARD: "STANDARD",
+  STARTER: "STARTER"
+};
+var StateDBType = {
+  CouchDB: "CouchDB",
+  LevelDB: "LevelDB"
+};
+var MemberStatus = {
+  AVAILABLE: "AVAILABLE",
+  CREATE_FAILED: "CREATE_FAILED",
+  CREATING: "CREATING",
+  DELETED: "DELETED",
+  DELETING: "DELETING",
+  INACCESSIBLE_ENCRYPTION_KEY: "INACCESSIBLE_ENCRYPTION_KEY",
+  UPDATING: "UPDATING"
+};
+var NetworkStatus = {
+  AVAILABLE: "AVAILABLE",
+  CREATE_FAILED: "CREATE_FAILED",
+  CREATING: "CREATING",
+  DELETED: "DELETED",
+  DELETING: "DELETING"
+};
+var NodeStatus = {
+  AVAILABLE: "AVAILABLE",
+  CREATE_FAILED: "CREATE_FAILED",
+  CREATING: "CREATING",
+  DELETED: "DELETED",
+  DELETING: "DELETING",
+  FAILED: "FAILED",
+  INACCESSIBLE_ENCRYPTION_KEY: "INACCESSIBLE_ENCRYPTION_KEY",
+  UNHEALTHY: "UNHEALTHY",
+  UPDATING: "UPDATING"
+};
+var ProposalStatus = {
+  ACTION_FAILED: "ACTION_FAILED",
+  APPROVED: "APPROVED",
+  EXPIRED: "EXPIRED",
+  IN_PROGRESS: "IN_PROGRESS",
+  REJECTED: "REJECTED"
+};
+var _IllegalActionException = class _IllegalActionException extends ManagedBlockchainServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "IllegalActionException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "IllegalActionException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _IllegalActionException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_IllegalActionException, "IllegalActionException");
+var IllegalActionException = _IllegalActionException;
+var InvitationStatus = {
+  ACCEPTED: "ACCEPTED",
+  ACCEPTING: "ACCEPTING",
+  EXPIRED: "EXPIRED",
+  PENDING: "PENDING",
+  REJECTED: "REJECTED"
+};
+var VoteValue = {
+  NO: "NO",
+  YES: "YES"
+};
+var MemberFabricConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.AdminPassword && { AdminPassword: import_smithy_client.SENSITIVE_STRING }
+}), "MemberFabricConfigurationFilterSensitiveLog");
+var MemberFrameworkConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Fabric && { Fabric: MemberFabricConfigurationFilterSensitiveLog(obj.Fabric) }
+}), "MemberFrameworkConfigurationFilterSensitiveLog");
+var MemberConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.FrameworkConfiguration && {
+    FrameworkConfiguration: MemberFrameworkConfigurationFilterSensitiveLog(obj.FrameworkConfiguration)
+  }
+}), "MemberConfigurationFilterSensitiveLog");
+var CreateMemberInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.MemberConfiguration && {
+    MemberConfiguration: MemberConfigurationFilterSensitiveLog(obj.MemberConfiguration)
+  }
+}), "CreateMemberInputFilterSensitiveLog");
+var CreateNetworkInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.MemberConfiguration && {
+    MemberConfiguration: MemberConfigurationFilterSensitiveLog(obj.MemberConfiguration)
+  }
+}), "CreateNetworkInputFilterSensitiveLog");
+
+// src/protocols/Aws_restJson1.ts
+var se_CreateAccessorCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/accessors");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      AccessorType: [],
+      ClientRequestToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      NetworkType: [],
+      Tags: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateAccessorCommand");
+var se_CreateMemberCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/networks/{NetworkId}/members");
+  b.p("NetworkId", () => input.NetworkId, "{NetworkId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      ClientRequestToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      InvitationId: [],
+      MemberConfiguration: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateMemberCommand");
+var se_CreateNetworkCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/networks");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      ClientRequestToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      Description: [],
+      Framework: [],
+      FrameworkConfiguration: (_) => (0, import_smithy_client._json)(_),
+      FrameworkVersion: [],
+      MemberConfiguration: (_) => (0, import_smithy_client._json)(_),
+      Name: [],
+      Tags: (_) => (0, import_smithy_client._json)(_),
+      VotingPolicy: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateNetworkCommand");
+var se_CreateNodeCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/networks/{NetworkId}/nodes");
+  b.p("NetworkId", () => input.NetworkId, "{NetworkId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      ClientRequestToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      MemberId: [],
+      NodeConfiguration: (_) => (0, import_smithy_client._json)(_),
+      Tags: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateNodeCommand");
+var se_CreateProposalCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/networks/{NetworkId}/proposals");
+  b.p("NetworkId", () => input.NetworkId, "{NetworkId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      Actions: (_) => (0, import_smithy_client._json)(_),
+      ClientRequestToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      Description: [],
+      MemberId: [],
+      Tags: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateProposalCommand");
+var se_DeleteAccessorCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/accessors/{AccessorId}");
+  b.p("AccessorId", () => input.AccessorId, "{AccessorId}", false);
+  let body;
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_DeleteAccessorCommand");
+var se_DeleteMemberCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/networks/{NetworkId}/members/{MemberId}");
+  b.p("NetworkId", () => input.NetworkId, "{NetworkId}", false);
+  b.p("MemberId", () => input.MemberId, "{MemberId}", false);
+  let body;
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_DeleteMemberCommand");
+var se_DeleteNodeCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/networks/{NetworkId}/nodes/{NodeId}");
+  b.p("NetworkId", () => input.NetworkId, "{NetworkId}", false);
+  b.p("NodeId", () => input.NodeId, "{NodeId}", false);
+  const query = (0, import_smithy_client.map)({
+    [_mI]: [, input[_MI]]
+  });
+  let body;
+  b.m("DELETE").h(headers).q(query).b(body);
+  return b.build();
+}, "se_DeleteNodeCommand");
+var se_GetAccessorCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/accessors/{AccessorId}");
+  b.p("AccessorId", () => input.AccessorId, "{AccessorId}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetAccessorCommand");
+var se_GetMemberCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/networks/{NetworkId}/members/{MemberId}");
+  b.p("NetworkId", () => input.NetworkId, "{NetworkId}", false);
+  b.p("MemberId", () => input.MemberId, "{MemberId}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetMemberCommand");
+var se_GetNetworkCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/networks/{NetworkId}");
+  b.p("NetworkId", () => input.NetworkId, "{NetworkId}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetNetworkCommand");
+var se_GetNodeCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/networks/{NetworkId}/nodes/{NodeId}");
+  b.p("NetworkId", () => input.NetworkId, "{NetworkId}", false);
+  b.p("NodeId", () => input.NodeId, "{NodeId}", false);
+  const query = (0, import_smithy_client.map)({
+    [_mI]: [, input[_MI]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_GetNodeCommand");
+var se_GetProposalCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/networks/{NetworkId}/proposals/{ProposalId}");
+  b.p("NetworkId", () => input.NetworkId, "{NetworkId}", false);
+  b.p("ProposalId", () => input.ProposalId, "{ProposalId}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetProposalCommand");
+var se_ListAccessorsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/accessors");
+  const query = (0, import_smithy_client.map)({
+    [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
+    [_nT]: [, input[_NT]],
+    [_nTe]: [, input[_NTe]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListAccessorsCommand");
+var se_ListInvitationsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/invitations");
+  const query = (0, import_smithy_client.map)({
+    [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
+    [_nT]: [, input[_NT]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListInvitationsCommand");
+var se_ListMembersCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/networks/{NetworkId}/members");
+  b.p("NetworkId", () => input.NetworkId, "{NetworkId}", false);
+  const query = (0, import_smithy_client.map)({
+    [_n]: [, input[_N]],
+    [_s]: [, input[_S]],
+    [_iO]: [() => input.IsOwned !== void 0, () => input[_IO].toString()],
+    [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
+    [_nT]: [, input[_NT]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListMembersCommand");
+var se_ListNetworksCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/networks");
+  const query = (0, import_smithy_client.map)({
+    [_n]: [, input[_N]],
+    [_f]: [, input[_F]],
+    [_s]: [, input[_S]],
+    [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
+    [_nT]: [, input[_NT]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListNetworksCommand");
+var se_ListNodesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/networks/{NetworkId}/nodes");
+  b.p("NetworkId", () => input.NetworkId, "{NetworkId}", false);
+  const query = (0, import_smithy_client.map)({
+    [_mI]: [, input[_MI]],
+    [_s]: [, input[_S]],
+    [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
+    [_nT]: [, input[_NT]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListNodesCommand");
+var se_ListProposalsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/networks/{NetworkId}/proposals");
+  b.p("NetworkId", () => input.NetworkId, "{NetworkId}", false);
+  const query = (0, import_smithy_client.map)({
+    [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
+    [_nT]: [, input[_NT]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListProposalsCommand");
+var se_ListProposalVotesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/networks/{NetworkId}/proposals/{ProposalId}/votes");
+  b.p("NetworkId", () => input.NetworkId, "{NetworkId}", false);
+  b.p("ProposalId", () => input.ProposalId, "{ProposalId}", false);
+  const query = (0, import_smithy_client.map)({
+    [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
+    [_nT]: [, input[_NT]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListProposalVotesCommand");
+var se_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/tags/{ResourceArn}");
+  b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_ListTagsForResourceCommand");
+var se_RejectInvitationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/invitations/{InvitationId}");
+  b.p("InvitationId", () => input.InvitationId, "{InvitationId}", false);
+  let body;
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_RejectInvitationCommand");
+var se_TagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/tags/{ResourceArn}");
+  b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      Tags: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_TagResourceCommand");
+var se_UntagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/tags/{ResourceArn}");
+  b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
+  const query = (0, import_smithy_client.map)({
+    [_tK]: [
+      (0, import_smithy_client.expectNonNull)(input.TagKeys, `TagKeys`) != null,
+      () => (input[_TK] || []).map((_entry) => _entry)
+    ]
+  });
+  let body;
+  b.m("DELETE").h(headers).q(query).b(body);
+  return b.build();
+}, "se_UntagResourceCommand");
+var se_UpdateMemberCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/networks/{NetworkId}/members/{MemberId}");
+  b.p("NetworkId", () => input.NetworkId, "{NetworkId}", false);
+  b.p("MemberId", () => input.MemberId, "{MemberId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      LogPublishingConfiguration: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("PATCH").h(headers).b(body);
+  return b.build();
+}, "se_UpdateMemberCommand");
+var se_UpdateNodeCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/networks/{NetworkId}/nodes/{NodeId}");
+  b.p("NetworkId", () => input.NetworkId, "{NetworkId}", false);
+  b.p("NodeId", () => input.NodeId, "{NodeId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      LogPublishingConfiguration: (_) => (0, import_smithy_client._json)(_),
+      MemberId: []
+    })
+  );
+  b.m("PATCH").h(headers).b(body);
+  return b.build();
+}, "se_UpdateNodeCommand");
+var se_VoteOnProposalCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/networks/{NetworkId}/proposals/{ProposalId}/votes");
+  b.p("NetworkId", () => input.NetworkId, "{NetworkId}", false);
+  b.p("ProposalId", () => input.ProposalId, "{ProposalId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      Vote: [],
+      VoterMemberId: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_VoteOnProposalCommand");
+var de_CreateAccessorCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateAccessorCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    AccessorId: import_smithy_client.expectString,
+    BillingToken: import_smithy_client.expectString,
+    NetworkType: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateAccessorCommand");
+var de_CreateAccessorCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.managedblockchain#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServiceErrorException":
+    case "com.amazonaws.managedblockchain#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.managedblockchain#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceAlreadyExistsException":
+    case "com.amazonaws.managedblockchain#ResourceAlreadyExistsException":
+      throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
+    case "ResourceLimitExceededException":
+    case "com.amazonaws.managedblockchain#ResourceLimitExceededException":
+      throw await de_ResourceLimitExceededExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.managedblockchain#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "TooManyTagsException":
+    case "com.amazonaws.managedblockchain#TooManyTagsException":
+      throw await de_TooManyTagsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateAccessorCommandError");
+var de_CreateMemberCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateMemberCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    MemberId: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateMemberCommand");
+var de_CreateMemberCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.managedblockchain#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServiceErrorException":
+    case "com.amazonaws.managedblockchain#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.managedblockchain#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceAlreadyExistsException":
+    case "com.amazonaws.managedblockchain#ResourceAlreadyExistsException":
+      throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
+    case "ResourceLimitExceededException":
+    case "com.amazonaws.managedblockchain#ResourceLimitExceededException":
+      throw await de_ResourceLimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.managedblockchain#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ResourceNotReadyException":
+    case "com.amazonaws.managedblockchain#ResourceNotReadyException":
+      throw await de_ResourceNotReadyExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.managedblockchain#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "TooManyTagsException":
+    case "com.amazonaws.managedblockchain#TooManyTagsException":
+      throw await de_TooManyTagsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateMemberCommandError");
+var de_CreateNetworkCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateNetworkCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    MemberId: import_smithy_client.expectString,
+    NetworkId: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateNetworkCommand");
+var de_CreateNetworkCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.managedblockchain#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServiceErrorException":
+    case "com.amazonaws.managedblockchain#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.managedblockchain#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceAlreadyExistsException":
+    case "com.amazonaws.managedblockchain#ResourceAlreadyExistsException":
+      throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
+    case "ResourceLimitExceededException":
+    case "com.amazonaws.managedblockchain#ResourceLimitExceededException":
+      throw await de_ResourceLimitExceededExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.managedblockchain#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "TooManyTagsException":
+    case "com.amazonaws.managedblockchain#TooManyTagsException":
+      throw await de_TooManyTagsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateNetworkCommandError");
+var de_CreateNodeCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateNodeCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    NodeId: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateNodeCommand");
+var de_CreateNodeCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.managedblockchain#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServiceErrorException":
+    case "com.amazonaws.managedblockchain#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.managedblockchain#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceAlreadyExistsException":
+    case "com.amazonaws.managedblockchain#ResourceAlreadyExistsException":
+      throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
+    case "ResourceLimitExceededException":
+    case "com.amazonaws.managedblockchain#ResourceLimitExceededException":
+      throw await de_ResourceLimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.managedblockchain#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ResourceNotReadyException":
+    case "com.amazonaws.managedblockchain#ResourceNotReadyException":
+      throw await de_ResourceNotReadyExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.managedblockchain#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "TooManyTagsException":
+    case "com.amazonaws.managedblockchain#TooManyTagsException":
+      throw await de_TooManyTagsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateNodeCommandError");
+var de_CreateProposalCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateProposalCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    ProposalId: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateProposalCommand");
+var de_CreateProposalCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.managedblockchain#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServiceErrorException":
+    case "com.amazonaws.managedblockchain#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.managedblockchain#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.managedblockchain#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ResourceNotReadyException":
+    case "com.amazonaws.managedblockchain#ResourceNotReadyException":
+      throw await de_ResourceNotReadyExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.managedblockchain#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "TooManyTagsException":
+    case "com.amazonaws.managedblockchain#TooManyTagsException":
+      throw await de_TooManyTagsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateProposalCommandError");
+var de_DeleteAccessorCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteAccessorCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteAccessorCommand");
+var de_DeleteAccessorCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.managedblockchain#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServiceErrorException":
+    case "com.amazonaws.managedblockchain#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.managedblockchain#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.managedblockchain#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.managedblockchain#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteAccessorCommandError");
+var de_DeleteMemberCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteMemberCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteMemberCommand");
+var de_DeleteMemberCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.managedblockchain#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServiceErrorException":
+    case "com.amazonaws.managedblockchain#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.managedblockchain#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.managedblockchain#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ResourceNotReadyException":
+    case "com.amazonaws.managedblockchain#ResourceNotReadyException":
+      throw await de_ResourceNotReadyExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.managedblockchain#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteMemberCommandError");
+var de_DeleteNodeCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteNodeCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteNodeCommand");
+var de_DeleteNodeCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.managedblockchain#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServiceErrorException":
+    case "com.amazonaws.managedblockchain#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.managedblockchain#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.managedblockchain#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ResourceNotReadyException":
+    case "com.amazonaws.managedblockchain#ResourceNotReadyException":
+      throw await de_ResourceNotReadyExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.managedblockchain#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteNodeCommandError");
+var de_GetAccessorCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetAccessorCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Accessor: (_) => de_Accessor(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetAccessorCommand");
+var de_GetAccessorCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.managedblockchain#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServiceErrorException":
+    case "com.amazonaws.managedblockchain#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.managedblockchain#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.managedblockchain#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.managedblockchain#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetAccessorCommandError");
+var de_GetMemberCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetMemberCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Member: (_) => de_Member(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetMemberCommand");
+var de_GetMemberCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.managedblockchain#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServiceErrorException":
+    case "com.amazonaws.managedblockchain#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.managedblockchain#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.managedblockchain#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.managedblockchain#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetMemberCommandError");
+var de_GetNetworkCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetNetworkCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Network: (_) => de_Network(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetNetworkCommand");
+var de_GetNetworkCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.managedblockchain#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServiceErrorException":
+    case "com.amazonaws.managedblockchain#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.managedblockchain#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.managedblockchain#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.managedblockchain#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetNetworkCommandError");
+var de_GetNodeCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetNodeCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Node: (_) => de_Node(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetNodeCommand");
+var de_GetNodeCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.managedblockchain#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServiceErrorException":
+    case "com.amazonaws.managedblockchain#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.managedblockchain#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.managedblockchain#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.managedblockchain#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetNodeCommandError");
+var de_GetProposalCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetProposalCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Proposal: (_) => de_Proposal(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetProposalCommand");
+var de_GetProposalCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.managedblockchain#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServiceErrorException":
+    case "com.amazonaws.managedblockchain#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.managedblockchain#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.managedblockchain#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.managedblockchain#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetProposalCommandError");
+var de_ListAccessorsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListAccessorsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Accessors: (_) => de_AccessorSummaryList(_, context),
+    NextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListAccessorsCommand");
+var de_ListAccessorsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.managedblockchain#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServiceErrorException":
+    case "com.amazonaws.managedblockchain#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.managedblockchain#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.managedblockchain#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListAccessorsCommandError");
+var de_ListInvitationsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListInvitationsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Invitations: (_) => de_InvitationList(_, context),
+    NextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListInvitationsCommand");
+var de_ListInvitationsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.managedblockchain#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServiceErrorException":
+    case "com.amazonaws.managedblockchain#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.managedblockchain#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceLimitExceededException":
+    case "com.amazonaws.managedblockchain#ResourceLimitExceededException":
+      throw await de_ResourceLimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.managedblockchain#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.managedblockchain#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListInvitationsCommandError");
+var de_ListMembersCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListMembersCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Members: (_) => de_MemberSummaryList(_, context),
+    NextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListMembersCommand");
+var de_ListMembersCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.managedblockchain#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServiceErrorException":
+    case "com.amazonaws.managedblockchain#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.managedblockchain#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.managedblockchain#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListMembersCommandError");
+var de_ListNetworksCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListNetworksCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Networks: (_) => de_NetworkSummaryList(_, context),
+    NextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListNetworksCommand");
+var de_ListNetworksCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.managedblockchain#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServiceErrorException":
+    case "com.amazonaws.managedblockchain#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.managedblockchain#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.managedblockchain#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListNetworksCommandError");
+var de_ListNodesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListNodesCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    NextToken: import_smithy_client.expectString,
+    Nodes: (_) => de_NodeSummaryList(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListNodesCommand");
+var de_ListNodesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.managedblockchain#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServiceErrorException":
+    case "com.amazonaws.managedblockchain#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.managedblockchain#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.managedblockchain#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListNodesCommandError");
+var de_ListProposalsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListProposalsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    NextToken: import_smithy_client.expectString,
+    Proposals: (_) => de_ProposalSummaryList(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListProposalsCommand");
+var de_ListProposalsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.managedblockchain#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServiceErrorException":
+    case "com.amazonaws.managedblockchain#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.managedblockchain#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.managedblockchain#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.managedblockchain#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListProposalsCommandError");
+var de_ListProposalVotesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListProposalVotesCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    NextToken: import_smithy_client.expectString,
+    ProposalVotes: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListProposalVotesCommand");
+var de_ListProposalVotesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.managedblockchain#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServiceErrorException":
+    case "com.amazonaws.managedblockchain#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.managedblockchain#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.managedblockchain#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListProposalVotesCommandError");
+var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListTagsForResourceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Tags: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "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 "InternalServiceErrorException":
+    case "com.amazonaws.managedblockchain#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.managedblockchain#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.managedblockchain#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ResourceNotReadyException":
+    case "com.amazonaws.managedblockchain#ResourceNotReadyException":
+      throw await de_ResourceNotReadyExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListTagsForResourceCommandError");
+var de_RejectInvitationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_RejectInvitationCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_RejectInvitationCommand");
+var de_RejectInvitationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.managedblockchain#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "IllegalActionException":
+    case "com.amazonaws.managedblockchain#IllegalActionException":
+      throw await de_IllegalActionExceptionRes(parsedOutput, context);
+    case "InternalServiceErrorException":
+    case "com.amazonaws.managedblockchain#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.managedblockchain#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.managedblockchain#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.managedblockchain#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_RejectInvitationCommandError");
+var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_TagResourceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "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 "InternalServiceErrorException":
+    case "com.amazonaws.managedblockchain#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.managedblockchain#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.managedblockchain#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ResourceNotReadyException":
+    case "com.amazonaws.managedblockchain#ResourceNotReadyException":
+      throw await de_ResourceNotReadyExceptionRes(parsedOutput, context);
+    case "TooManyTagsException":
+    case "com.amazonaws.managedblockchain#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 !== 200 && output.statusCode >= 300) {
+    return de_UntagResourceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "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 "InternalServiceErrorException":
+    case "com.amazonaws.managedblockchain#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.managedblockchain#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.managedblockchain#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ResourceNotReadyException":
+    case "com.amazonaws.managedblockchain#ResourceNotReadyException":
+      throw await de_ResourceNotReadyExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UntagResourceCommandError");
+var de_UpdateMemberCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UpdateMemberCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_UpdateMemberCommand");
+var de_UpdateMemberCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.managedblockchain#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServiceErrorException":
+    case "com.amazonaws.managedblockchain#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.managedblockchain#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.managedblockchain#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.managedblockchain#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateMemberCommandError");
+var de_UpdateNodeCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UpdateNodeCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_UpdateNodeCommand");
+var de_UpdateNodeCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.managedblockchain#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServiceErrorException":
+    case "com.amazonaws.managedblockchain#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.managedblockchain#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.managedblockchain#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.managedblockchain#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateNodeCommandError");
+var de_VoteOnProposalCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_VoteOnProposalCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_VoteOnProposalCommand");
+var de_VoteOnProposalCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.managedblockchain#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "IllegalActionException":
+    case "com.amazonaws.managedblockchain#IllegalActionException":
+      throw await de_IllegalActionExceptionRes(parsedOutput, context);
+    case "InternalServiceErrorException":
+    case "com.amazonaws.managedblockchain#InternalServiceErrorException":
+      throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.managedblockchain#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.managedblockchain#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.managedblockchain#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_VoteOnProposalCommandError");
+var throwDefaultError = (0, import_smithy_client.withBaseException)(ManagedBlockchainServiceException);
+var de_AccessDeniedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new AccessDeniedException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_AccessDeniedExceptionRes");
+var de_IllegalActionExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new IllegalActionException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_IllegalActionExceptionRes");
+var de_InternalServiceErrorExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {});
+  Object.assign(contents, doc);
+  const exception = new InternalServiceErrorException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_InternalServiceErrorExceptionRes");
+var de_InvalidRequestExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new InvalidRequestException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_InvalidRequestExceptionRes");
+var de_ResourceAlreadyExistsExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ResourceAlreadyExistsException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ResourceAlreadyExistsExceptionRes");
+var de_ResourceLimitExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ResourceLimitExceededException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ResourceLimitExceededExceptionRes");
+var de_ResourceNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: import_smithy_client.expectString,
+    ResourceName: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ResourceNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ResourceNotFoundExceptionRes");
+var de_ResourceNotReadyExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ResourceNotReadyException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ResourceNotReadyExceptionRes");
+var de_ThrottlingExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {});
+  Object.assign(contents, doc);
+  const exception = new ThrottlingException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ThrottlingExceptionRes");
+var de_TooManyTagsExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: import_smithy_client.expectString,
+    ResourceName: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new TooManyTagsException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_TooManyTagsExceptionRes");
+var de_Accessor = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Arn: import_smithy_client.expectString,
+    BillingToken: import_smithy_client.expectString,
+    CreationDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    Id: import_smithy_client.expectString,
+    NetworkType: import_smithy_client.expectString,
+    Status: import_smithy_client.expectString,
+    Tags: import_smithy_client._json,
+    Type: import_smithy_client.expectString
+  });
+}, "de_Accessor");
+var de_AccessorSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Arn: import_smithy_client.expectString,
+    CreationDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    Id: import_smithy_client.expectString,
+    NetworkType: import_smithy_client.expectString,
+    Status: import_smithy_client.expectString,
+    Type: import_smithy_client.expectString
+  });
+}, "de_AccessorSummary");
+var de_AccessorSummaryList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_AccessorSummary(entry, context);
+  });
+  return retVal;
+}, "de_AccessorSummaryList");
+var de_Invitation = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Arn: import_smithy_client.expectString,
+    CreationDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    ExpirationDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    InvitationId: import_smithy_client.expectString,
+    NetworkSummary: (_) => de_NetworkSummary(_, context),
+    Status: import_smithy_client.expectString
+  });
+}, "de_Invitation");
+var de_InvitationList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Invitation(entry, context);
+  });
+  return retVal;
+}, "de_InvitationList");
+var de_Member = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Arn: import_smithy_client.expectString,
+    CreationDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    Description: import_smithy_client.expectString,
+    FrameworkAttributes: import_smithy_client._json,
+    Id: import_smithy_client.expectString,
+    KmsKeyArn: import_smithy_client.expectString,
+    LogPublishingConfiguration: import_smithy_client._json,
+    Name: import_smithy_client.expectString,
+    NetworkId: import_smithy_client.expectString,
+    Status: import_smithy_client.expectString,
+    Tags: import_smithy_client._json
+  });
+}, "de_Member");
+var de_MemberSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Arn: import_smithy_client.expectString,
+    CreationDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    Description: import_smithy_client.expectString,
+    Id: import_smithy_client.expectString,
+    IsOwned: import_smithy_client.expectBoolean,
+    Name: import_smithy_client.expectString,
+    Status: import_smithy_client.expectString
+  });
+}, "de_MemberSummary");
+var de_MemberSummaryList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_MemberSummary(entry, context);
+  });
+  return retVal;
+}, "de_MemberSummaryList");
+var de_Network = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Arn: import_smithy_client.expectString,
+    CreationDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    Description: import_smithy_client.expectString,
+    Framework: import_smithy_client.expectString,
+    FrameworkAttributes: import_smithy_client._json,
+    FrameworkVersion: import_smithy_client.expectString,
+    Id: import_smithy_client.expectString,
+    Name: import_smithy_client.expectString,
+    Status: import_smithy_client.expectString,
+    Tags: import_smithy_client._json,
+    VotingPolicy: import_smithy_client._json,
+    VpcEndpointServiceName: import_smithy_client.expectString
+  });
+}, "de_Network");
+var de_NetworkSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Arn: import_smithy_client.expectString,
+    CreationDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    Description: import_smithy_client.expectString,
+    Framework: import_smithy_client.expectString,
+    FrameworkVersion: import_smithy_client.expectString,
+    Id: import_smithy_client.expectString,
+    Name: import_smithy_client.expectString,
+    Status: import_smithy_client.expectString
+  });
+}, "de_NetworkSummary");
+var de_NetworkSummaryList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_NetworkSummary(entry, context);
+  });
+  return retVal;
+}, "de_NetworkSummaryList");
+var de_Node = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Arn: import_smithy_client.expectString,
+    AvailabilityZone: import_smithy_client.expectString,
+    CreationDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    FrameworkAttributes: import_smithy_client._json,
+    Id: import_smithy_client.expectString,
+    InstanceType: import_smithy_client.expectString,
+    KmsKeyArn: import_smithy_client.expectString,
+    LogPublishingConfiguration: import_smithy_client._json,
+    MemberId: import_smithy_client.expectString,
+    NetworkId: import_smithy_client.expectString,
+    StateDB: import_smithy_client.expectString,
+    Status: import_smithy_client.expectString,
+    Tags: import_smithy_client._json
+  });
+}, "de_Node");
+var de_NodeSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Arn: import_smithy_client.expectString,
+    AvailabilityZone: import_smithy_client.expectString,
+    CreationDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    Id: import_smithy_client.expectString,
+    InstanceType: import_smithy_client.expectString,
+    Status: import_smithy_client.expectString
+  });
+}, "de_NodeSummary");
+var de_NodeSummaryList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_NodeSummary(entry, context);
+  });
+  return retVal;
+}, "de_NodeSummaryList");
+var de_Proposal = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Actions: import_smithy_client._json,
+    Arn: import_smithy_client.expectString,
+    CreationDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    Description: import_smithy_client.expectString,
+    ExpirationDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    NetworkId: import_smithy_client.expectString,
+    NoVoteCount: import_smithy_client.expectInt32,
+    OutstandingVoteCount: import_smithy_client.expectInt32,
+    ProposalId: import_smithy_client.expectString,
+    ProposedByMemberId: import_smithy_client.expectString,
+    ProposedByMemberName: import_smithy_client.expectString,
+    Status: import_smithy_client.expectString,
+    Tags: import_smithy_client._json,
+    YesVoteCount: import_smithy_client.expectInt32
+  });
+}, "de_Proposal");
+var de_ProposalSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Arn: import_smithy_client.expectString,
+    CreationDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    Description: import_smithy_client.expectString,
+    ExpirationDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    ProposalId: import_smithy_client.expectString,
+    ProposedByMemberId: import_smithy_client.expectString,
+    ProposedByMemberName: import_smithy_client.expectString,
+    Status: import_smithy_client.expectString
+  });
+}, "de_ProposalSummary");
+var de_ProposalSummaryList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_ProposalSummary(entry, context);
+  });
+  return retVal;
+}, "de_ProposalSummaryList");
+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 _F = "Framework";
+var _IO = "IsOwned";
+var _MI = "MemberId";
+var _MR = "MaxResults";
+var _N = "Name";
+var _NT = "NextToken";
+var _NTe = "NetworkType";
+var _S = "Status";
+var _TK = "TagKeys";
+var _f = "framework";
+var _iO = "isOwned";
+var _mI = "memberId";
+var _mR = "maxResults";
+var _n = "name";
+var _nT = "nextToken";
+var _nTe = "networkType";
+var _s = "status";
+var _tK = "tagKeys";
+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/CreateAccessorCommand.ts
+var _CreateAccessorCommand = class _CreateAccessorCommand 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("TaigaWebService", "CreateAccessor", {}).n("ManagedBlockchainClient", "CreateAccessorCommand").f(void 0, void 0).ser(se_CreateAccessorCommand).de(de_CreateAccessorCommand).build() {
+};
+__name(_CreateAccessorCommand, "CreateAccessorCommand");
+var CreateAccessorCommand = _CreateAccessorCommand;
+
+// src/commands/CreateMemberCommand.ts
+
+
+
+
+var _CreateMemberCommand = class _CreateMemberCommand 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("TaigaWebService", "CreateMember", {}).n("ManagedBlockchainClient", "CreateMemberCommand").f(CreateMemberInputFilterSensitiveLog, void 0).ser(se_CreateMemberCommand).de(de_CreateMemberCommand).build() {
+};
+__name(_CreateMemberCommand, "CreateMemberCommand");
+var CreateMemberCommand = _CreateMemberCommand;
+
+// src/commands/CreateNetworkCommand.ts
+
+
+
+
+var _CreateNetworkCommand = class _CreateNetworkCommand 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("TaigaWebService", "CreateNetwork", {}).n("ManagedBlockchainClient", "CreateNetworkCommand").f(CreateNetworkInputFilterSensitiveLog, void 0).ser(se_CreateNetworkCommand).de(de_CreateNetworkCommand).build() {
+};
+__name(_CreateNetworkCommand, "CreateNetworkCommand");
+var CreateNetworkCommand = _CreateNetworkCommand;
+
+// src/commands/CreateNodeCommand.ts
+
+
+
+
+var _CreateNodeCommand = class _CreateNodeCommand 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("TaigaWebService", "CreateNode", {}).n("ManagedBlockchainClient", "CreateNodeCommand").f(void 0, void 0).ser(se_CreateNodeCommand).de(de_CreateNodeCommand).build() {
+};
+__name(_CreateNodeCommand, "CreateNodeCommand");
+var CreateNodeCommand = _CreateNodeCommand;
+
+// src/commands/CreateProposalCommand.ts
+
+
+
+
+var _CreateProposalCommand = class _CreateProposalCommand 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("TaigaWebService", "CreateProposal", {}).n("ManagedBlockchainClient", "CreateProposalCommand").f(void 0, void 0).ser(se_CreateProposalCommand).de(de_CreateProposalCommand).build() {
+};
+__name(_CreateProposalCommand, "CreateProposalCommand");
+var CreateProposalCommand = _CreateProposalCommand;
+
+// src/commands/DeleteAccessorCommand.ts
+
+
+
+
+var _DeleteAccessorCommand = class _DeleteAccessorCommand 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("TaigaWebService", "DeleteAccessor", {}).n("ManagedBlockchainClient", "DeleteAccessorCommand").f(void 0, void 0).ser(se_DeleteAccessorCommand).de(de_DeleteAccessorCommand).build() {
+};
+__name(_DeleteAccessorCommand, "DeleteAccessorCommand");
+var DeleteAccessorCommand = _DeleteAccessorCommand;
+
+// src/commands/DeleteMemberCommand.ts
+
+
+
+
+var _DeleteMemberCommand = class _DeleteMemberCommand 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("TaigaWebService", "DeleteMember", {}).n("ManagedBlockchainClient", "DeleteMemberCommand").f(void 0, void 0).ser(se_DeleteMemberCommand).de(de_DeleteMemberCommand).build() {
+};
+__name(_DeleteMemberCommand, "DeleteMemberCommand");
+var DeleteMemberCommand = _DeleteMemberCommand;
+
+// src/commands/DeleteNodeCommand.ts
+
+
+
+
+var _DeleteNodeCommand = class _DeleteNodeCommand 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("TaigaWebService", "DeleteNode", {}).n("ManagedBlockchainClient", "DeleteNodeCommand").f(void 0, void 0).ser(se_DeleteNodeCommand).de(de_DeleteNodeCommand).build() {
+};
+__name(_DeleteNodeCommand, "DeleteNodeCommand");
+var DeleteNodeCommand = _DeleteNodeCommand;
+
+// src/commands/GetAccessorCommand.ts
+
+
+
+
+var _GetAccessorCommand = class _GetAccessorCommand 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("TaigaWebService", "GetAccessor", {}).n("ManagedBlockchainClient", "GetAccessorCommand").f(void 0, void 0).ser(se_GetAccessorCommand).de(de_GetAccessorCommand).build() {
+};
+__name(_GetAccessorCommand, "GetAccessorCommand");
+var GetAccessorCommand = _GetAccessorCommand;
+
+// src/commands/GetMemberCommand.ts
+
+
+
+
+var _GetMemberCommand = class _GetMemberCommand 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("TaigaWebService", "GetMember", {}).n("ManagedBlockchainClient", "GetMemberCommand").f(void 0, void 0).ser(se_GetMemberCommand).de(de_GetMemberCommand).build() {
+};
+__name(_GetMemberCommand, "GetMemberCommand");
+var GetMemberCommand = _GetMemberCommand;
+
+// src/commands/GetNetworkCommand.ts
+
+
+
+
+var _GetNetworkCommand = class _GetNetworkCommand 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("TaigaWebService", "GetNetwork", {}).n("ManagedBlockchainClient", "GetNetworkCommand").f(void 0, void 0).ser(se_GetNetworkCommand).de(de_GetNetworkCommand).build() {
+};
+__name(_GetNetworkCommand, "GetNetworkCommand");
+var GetNetworkCommand = _GetNetworkCommand;
+
+// src/commands/GetNodeCommand.ts
+
+
+
+
+var _GetNodeCommand = class _GetNodeCommand 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("TaigaWebService", "GetNode", {}).n("ManagedBlockchainClient", "GetNodeCommand").f(void 0, void 0).ser(se_GetNodeCommand).de(de_GetNodeCommand).build() {
+};
+__name(_GetNodeCommand, "GetNodeCommand");
+var GetNodeCommand = _GetNodeCommand;
+
+// src/commands/GetProposalCommand.ts
+
+
+
+
+var _GetProposalCommand = class _GetProposalCommand 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("TaigaWebService", "GetProposal", {}).n("ManagedBlockchainClient", "GetProposalCommand").f(void 0, void 0).ser(se_GetProposalCommand).de(de_GetProposalCommand).build() {
+};
+__name(_GetProposalCommand, "GetProposalCommand");
+var GetProposalCommand = _GetProposalCommand;
+
+// src/commands/ListAccessorsCommand.ts
+
+
+
+
+var _ListAccessorsCommand = class _ListAccessorsCommand 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("TaigaWebService", "ListAccessors", {}).n("ManagedBlockchainClient", "ListAccessorsCommand").f(void 0, void 0).ser(se_ListAccessorsCommand).de(de_ListAccessorsCommand).build() {
+};
+__name(_ListAccessorsCommand, "ListAccessorsCommand");
+var ListAccessorsCommand = _ListAccessorsCommand;
+
+// src/commands/ListInvitationsCommand.ts
+
+
+
+
+var _ListInvitationsCommand = class _ListInvitationsCommand 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("TaigaWebService", "ListInvitations", {}).n("ManagedBlockchainClient", "ListInvitationsCommand").f(void 0, void 0).ser(se_ListInvitationsCommand).de(de_ListInvitationsCommand).build() {
+};
+__name(_ListInvitationsCommand, "ListInvitationsCommand");
+var ListInvitationsCommand = _ListInvitationsCommand;
+
+// src/commands/ListMembersCommand.ts
+
+
+
+
+var _ListMembersCommand = class _ListMembersCommand 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("TaigaWebService", "ListMembers", {}).n("ManagedBlockchainClient", "ListMembersCommand").f(void 0, void 0).ser(se_ListMembersCommand).de(de_ListMembersCommand).build() {
+};
+__name(_ListMembersCommand, "ListMembersCommand");
+var ListMembersCommand = _ListMembersCommand;
+
+// src/commands/ListNetworksCommand.ts
+
+
+
+
+var _ListNetworksCommand = class _ListNetworksCommand 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("TaigaWebService", "ListNetworks", {}).n("ManagedBlockchainClient", "ListNetworksCommand").f(void 0, void 0).ser(se_ListNetworksCommand).de(de_ListNetworksCommand).build() {
+};
+__name(_ListNetworksCommand, "ListNetworksCommand");
+var ListNetworksCommand = _ListNetworksCommand;
+
+// src/commands/ListNodesCommand.ts
+
+
+
+
+var _ListNodesCommand = class _ListNodesCommand 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("TaigaWebService", "ListNodes", {}).n("ManagedBlockchainClient", "ListNodesCommand").f(void 0, void 0).ser(se_ListNodesCommand).de(de_ListNodesCommand).build() {
+};
+__name(_ListNodesCommand, "ListNodesCommand");
+var ListNodesCommand = _ListNodesCommand;
+
+// src/commands/ListProposalsCommand.ts
+
+
+
+
+var _ListProposalsCommand = class _ListProposalsCommand 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("TaigaWebService", "ListProposals", {}).n("ManagedBlockchainClient", "ListProposalsCommand").f(void 0, void 0).ser(se_ListProposalsCommand).de(de_ListProposalsCommand).build() {
+};
+__name(_ListProposalsCommand, "ListProposalsCommand");
+var ListProposalsCommand = _ListProposalsCommand;
+
+// src/commands/ListProposalVotesCommand.ts
+
+
+
+
+var _ListProposalVotesCommand = class _ListProposalVotesCommand 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("TaigaWebService", "ListProposalVotes", {}).n("ManagedBlockchainClient", "ListProposalVotesCommand").f(void 0, void 0).ser(se_ListProposalVotesCommand).de(de_ListProposalVotesCommand).build() {
+};
+__name(_ListProposalVotesCommand, "ListProposalVotesCommand");
+var ListProposalVotesCommand = _ListProposalVotesCommand;
+
+// 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("TaigaWebService", "ListTagsForResource", {}).n("ManagedBlockchainClient", "ListTagsForResourceCommand").f(void 0, void 0).ser(se_ListTagsForResourceCommand).de(de_ListTagsForResourceCommand).build() {
+};
+__name(_ListTagsForResourceCommand, "ListTagsForResourceCommand");
+var ListTagsForResourceCommand = _ListTagsForResourceCommand;
+
+// src/commands/RejectInvitationCommand.ts
+
+
+
+
+var _RejectInvitationCommand = class _RejectInvitationCommand 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("TaigaWebService", "RejectInvitation", {}).n("ManagedBlockchainClient", "RejectInvitationCommand").f(void 0, void 0).ser(se_RejectInvitationCommand).de(de_RejectInvitationCommand).build() {
+};
+__name(_RejectInvitationCommand, "RejectInvitationCommand");
+var RejectInvitationCommand = _RejectInvitationCommand;
+
+// 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("TaigaWebService", "TagResource", {}).n("ManagedBlockchainClient", "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("TaigaWebService", "UntagResource", {}).n("ManagedBlockchainClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
+};
+__name(_UntagResourceCommand, "UntagResourceCommand");
+var UntagResourceCommand = _UntagResourceCommand;
+
+// src/commands/UpdateMemberCommand.ts
+
+
+
+
+var _UpdateMemberCommand = class _UpdateMemberCommand 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("TaigaWebService", "UpdateMember", {}).n("ManagedBlockchainClient", "UpdateMemberCommand").f(void 0, void 0).ser(se_UpdateMemberCommand).de(de_UpdateMemberCommand).build() {
+};
+__name(_UpdateMemberCommand, "UpdateMemberCommand");
+var UpdateMemberCommand = _UpdateMemberCommand;
+
+// src/commands/UpdateNodeCommand.ts
+
+
+
+
+var _UpdateNodeCommand = class _UpdateNodeCommand 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("TaigaWebService", "UpdateNode", {}).n("ManagedBlockchainClient", "UpdateNodeCommand").f(void 0, void 0).ser(se_UpdateNodeCommand).de(de_UpdateNodeCommand).build() {
+};
+__name(_UpdateNodeCommand, "UpdateNodeCommand");
+var UpdateNodeCommand = _UpdateNodeCommand;
+
+// src/commands/VoteOnProposalCommand.ts
+
+
+
+
+var _VoteOnProposalCommand = class _VoteOnProposalCommand 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("TaigaWebService", "VoteOnProposal", {}).n("ManagedBlockchainClient", "VoteOnProposalCommand").f(void 0, void 0).ser(se_VoteOnProposalCommand).de(de_VoteOnProposalCommand).build() {
+};
+__name(_VoteOnProposalCommand, "VoteOnProposalCommand");
+var VoteOnProposalCommand = _VoteOnProposalCommand;
+
+// src/ManagedBlockchain.ts
+var commands = {
+  CreateAccessorCommand,
+  CreateMemberCommand,
+  CreateNetworkCommand,
+  CreateNodeCommand,
+  CreateProposalCommand,
+  DeleteAccessorCommand,
+  DeleteMemberCommand,
+  DeleteNodeCommand,
+  GetAccessorCommand,
+  GetMemberCommand,
+  GetNetworkCommand,
+  GetNodeCommand,
+  GetProposalCommand,
+  ListAccessorsCommand,
+  ListInvitationsCommand,
+  ListMembersCommand,
+  ListNetworksCommand,
+  ListNodesCommand,
+  ListProposalsCommand,
+  ListProposalVotesCommand,
+  ListTagsForResourceCommand,
+  RejectInvitationCommand,
+  TagResourceCommand,
+  UntagResourceCommand,
+  UpdateMemberCommand,
+  UpdateNodeCommand,
+  VoteOnProposalCommand
+};
+var _ManagedBlockchain = class _ManagedBlockchain extends ManagedBlockchainClient {
+};
+__name(_ManagedBlockchain, "ManagedBlockchain");
+var ManagedBlockchain = _ManagedBlockchain;
+(0, import_smithy_client.createAggregatedClient)(commands, ManagedBlockchain);
+
+// src/pagination/ListAccessorsPaginator.ts
+
+var paginateListAccessors = (0, import_core.createPaginator)(ManagedBlockchainClient, ListAccessorsCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListInvitationsPaginator.ts
+
+var paginateListInvitations = (0, import_core.createPaginator)(ManagedBlockchainClient, ListInvitationsCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListMembersPaginator.ts
+
+var paginateListMembers = (0, import_core.createPaginator)(ManagedBlockchainClient, ListMembersCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListNetworksPaginator.ts
+
+var paginateListNetworks = (0, import_core.createPaginator)(ManagedBlockchainClient, ListNetworksCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListNodesPaginator.ts
+
+var paginateListNodes = (0, import_core.createPaginator)(ManagedBlockchainClient, ListNodesCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListProposalVotesPaginator.ts
+
+var paginateListProposalVotes = (0, import_core.createPaginator)(ManagedBlockchainClient, ListProposalVotesCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListProposalsPaginator.ts
+
+var paginateListProposals = (0, import_core.createPaginator)(ManagedBlockchainClient, ListProposalsCommand, "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 = {
+  AccessDeniedException,
+  AccessorNetworkType,
+  AccessorStatus,
+  AccessorType,
+  CreateAccessorCommand,
+  CreateMemberCommand,
+  CreateMemberInputFilterSensitiveLog,
+  CreateNetworkCommand,
+  CreateNetworkInputFilterSensitiveLog,
+  CreateNodeCommand,
+  CreateProposalCommand,
+  DeleteAccessorCommand,
+  DeleteMemberCommand,
+  DeleteNodeCommand,
+  Edition,
+  Framework,
+  GetAccessorCommand,
+  GetMemberCommand,
+  GetNetworkCommand,
+  GetNodeCommand,
+  GetProposalCommand,
+  IllegalActionException,
+  InternalServiceErrorException,
+  InvalidRequestException,
+  InvitationStatus,
+  ListAccessorsCommand,
+  ListInvitationsCommand,
+  ListMembersCommand,
+  ListNetworksCommand,
+  ListNodesCommand,
+  ListProposalVotesCommand,
+  ListProposalsCommand,
+  ListTagsForResourceCommand,
+  ManagedBlockchain,
+  ManagedBlockchainClient,
+  ManagedBlockchainServiceException,
+  MemberConfigurationFilterSensitiveLog,
+  MemberFabricConfigurationFilterSensitiveLog,
+  MemberFrameworkConfigurationFilterSensitiveLog,
+  MemberStatus,
+  NetworkStatus,
+  NodeStatus,
+  ProposalStatus,
+  RejectInvitationCommand,
+  ResourceAlreadyExistsException,
+  ResourceLimitExceededException,
+  ResourceNotFoundException,
+  ResourceNotReadyException,
+  StateDBType,
+  TagResourceCommand,
+  ThresholdComparator,
+  ThrottlingException,
+  TooManyTagsException,
+  UntagResourceCommand,
+  UpdateMemberCommand,
+  UpdateNodeCommand,
+  VoteOnProposalCommand,
+  VoteValue,
+  __Client,
+  paginateListAccessors,
+  paginateListInvitations,
+  paginateListMembers,
+  paginateListNetworks,
+  paginateListNodes,
+  paginateListProposalVotes,
+  paginateListProposals
+});
+