@aws-sdk/client-schemas 3.489.0 → 3.495.0

package/dist-cjs/index.js

@@ -1,13 +1,3290 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SchemasServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./SchemasClient"), exports);
-tslib_1.__exportStar(require("./Schemas"), exports);
-tslib_1.__exportStar(require("./commands"), exports);
-tslib_1.__exportStar(require("./pagination"), exports);
-tslib_1.__exportStar(require("./waiters"), exports);
-tslib_1.__exportStar(require("./models"), exports);
-require("@aws-sdk/util-endpoints");
-var SchemasServiceException_1 = require("./models/SchemasServiceException");
-Object.defineProperty(exports, "SchemasServiceException", { enumerable: true, get: function () { return SchemasServiceException_1.SchemasServiceException; } });
+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, {
+  BadRequestException: () => BadRequestException,
+  CodeGenerationStatus: () => CodeGenerationStatus,
+  ConflictException: () => ConflictException,
+  CreateDiscovererCommand: () => CreateDiscovererCommand,
+  CreateRegistryCommand: () => CreateRegistryCommand,
+  CreateSchemaCommand: () => CreateSchemaCommand,
+  DeleteDiscovererCommand: () => DeleteDiscovererCommand,
+  DeleteRegistryCommand: () => DeleteRegistryCommand,
+  DeleteResourcePolicyCommand: () => DeleteResourcePolicyCommand,
+  DeleteSchemaCommand: () => DeleteSchemaCommand,
+  DeleteSchemaVersionCommand: () => DeleteSchemaVersionCommand,
+  DescribeCodeBindingCommand: () => DescribeCodeBindingCommand,
+  DescribeDiscovererCommand: () => DescribeDiscovererCommand,
+  DescribeRegistryCommand: () => DescribeRegistryCommand,
+  DescribeSchemaCommand: () => DescribeSchemaCommand,
+  DiscovererState: () => DiscovererState,
+  ExportSchemaCommand: () => ExportSchemaCommand,
+  ForbiddenException: () => ForbiddenException,
+  GetCodeBindingSourceCommand: () => GetCodeBindingSourceCommand,
+  GetDiscoveredSchemaCommand: () => GetDiscoveredSchemaCommand,
+  GetResourcePolicyCommand: () => GetResourcePolicyCommand,
+  GoneException: () => GoneException,
+  InternalServerErrorException: () => InternalServerErrorException,
+  ListDiscoverersCommand: () => ListDiscoverersCommand,
+  ListRegistriesCommand: () => ListRegistriesCommand,
+  ListSchemaVersionsCommand: () => ListSchemaVersionsCommand,
+  ListSchemasCommand: () => ListSchemasCommand,
+  ListTagsForResourceCommand: () => ListTagsForResourceCommand,
+  NotFoundException: () => NotFoundException,
+  PreconditionFailedException: () => PreconditionFailedException,
+  PutCodeBindingCommand: () => PutCodeBindingCommand,
+  PutResourcePolicyCommand: () => PutResourcePolicyCommand,
+  Schemas: () => Schemas,
+  SchemasClient: () => SchemasClient,
+  SchemasServiceException: () => SchemasServiceException,
+  SearchSchemasCommand: () => SearchSchemasCommand,
+  ServiceUnavailableException: () => ServiceUnavailableException,
+  StartDiscovererCommand: () => StartDiscovererCommand,
+  StopDiscovererCommand: () => StopDiscovererCommand,
+  TagResourceCommand: () => TagResourceCommand,
+  TooManyRequestsException: () => TooManyRequestsException,
+  Type: () => Type,
+  UnauthorizedException: () => UnauthorizedException,
+  UntagResourceCommand: () => UntagResourceCommand,
+  UpdateDiscovererCommand: () => UpdateDiscovererCommand,
+  UpdateRegistryCommand: () => UpdateRegistryCommand,
+  UpdateSchemaCommand: () => UpdateSchemaCommand,
+  __Client: () => import_smithy_client.Client,
+  paginateListDiscoverers: () => paginateListDiscoverers,
+  paginateListRegistries: () => paginateListRegistries,
+  paginateListSchemaVersions: () => paginateListSchemaVersions,
+  paginateListSchemas: () => paginateListSchemas,
+  paginateSearchSchemas: () => paginateSearchSchemas,
+  waitForCodeBindingExists: () => waitForCodeBindingExists,
+  waitUntilCodeBindingExists: () => waitUntilCodeBindingExists
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/SchemasClient.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: "schemas"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/SchemasClient.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/SchemasClient.ts
+var _SchemasClient = class _SchemasClient 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(_SchemasClient, "SchemasClient");
+var SchemasClient = _SchemasClient;
+
+// src/Schemas.ts
+
+
+// src/commands/CreateDiscovererCommand.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/SchemasServiceException.ts
+
+var _SchemasServiceException = class _SchemasServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _SchemasServiceException.prototype);
+  }
+};
+__name(_SchemasServiceException, "SchemasServiceException");
+var SchemasServiceException = _SchemasServiceException;
+
+// src/models/models_0.ts
+var DiscovererState = {
+  STARTED: "STARTED",
+  STOPPED: "STOPPED"
+};
+var Type = {
+  JSONSchemaDraft4: "JSONSchemaDraft4",
+  OpenApi3: "OpenApi3"
+};
+var _BadRequestException = class _BadRequestException extends SchemasServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "BadRequestException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "BadRequestException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _BadRequestException.prototype);
+    this.Code = opts.Code;
+    this.Message = opts.Message;
+  }
+};
+__name(_BadRequestException, "BadRequestException");
+var BadRequestException = _BadRequestException;
+var CodeGenerationStatus = {
+  CREATE_COMPLETE: "CREATE_COMPLETE",
+  CREATE_FAILED: "CREATE_FAILED",
+  CREATE_IN_PROGRESS: "CREATE_IN_PROGRESS"
+};
+var _ConflictException = class _ConflictException extends SchemasServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ConflictException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ConflictException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ConflictException.prototype);
+    this.Code = opts.Code;
+    this.Message = opts.Message;
+  }
+};
+__name(_ConflictException, "ConflictException");
+var ConflictException = _ConflictException;
+var _ForbiddenException = class _ForbiddenException extends SchemasServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ForbiddenException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ForbiddenException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ForbiddenException.prototype);
+    this.Code = opts.Code;
+    this.Message = opts.Message;
+  }
+};
+__name(_ForbiddenException, "ForbiddenException");
+var ForbiddenException = _ForbiddenException;
+var _InternalServerErrorException = class _InternalServerErrorException extends SchemasServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InternalServerErrorException",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "InternalServerErrorException";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _InternalServerErrorException.prototype);
+    this.Code = opts.Code;
+    this.Message = opts.Message;
+  }
+};
+__name(_InternalServerErrorException, "InternalServerErrorException");
+var InternalServerErrorException = _InternalServerErrorException;
+var _ServiceUnavailableException = class _ServiceUnavailableException extends SchemasServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ServiceUnavailableException",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "ServiceUnavailableException";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _ServiceUnavailableException.prototype);
+    this.Code = opts.Code;
+    this.Message = opts.Message;
+  }
+};
+__name(_ServiceUnavailableException, "ServiceUnavailableException");
+var ServiceUnavailableException = _ServiceUnavailableException;
+var _UnauthorizedException = class _UnauthorizedException extends SchemasServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "UnauthorizedException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "UnauthorizedException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _UnauthorizedException.prototype);
+    this.Code = opts.Code;
+    this.Message = opts.Message;
+  }
+};
+__name(_UnauthorizedException, "UnauthorizedException");
+var UnauthorizedException = _UnauthorizedException;
+var _NotFoundException = class _NotFoundException extends SchemasServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "NotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "NotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _NotFoundException.prototype);
+    this.Code = opts.Code;
+    this.Message = opts.Message;
+  }
+};
+__name(_NotFoundException, "NotFoundException");
+var NotFoundException = _NotFoundException;
+var _TooManyRequestsException = class _TooManyRequestsException extends SchemasServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "TooManyRequestsException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "TooManyRequestsException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _TooManyRequestsException.prototype);
+    this.Code = opts.Code;
+    this.Message = opts.Message;
+  }
+};
+__name(_TooManyRequestsException, "TooManyRequestsException");
+var TooManyRequestsException = _TooManyRequestsException;
+var _GoneException = class _GoneException extends SchemasServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "GoneException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "GoneException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _GoneException.prototype);
+    this.Code = opts.Code;
+    this.Message = opts.Message;
+  }
+};
+__name(_GoneException, "GoneException");
+var GoneException = _GoneException;
+var _PreconditionFailedException = class _PreconditionFailedException extends SchemasServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "PreconditionFailedException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "PreconditionFailedException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _PreconditionFailedException.prototype);
+    this.Code = opts.Code;
+    this.Message = opts.Message;
+  }
+};
+__name(_PreconditionFailedException, "PreconditionFailedException");
+var PreconditionFailedException = _PreconditionFailedException;
+
+// src/protocols/Aws_restJson1.ts
+var se_CreateDiscovererCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/discoverers");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      CrossAccount: [],
+      Description: [],
+      SourceArn: [],
+      tags: [, (_) => (0, import_smithy_client._json)(_), `Tags`]
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateDiscovererCommand");
+var se_CreateRegistryCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/registries/name/{RegistryName}");
+  b.p("RegistryName", () => input.RegistryName, "{RegistryName}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      Description: [],
+      tags: [, (_) => (0, import_smithy_client._json)(_), `Tags`]
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateRegistryCommand");
+var se_CreateSchemaCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/registries/name/{RegistryName}/schemas/name/{SchemaName}");
+  b.p("RegistryName", () => input.RegistryName, "{RegistryName}", false);
+  b.p("SchemaName", () => input.SchemaName, "{SchemaName}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      Content: [],
+      Description: [],
+      tags: [, (_) => (0, import_smithy_client._json)(_), `Tags`],
+      Type: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateSchemaCommand");
+var se_DeleteDiscovererCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v1/discoverers/id/{DiscovererId}");
+  b.p("DiscovererId", () => input.DiscovererId, "{DiscovererId}", false);
+  let body;
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_DeleteDiscovererCommand");
+var se_DeleteRegistryCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v1/registries/name/{RegistryName}");
+  b.p("RegistryName", () => input.RegistryName, "{RegistryName}", false);
+  let body;
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_DeleteRegistryCommand");
+var se_DeleteResourcePolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v1/policy");
+  const query = (0, import_smithy_client.map)({
+    [_rN]: [, input[_RN]]
+  });
+  let body;
+  b.m("DELETE").h(headers).q(query).b(body);
+  return b.build();
+}, "se_DeleteResourcePolicyCommand");
+var se_DeleteSchemaCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v1/registries/name/{RegistryName}/schemas/name/{SchemaName}");
+  b.p("RegistryName", () => input.RegistryName, "{RegistryName}", false);
+  b.p("SchemaName", () => input.SchemaName, "{SchemaName}", false);
+  let body;
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_DeleteSchemaCommand");
+var se_DeleteSchemaVersionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v1/registries/name/{RegistryName}/schemas/name/{SchemaName}/version/{SchemaVersion}");
+  b.p("RegistryName", () => input.RegistryName, "{RegistryName}", false);
+  b.p("SchemaName", () => input.SchemaName, "{SchemaName}", false);
+  b.p("SchemaVersion", () => input.SchemaVersion, "{SchemaVersion}", false);
+  let body;
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_DeleteSchemaVersionCommand");
+var se_DescribeCodeBindingCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v1/registries/name/{RegistryName}/schemas/name/{SchemaName}/language/{Language}");
+  b.p("Language", () => input.Language, "{Language}", false);
+  b.p("RegistryName", () => input.RegistryName, "{RegistryName}", false);
+  b.p("SchemaName", () => input.SchemaName, "{SchemaName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_sV]: [, input[_SV]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_DescribeCodeBindingCommand");
+var se_DescribeDiscovererCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v1/discoverers/id/{DiscovererId}");
+  b.p("DiscovererId", () => input.DiscovererId, "{DiscovererId}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_DescribeDiscovererCommand");
+var se_DescribeRegistryCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v1/registries/name/{RegistryName}");
+  b.p("RegistryName", () => input.RegistryName, "{RegistryName}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_DescribeRegistryCommand");
+var se_DescribeSchemaCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v1/registries/name/{RegistryName}/schemas/name/{SchemaName}");
+  b.p("RegistryName", () => input.RegistryName, "{RegistryName}", false);
+  b.p("SchemaName", () => input.SchemaName, "{SchemaName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_sV]: [, input[_SV]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_DescribeSchemaCommand");
+var se_ExportSchemaCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v1/registries/name/{RegistryName}/schemas/name/{SchemaName}/export");
+  b.p("RegistryName", () => input.RegistryName, "{RegistryName}", false);
+  b.p("SchemaName", () => input.SchemaName, "{SchemaName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_sV]: [, input[_SV]],
+    [_t]: [, (0, import_smithy_client.expectNonNull)(input[_T], `Type`)]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ExportSchemaCommand");
+var se_GetCodeBindingSourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v1/registries/name/{RegistryName}/schemas/name/{SchemaName}/language/{Language}/source");
+  b.p("Language", () => input.Language, "{Language}", false);
+  b.p("RegistryName", () => input.RegistryName, "{RegistryName}", false);
+  b.p("SchemaName", () => input.SchemaName, "{SchemaName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_sV]: [, input[_SV]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_GetCodeBindingSourceCommand");
+var se_GetDiscoveredSchemaCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/discover");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      Events: (_) => (0, import_smithy_client._json)(_),
+      Type: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GetDiscoveredSchemaCommand");
+var se_GetResourcePolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v1/policy");
+  const query = (0, import_smithy_client.map)({
+    [_rN]: [, input[_RN]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_GetResourcePolicyCommand");
+var se_ListDiscoverersCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v1/discoverers");
+  const query = (0, import_smithy_client.map)({
+    [_dIP]: [, input[_DIP]],
+    [_l]: [() => input.Limit !== void 0, () => input[_L].toString()],
+    [_nT]: [, input[_NT]],
+    [_sAP]: [, input[_SAP]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListDiscoverersCommand");
+var se_ListRegistriesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v1/registries");
+  const query = (0, import_smithy_client.map)({
+    [_l]: [() => input.Limit !== void 0, () => input[_L].toString()],
+    [_nT]: [, input[_NT]],
+    [_rNP]: [, input[_RNP]],
+    [_s]: [, input[_S]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListRegistriesCommand");
+var se_ListSchemasCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v1/registries/name/{RegistryName}/schemas");
+  b.p("RegistryName", () => input.RegistryName, "{RegistryName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_l]: [() => input.Limit !== void 0, () => input[_L].toString()],
+    [_nT]: [, input[_NT]],
+    [_sNP]: [, input[_SNP]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListSchemasCommand");
+var se_ListSchemaVersionsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v1/registries/name/{RegistryName}/schemas/name/{SchemaName}/versions");
+  b.p("RegistryName", () => input.RegistryName, "{RegistryName}", false);
+  b.p("SchemaName", () => input.SchemaName, "{SchemaName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_l]: [() => input.Limit !== void 0, () => input[_L].toString()],
+    [_nT]: [, input[_NT]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListSchemaVersionsCommand");
+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_PutCodeBindingCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v1/registries/name/{RegistryName}/schemas/name/{SchemaName}/language/{Language}");
+  b.p("Language", () => input.Language, "{Language}", false);
+  b.p("RegistryName", () => input.RegistryName, "{RegistryName}", false);
+  b.p("SchemaName", () => input.SchemaName, "{SchemaName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_sV]: [, input[_SV]]
+  });
+  let body;
+  b.m("POST").h(headers).q(query).b(body);
+  return b.build();
+}, "se_PutCodeBindingCommand");
+var se_PutResourcePolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/policy");
+  const query = (0, import_smithy_client.map)({
+    [_rN]: [, input[_RN]]
+  });
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      Policy: (_) => import_smithy_client.LazyJsonString.fromObject(_),
+      RevisionId: []
+    })
+  );
+  b.m("PUT").h(headers).q(query).b(body);
+  return b.build();
+}, "se_PutResourcePolicyCommand");
+var se_SearchSchemasCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v1/registries/name/{RegistryName}/schemas/search");
+  b.p("RegistryName", () => input.RegistryName, "{RegistryName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_k]: [, (0, import_smithy_client.expectNonNull)(input[_K], `Keywords`)],
+    [_l]: [() => input.Limit !== void 0, () => input[_L].toString()],
+    [_nT]: [, input[_NT]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_SearchSchemasCommand");
+var se_StartDiscovererCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v1/discoverers/id/{DiscovererId}/start");
+  b.p("DiscovererId", () => input.DiscovererId, "{DiscovererId}", false);
+  let body;
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_StartDiscovererCommand");
+var se_StopDiscovererCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v1/discoverers/id/{DiscovererId}/stop");
+  b.p("DiscovererId", () => input.DiscovererId, "{DiscovererId}", false);
+  let body;
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_StopDiscovererCommand");
+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)(_), `Tags`]
+    })
+  );
+  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_UpdateDiscovererCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/discoverers/id/{DiscovererId}");
+  b.p("DiscovererId", () => input.DiscovererId, "{DiscovererId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      CrossAccount: [],
+      Description: []
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_UpdateDiscovererCommand");
+var se_UpdateRegistryCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/registries/name/{RegistryName}");
+  b.p("RegistryName", () => input.RegistryName, "{RegistryName}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      Description: []
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_UpdateRegistryCommand");
+var se_UpdateSchemaCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/registries/name/{RegistryName}/schemas/name/{SchemaName}");
+  b.p("RegistryName", () => input.RegistryName, "{RegistryName}", false);
+  b.p("SchemaName", () => input.SchemaName, "{SchemaName}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      ClientTokenId: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      Content: [],
+      Description: [],
+      Type: []
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_UpdateSchemaCommand");
+var de_CreateDiscovererCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 201 && output.statusCode >= 300) {
+    return de_CreateDiscovererCommandError(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, {
+    CrossAccount: import_smithy_client.expectBoolean,
+    Description: import_smithy_client.expectString,
+    DiscovererArn: import_smithy_client.expectString,
+    DiscovererId: import_smithy_client.expectString,
+    SourceArn: import_smithy_client.expectString,
+    State: import_smithy_client.expectString,
+    Tags: [, import_smithy_client._json, `tags`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateDiscovererCommand");
+var de_CreateDiscovererCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.schemas#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.schemas#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.schemas#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.schemas#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.schemas#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "UnauthorizedException":
+    case "com.amazonaws.schemas#UnauthorizedException":
+      throw await de_UnauthorizedExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateDiscovererCommandError");
+var de_CreateRegistryCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 201 && output.statusCode >= 300) {
+    return de_CreateRegistryCommandError(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, {
+    Description: import_smithy_client.expectString,
+    RegistryArn: import_smithy_client.expectString,
+    RegistryName: import_smithy_client.expectString,
+    Tags: [, import_smithy_client._json, `tags`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateRegistryCommand");
+var de_CreateRegistryCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.schemas#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.schemas#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.schemas#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.schemas#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.schemas#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "UnauthorizedException":
+    case "com.amazonaws.schemas#UnauthorizedException":
+      throw await de_UnauthorizedExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateRegistryCommandError");
+var de_CreateSchemaCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 201 && output.statusCode >= 300) {
+    return de_CreateSchemaCommandError(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, {
+    Description: import_smithy_client.expectString,
+    LastModified: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    SchemaArn: import_smithy_client.expectString,
+    SchemaName: import_smithy_client.expectString,
+    SchemaVersion: import_smithy_client.expectString,
+    Tags: [, import_smithy_client._json, `tags`],
+    Type: import_smithy_client.expectString,
+    VersionCreatedDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_))
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateSchemaCommand");
+var de_CreateSchemaCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.schemas#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.schemas#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.schemas#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.schemas#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateSchemaCommandError");
+var de_DeleteDiscovererCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_DeleteDiscovererCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteDiscovererCommand");
+var de_DeleteDiscovererCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.schemas#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.schemas#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.schemas#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.schemas#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.schemas#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "UnauthorizedException":
+    case "com.amazonaws.schemas#UnauthorizedException":
+      throw await de_UnauthorizedExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteDiscovererCommandError");
+var de_DeleteRegistryCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_DeleteRegistryCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteRegistryCommand");
+var de_DeleteRegistryCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.schemas#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.schemas#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.schemas#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.schemas#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.schemas#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "UnauthorizedException":
+    case "com.amazonaws.schemas#UnauthorizedException":
+      throw await de_UnauthorizedExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteRegistryCommandError");
+var de_DeleteResourcePolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_DeleteResourcePolicyCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteResourcePolicyCommand");
+var de_DeleteResourcePolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.schemas#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.schemas#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.schemas#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.schemas#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.schemas#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "UnauthorizedException":
+    case "com.amazonaws.schemas#UnauthorizedException":
+      throw await de_UnauthorizedExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteResourcePolicyCommandError");
+var de_DeleteSchemaCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_DeleteSchemaCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteSchemaCommand");
+var de_DeleteSchemaCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.schemas#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.schemas#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.schemas#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.schemas#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.schemas#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "UnauthorizedException":
+    case "com.amazonaws.schemas#UnauthorizedException":
+      throw await de_UnauthorizedExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteSchemaCommandError");
+var de_DeleteSchemaVersionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_DeleteSchemaVersionCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteSchemaVersionCommand");
+var de_DeleteSchemaVersionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.schemas#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.schemas#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.schemas#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.schemas#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.schemas#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "UnauthorizedException":
+    case "com.amazonaws.schemas#UnauthorizedException":
+      throw await de_UnauthorizedExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteSchemaVersionCommandError");
+var de_DescribeCodeBindingCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DescribeCodeBindingCommandError(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, {
+    CreationDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    LastModified: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    SchemaVersion: import_smithy_client.expectString,
+    Status: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_DescribeCodeBindingCommand");
+var de_DescribeCodeBindingCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.schemas#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.schemas#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.schemas#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.schemas#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.schemas#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    case "UnauthorizedException":
+    case "com.amazonaws.schemas#UnauthorizedException":
+      throw await de_UnauthorizedExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeCodeBindingCommandError");
+var de_DescribeDiscovererCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DescribeDiscovererCommandError(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, {
+    CrossAccount: import_smithy_client.expectBoolean,
+    Description: import_smithy_client.expectString,
+    DiscovererArn: import_smithy_client.expectString,
+    DiscovererId: import_smithy_client.expectString,
+    SourceArn: import_smithy_client.expectString,
+    State: import_smithy_client.expectString,
+    Tags: [, import_smithy_client._json, `tags`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_DescribeDiscovererCommand");
+var de_DescribeDiscovererCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.schemas#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.schemas#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.schemas#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.schemas#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.schemas#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "UnauthorizedException":
+    case "com.amazonaws.schemas#UnauthorizedException":
+      throw await de_UnauthorizedExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeDiscovererCommandError");
+var de_DescribeRegistryCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DescribeRegistryCommandError(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, {
+    Description: import_smithy_client.expectString,
+    RegistryArn: import_smithy_client.expectString,
+    RegistryName: import_smithy_client.expectString,
+    Tags: [, import_smithy_client._json, `tags`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_DescribeRegistryCommand");
+var de_DescribeRegistryCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.schemas#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.schemas#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.schemas#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.schemas#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.schemas#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "UnauthorizedException":
+    case "com.amazonaws.schemas#UnauthorizedException":
+      throw await de_UnauthorizedExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeRegistryCommandError");
+var de_DescribeSchemaCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DescribeSchemaCommandError(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, {
+    Content: import_smithy_client.expectString,
+    Description: import_smithy_client.expectString,
+    LastModified: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    SchemaArn: import_smithy_client.expectString,
+    SchemaName: import_smithy_client.expectString,
+    SchemaVersion: import_smithy_client.expectString,
+    Tags: [, import_smithy_client._json, `tags`],
+    Type: import_smithy_client.expectString,
+    VersionCreatedDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_))
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_DescribeSchemaCommand");
+var de_DescribeSchemaCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.schemas#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.schemas#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.schemas#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.schemas#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.schemas#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "UnauthorizedException":
+    case "com.amazonaws.schemas#UnauthorizedException":
+      throw await de_UnauthorizedExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeSchemaCommandError");
+var de_ExportSchemaCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ExportSchemaCommandError(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, {
+    Content: import_smithy_client.expectString,
+    SchemaArn: import_smithy_client.expectString,
+    SchemaName: import_smithy_client.expectString,
+    SchemaVersion: import_smithy_client.expectString,
+    Type: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ExportSchemaCommand");
+var de_ExportSchemaCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.schemas#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.schemas#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.schemas#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.schemas#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.schemas#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.schemas#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    case "UnauthorizedException":
+    case "com.amazonaws.schemas#UnauthorizedException":
+      throw await de_UnauthorizedExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ExportSchemaCommandError");
+var de_GetCodeBindingSourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetCodeBindingSourceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = await (0, import_smithy_client.collectBody)(output.body, context);
+  contents.Body = data;
+  return contents;
+}, "de_GetCodeBindingSourceCommand");
+var de_GetCodeBindingSourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.schemas#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.schemas#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.schemas#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.schemas#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.schemas#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    case "UnauthorizedException":
+    case "com.amazonaws.schemas#UnauthorizedException":
+      throw await de_UnauthorizedExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetCodeBindingSourceCommandError");
+var de_GetDiscoveredSchemaCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetDiscoveredSchemaCommandError(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, {
+    Content: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetDiscoveredSchemaCommand");
+var de_GetDiscoveredSchemaCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.schemas#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.schemas#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.schemas#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.schemas#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "UnauthorizedException":
+    case "com.amazonaws.schemas#UnauthorizedException":
+      throw await de_UnauthorizedExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetDiscoveredSchemaCommandError");
+var de_GetResourcePolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetResourcePolicyCommandError(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, {
+    Policy: (_) => new import_smithy_client.LazyJsonString(_),
+    RevisionId: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetResourcePolicyCommand");
+var de_GetResourcePolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.schemas#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.schemas#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.schemas#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.schemas#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.schemas#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "UnauthorizedException":
+    case "com.amazonaws.schemas#UnauthorizedException":
+      throw await de_UnauthorizedExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetResourcePolicyCommandError");
+var de_ListDiscoverersCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListDiscoverersCommandError(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, {
+    Discoverers: (_) => de___listOfDiscovererSummary(_, context),
+    NextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListDiscoverersCommand");
+var de_ListDiscoverersCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.schemas#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.schemas#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.schemas#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.schemas#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "UnauthorizedException":
+    case "com.amazonaws.schemas#UnauthorizedException":
+      throw await de_UnauthorizedExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListDiscoverersCommandError");
+var de_ListRegistriesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListRegistriesCommandError(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,
+    Registries: (_) => de___listOfRegistrySummary(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListRegistriesCommand");
+var de_ListRegistriesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.schemas#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.schemas#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.schemas#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.schemas#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "UnauthorizedException":
+    case "com.amazonaws.schemas#UnauthorizedException":
+      throw await de_UnauthorizedExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListRegistriesCommandError");
+var de_ListSchemasCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListSchemasCommandError(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,
+    Schemas: (_) => de___listOfSchemaSummary(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListSchemasCommand");
+var de_ListSchemasCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.schemas#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.schemas#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.schemas#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.schemas#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "UnauthorizedException":
+    case "com.amazonaws.schemas#UnauthorizedException":
+      throw await de_UnauthorizedExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListSchemasCommandError");
+var de_ListSchemaVersionsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListSchemaVersionsCommandError(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,
+    SchemaVersions: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListSchemaVersionsCommand");
+var de_ListSchemaVersionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.schemas#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.schemas#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.schemas#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.schemas#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.schemas#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "UnauthorizedException":
+    case "com.amazonaws.schemas#UnauthorizedException":
+      throw await de_UnauthorizedExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListSchemaVersionsCommandError");
+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, `tags`]
+  });
+  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 "BadRequestException":
+    case "com.amazonaws.schemas#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.schemas#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.schemas#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.schemas#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListTagsForResourceCommandError");
+var de_PutCodeBindingCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 202 && output.statusCode >= 300) {
+    return de_PutCodeBindingCommandError(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, {
+    CreationDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    LastModified: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    SchemaVersion: import_smithy_client.expectString,
+    Status: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_PutCodeBindingCommand");
+var de_PutCodeBindingCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.schemas#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.schemas#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "GoneException":
+    case "com.amazonaws.schemas#GoneException":
+      throw await de_GoneExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.schemas#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.schemas#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.schemas#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    case "UnauthorizedException":
+    case "com.amazonaws.schemas#UnauthorizedException":
+      throw await de_UnauthorizedExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_PutCodeBindingCommandError");
+var de_PutResourcePolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_PutResourcePolicyCommandError(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, {
+    Policy: (_) => new import_smithy_client.LazyJsonString(_),
+    RevisionId: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_PutResourcePolicyCommand");
+var de_PutResourcePolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.schemas#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.schemas#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.schemas#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.schemas#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "PreconditionFailedException":
+    case "com.amazonaws.schemas#PreconditionFailedException":
+      throw await de_PreconditionFailedExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.schemas#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "UnauthorizedException":
+    case "com.amazonaws.schemas#UnauthorizedException":
+      throw await de_UnauthorizedExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_PutResourcePolicyCommandError");
+var de_SearchSchemasCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_SearchSchemasCommandError(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,
+    Schemas: (_) => de___listOfSearchSchemaSummary(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_SearchSchemasCommand");
+var de_SearchSchemasCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.schemas#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.schemas#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.schemas#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.schemas#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "UnauthorizedException":
+    case "com.amazonaws.schemas#UnauthorizedException":
+      throw await de_UnauthorizedExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_SearchSchemasCommandError");
+var de_StartDiscovererCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_StartDiscovererCommandError(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, {
+    DiscovererId: import_smithy_client.expectString,
+    State: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_StartDiscovererCommand");
+var de_StartDiscovererCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.schemas#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.schemas#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.schemas#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.schemas#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.schemas#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "UnauthorizedException":
+    case "com.amazonaws.schemas#UnauthorizedException":
+      throw await de_UnauthorizedExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_StartDiscovererCommandError");
+var de_StopDiscovererCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_StopDiscovererCommandError(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, {
+    DiscovererId: import_smithy_client.expectString,
+    State: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_StopDiscovererCommand");
+var de_StopDiscovererCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.schemas#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.schemas#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.schemas#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.schemas#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.schemas#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "UnauthorizedException":
+    case "com.amazonaws.schemas#UnauthorizedException":
+      throw await de_UnauthorizedExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_StopDiscovererCommandError");
+var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && 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 "BadRequestException":
+    case "com.amazonaws.schemas#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.schemas#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.schemas#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.schemas#NotFoundException":
+      throw await de_NotFoundExceptionRes(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 !== 204 && 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 "BadRequestException":
+    case "com.amazonaws.schemas#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.schemas#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.schemas#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.schemas#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UntagResourceCommandError");
+var de_UpdateDiscovererCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UpdateDiscovererCommandError(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, {
+    CrossAccount: import_smithy_client.expectBoolean,
+    Description: import_smithy_client.expectString,
+    DiscovererArn: import_smithy_client.expectString,
+    DiscovererId: import_smithy_client.expectString,
+    SourceArn: import_smithy_client.expectString,
+    State: import_smithy_client.expectString,
+    Tags: [, import_smithy_client._json, `tags`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_UpdateDiscovererCommand");
+var de_UpdateDiscovererCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.schemas#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.schemas#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.schemas#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.schemas#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.schemas#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "UnauthorizedException":
+    case "com.amazonaws.schemas#UnauthorizedException":
+      throw await de_UnauthorizedExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateDiscovererCommandError");
+var de_UpdateRegistryCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UpdateRegistryCommandError(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, {
+    Description: import_smithy_client.expectString,
+    RegistryArn: import_smithy_client.expectString,
+    RegistryName: import_smithy_client.expectString,
+    Tags: [, import_smithy_client._json, `tags`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_UpdateRegistryCommand");
+var de_UpdateRegistryCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.schemas#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.schemas#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.schemas#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.schemas#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.schemas#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "UnauthorizedException":
+    case "com.amazonaws.schemas#UnauthorizedException":
+      throw await de_UnauthorizedExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateRegistryCommandError");
+var de_UpdateSchemaCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UpdateSchemaCommandError(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, {
+    Description: import_smithy_client.expectString,
+    LastModified: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    SchemaArn: import_smithy_client.expectString,
+    SchemaName: import_smithy_client.expectString,
+    SchemaVersion: import_smithy_client.expectString,
+    Tags: [, import_smithy_client._json, `tags`],
+    Type: import_smithy_client.expectString,
+    VersionCreatedDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_))
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_UpdateSchemaCommand");
+var de_UpdateSchemaCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.schemas#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.schemas#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.schemas#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.schemas#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.schemas#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateSchemaCommandError");
+var throwDefaultError = (0, import_smithy_client.withBaseException)(SchemasServiceException);
+var de_BadRequestExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Code: import_smithy_client.expectString,
+    Message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new BadRequestException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_BadRequestExceptionRes");
+var de_ConflictExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Code: import_smithy_client.expectString,
+    Message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ConflictException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ConflictExceptionRes");
+var de_ForbiddenExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Code: import_smithy_client.expectString,
+    Message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ForbiddenException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ForbiddenExceptionRes");
+var de_GoneExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Code: import_smithy_client.expectString,
+    Message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new GoneException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_GoneExceptionRes");
+var de_InternalServerErrorExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Code: import_smithy_client.expectString,
+    Message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new InternalServerErrorException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_InternalServerErrorExceptionRes");
+var de_NotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Code: import_smithy_client.expectString,
+    Message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new NotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_NotFoundExceptionRes");
+var de_PreconditionFailedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Code: import_smithy_client.expectString,
+    Message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new PreconditionFailedException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_PreconditionFailedExceptionRes");
+var de_ServiceUnavailableExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Code: import_smithy_client.expectString,
+    Message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ServiceUnavailableException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ServiceUnavailableExceptionRes");
+var de_TooManyRequestsExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Code: import_smithy_client.expectString,
+    Message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new TooManyRequestsException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_TooManyRequestsExceptionRes");
+var de_UnauthorizedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Code: import_smithy_client.expectString,
+    Message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new UnauthorizedException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_UnauthorizedExceptionRes");
+var de___listOfDiscovererSummary = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_DiscovererSummary(entry, context);
+  });
+  return retVal;
+}, "de___listOfDiscovererSummary");
+var de___listOfRegistrySummary = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_RegistrySummary(entry, context);
+  });
+  return retVal;
+}, "de___listOfRegistrySummary");
+var de___listOfSchemaSummary = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_SchemaSummary(entry, context);
+  });
+  return retVal;
+}, "de___listOfSchemaSummary");
+var de___listOfSearchSchemaSummary = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_SearchSchemaSummary(entry, context);
+  });
+  return retVal;
+}, "de___listOfSearchSchemaSummary");
+var de___listOfSearchSchemaVersionSummary = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_SearchSchemaVersionSummary(entry, context);
+  });
+  return retVal;
+}, "de___listOfSearchSchemaVersionSummary");
+var de_DiscovererSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    CrossAccount: import_smithy_client.expectBoolean,
+    DiscovererArn: import_smithy_client.expectString,
+    DiscovererId: import_smithy_client.expectString,
+    SourceArn: import_smithy_client.expectString,
+    State: import_smithy_client.expectString,
+    Tags: [, import_smithy_client._json, `tags`]
+  });
+}, "de_DiscovererSummary");
+var de_RegistrySummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    RegistryArn: import_smithy_client.expectString,
+    RegistryName: import_smithy_client.expectString,
+    Tags: [, import_smithy_client._json, `tags`]
+  });
+}, "de_RegistrySummary");
+var de_SchemaSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    LastModified: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    SchemaArn: import_smithy_client.expectString,
+    SchemaName: import_smithy_client.expectString,
+    Tags: [, import_smithy_client._json, `tags`],
+    VersionCount: import_smithy_client.expectLong
+  });
+}, "de_SchemaSummary");
+var de_SearchSchemaSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    RegistryName: import_smithy_client.expectString,
+    SchemaArn: import_smithy_client.expectString,
+    SchemaName: import_smithy_client.expectString,
+    SchemaVersions: (_) => de___listOfSearchSchemaVersionSummary(_, context)
+  });
+}, "de_SearchSchemaSummary");
+var de_SearchSchemaVersionSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    CreatedDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    SchemaVersion: import_smithy_client.expectString,
+    Type: import_smithy_client.expectString
+  });
+}, "de_SearchSchemaVersionSummary");
+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 _DIP = "DiscovererIdPrefix";
+var _K = "Keywords";
+var _L = "Limit";
+var _NT = "NextToken";
+var _RN = "RegistryName";
+var _RNP = "RegistryNamePrefix";
+var _S = "Scope";
+var _SAP = "SourceArnPrefix";
+var _SNP = "SchemaNamePrefix";
+var _SV = "SchemaVersion";
+var _T = "Type";
+var _TK = "TagKeys";
+var _dIP = "discovererIdPrefix";
+var _k = "keywords";
+var _l = "limit";
+var _nT = "nextToken";
+var _rN = "registryName";
+var _rNP = "registryNamePrefix";
+var _s = "scope";
+var _sAP = "sourceArnPrefix";
+var _sNP = "schemaNamePrefix";
+var _sV = "schemaVersion";
+var _t = "type";
+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/CreateDiscovererCommand.ts
+var _CreateDiscovererCommand = class _CreateDiscovererCommand 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("schemas", "CreateDiscoverer", {}).n("SchemasClient", "CreateDiscovererCommand").f(void 0, void 0).ser(se_CreateDiscovererCommand).de(de_CreateDiscovererCommand).build() {
+};
+__name(_CreateDiscovererCommand, "CreateDiscovererCommand");
+var CreateDiscovererCommand = _CreateDiscovererCommand;
+
+// src/commands/CreateRegistryCommand.ts
+
+
+
+
+var _CreateRegistryCommand = class _CreateRegistryCommand 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("schemas", "CreateRegistry", {}).n("SchemasClient", "CreateRegistryCommand").f(void 0, void 0).ser(se_CreateRegistryCommand).de(de_CreateRegistryCommand).build() {
+};
+__name(_CreateRegistryCommand, "CreateRegistryCommand");
+var CreateRegistryCommand = _CreateRegistryCommand;
+
+// src/commands/CreateSchemaCommand.ts
+
+
+
+
+var _CreateSchemaCommand = class _CreateSchemaCommand 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("schemas", "CreateSchema", {}).n("SchemasClient", "CreateSchemaCommand").f(void 0, void 0).ser(se_CreateSchemaCommand).de(de_CreateSchemaCommand).build() {
+};
+__name(_CreateSchemaCommand, "CreateSchemaCommand");
+var CreateSchemaCommand = _CreateSchemaCommand;
+
+// src/commands/DeleteDiscovererCommand.ts
+
+
+
+
+var _DeleteDiscovererCommand = class _DeleteDiscovererCommand 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("schemas", "DeleteDiscoverer", {}).n("SchemasClient", "DeleteDiscovererCommand").f(void 0, void 0).ser(se_DeleteDiscovererCommand).de(de_DeleteDiscovererCommand).build() {
+};
+__name(_DeleteDiscovererCommand, "DeleteDiscovererCommand");
+var DeleteDiscovererCommand = _DeleteDiscovererCommand;
+
+// src/commands/DeleteRegistryCommand.ts
+
+
+
+
+var _DeleteRegistryCommand = class _DeleteRegistryCommand 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("schemas", "DeleteRegistry", {}).n("SchemasClient", "DeleteRegistryCommand").f(void 0, void 0).ser(se_DeleteRegistryCommand).de(de_DeleteRegistryCommand).build() {
+};
+__name(_DeleteRegistryCommand, "DeleteRegistryCommand");
+var DeleteRegistryCommand = _DeleteRegistryCommand;
+
+// src/commands/DeleteResourcePolicyCommand.ts
+
+
+
+
+var _DeleteResourcePolicyCommand = class _DeleteResourcePolicyCommand 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("schemas", "DeleteResourcePolicy", {}).n("SchemasClient", "DeleteResourcePolicyCommand").f(void 0, void 0).ser(se_DeleteResourcePolicyCommand).de(de_DeleteResourcePolicyCommand).build() {
+};
+__name(_DeleteResourcePolicyCommand, "DeleteResourcePolicyCommand");
+var DeleteResourcePolicyCommand = _DeleteResourcePolicyCommand;
+
+// src/commands/DeleteSchemaCommand.ts
+
+
+
+
+var _DeleteSchemaCommand = class _DeleteSchemaCommand 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("schemas", "DeleteSchema", {}).n("SchemasClient", "DeleteSchemaCommand").f(void 0, void 0).ser(se_DeleteSchemaCommand).de(de_DeleteSchemaCommand).build() {
+};
+__name(_DeleteSchemaCommand, "DeleteSchemaCommand");
+var DeleteSchemaCommand = _DeleteSchemaCommand;
+
+// src/commands/DeleteSchemaVersionCommand.ts
+
+
+
+
+var _DeleteSchemaVersionCommand = class _DeleteSchemaVersionCommand 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("schemas", "DeleteSchemaVersion", {}).n("SchemasClient", "DeleteSchemaVersionCommand").f(void 0, void 0).ser(se_DeleteSchemaVersionCommand).de(de_DeleteSchemaVersionCommand).build() {
+};
+__name(_DeleteSchemaVersionCommand, "DeleteSchemaVersionCommand");
+var DeleteSchemaVersionCommand = _DeleteSchemaVersionCommand;
+
+// src/commands/DescribeCodeBindingCommand.ts
+
+
+
+
+var _DescribeCodeBindingCommand = class _DescribeCodeBindingCommand 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("schemas", "DescribeCodeBinding", {}).n("SchemasClient", "DescribeCodeBindingCommand").f(void 0, void 0).ser(se_DescribeCodeBindingCommand).de(de_DescribeCodeBindingCommand).build() {
+};
+__name(_DescribeCodeBindingCommand, "DescribeCodeBindingCommand");
+var DescribeCodeBindingCommand = _DescribeCodeBindingCommand;
+
+// src/commands/DescribeDiscovererCommand.ts
+
+
+
+
+var _DescribeDiscovererCommand = class _DescribeDiscovererCommand 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("schemas", "DescribeDiscoverer", {}).n("SchemasClient", "DescribeDiscovererCommand").f(void 0, void 0).ser(se_DescribeDiscovererCommand).de(de_DescribeDiscovererCommand).build() {
+};
+__name(_DescribeDiscovererCommand, "DescribeDiscovererCommand");
+var DescribeDiscovererCommand = _DescribeDiscovererCommand;
+
+// src/commands/DescribeRegistryCommand.ts
+
+
+
+
+var _DescribeRegistryCommand = class _DescribeRegistryCommand 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("schemas", "DescribeRegistry", {}).n("SchemasClient", "DescribeRegistryCommand").f(void 0, void 0).ser(se_DescribeRegistryCommand).de(de_DescribeRegistryCommand).build() {
+};
+__name(_DescribeRegistryCommand, "DescribeRegistryCommand");
+var DescribeRegistryCommand = _DescribeRegistryCommand;
+
+// src/commands/DescribeSchemaCommand.ts
+
+
+
+
+var _DescribeSchemaCommand = class _DescribeSchemaCommand 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("schemas", "DescribeSchema", {}).n("SchemasClient", "DescribeSchemaCommand").f(void 0, void 0).ser(se_DescribeSchemaCommand).de(de_DescribeSchemaCommand).build() {
+};
+__name(_DescribeSchemaCommand, "DescribeSchemaCommand");
+var DescribeSchemaCommand = _DescribeSchemaCommand;
+
+// src/commands/ExportSchemaCommand.ts
+
+
+
+
+var _ExportSchemaCommand = class _ExportSchemaCommand 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("schemas", "ExportSchema", {}).n("SchemasClient", "ExportSchemaCommand").f(void 0, void 0).ser(se_ExportSchemaCommand).de(de_ExportSchemaCommand).build() {
+};
+__name(_ExportSchemaCommand, "ExportSchemaCommand");
+var ExportSchemaCommand = _ExportSchemaCommand;
+
+// src/commands/GetCodeBindingSourceCommand.ts
+
+
+
+
+var _GetCodeBindingSourceCommand = class _GetCodeBindingSourceCommand 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("schemas", "GetCodeBindingSource", {}).n("SchemasClient", "GetCodeBindingSourceCommand").f(void 0, void 0).ser(se_GetCodeBindingSourceCommand).de(de_GetCodeBindingSourceCommand).build() {
+};
+__name(_GetCodeBindingSourceCommand, "GetCodeBindingSourceCommand");
+var GetCodeBindingSourceCommand = _GetCodeBindingSourceCommand;
+
+// src/commands/GetDiscoveredSchemaCommand.ts
+
+
+
+
+var _GetDiscoveredSchemaCommand = class _GetDiscoveredSchemaCommand 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("schemas", "GetDiscoveredSchema", {}).n("SchemasClient", "GetDiscoveredSchemaCommand").f(void 0, void 0).ser(se_GetDiscoveredSchemaCommand).de(de_GetDiscoveredSchemaCommand).build() {
+};
+__name(_GetDiscoveredSchemaCommand, "GetDiscoveredSchemaCommand");
+var GetDiscoveredSchemaCommand = _GetDiscoveredSchemaCommand;
+
+// src/commands/GetResourcePolicyCommand.ts
+
+
+
+
+var _GetResourcePolicyCommand = class _GetResourcePolicyCommand 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("schemas", "GetResourcePolicy", {}).n("SchemasClient", "GetResourcePolicyCommand").f(void 0, void 0).ser(se_GetResourcePolicyCommand).de(de_GetResourcePolicyCommand).build() {
+};
+__name(_GetResourcePolicyCommand, "GetResourcePolicyCommand");
+var GetResourcePolicyCommand = _GetResourcePolicyCommand;
+
+// src/commands/ListDiscoverersCommand.ts
+
+
+
+
+var _ListDiscoverersCommand = class _ListDiscoverersCommand 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("schemas", "ListDiscoverers", {}).n("SchemasClient", "ListDiscoverersCommand").f(void 0, void 0).ser(se_ListDiscoverersCommand).de(de_ListDiscoverersCommand).build() {
+};
+__name(_ListDiscoverersCommand, "ListDiscoverersCommand");
+var ListDiscoverersCommand = _ListDiscoverersCommand;
+
+// src/commands/ListRegistriesCommand.ts
+
+
+
+
+var _ListRegistriesCommand = class _ListRegistriesCommand 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("schemas", "ListRegistries", {}).n("SchemasClient", "ListRegistriesCommand").f(void 0, void 0).ser(se_ListRegistriesCommand).de(de_ListRegistriesCommand).build() {
+};
+__name(_ListRegistriesCommand, "ListRegistriesCommand");
+var ListRegistriesCommand = _ListRegistriesCommand;
+
+// src/commands/ListSchemasCommand.ts
+
+
+
+
+var _ListSchemasCommand = class _ListSchemasCommand 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("schemas", "ListSchemas", {}).n("SchemasClient", "ListSchemasCommand").f(void 0, void 0).ser(se_ListSchemasCommand).de(de_ListSchemasCommand).build() {
+};
+__name(_ListSchemasCommand, "ListSchemasCommand");
+var ListSchemasCommand = _ListSchemasCommand;
+
+// src/commands/ListSchemaVersionsCommand.ts
+
+
+
+
+var _ListSchemaVersionsCommand = class _ListSchemaVersionsCommand 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("schemas", "ListSchemaVersions", {}).n("SchemasClient", "ListSchemaVersionsCommand").f(void 0, void 0).ser(se_ListSchemaVersionsCommand).de(de_ListSchemaVersionsCommand).build() {
+};
+__name(_ListSchemaVersionsCommand, "ListSchemaVersionsCommand");
+var ListSchemaVersionsCommand = _ListSchemaVersionsCommand;
+
+// 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("schemas", "ListTagsForResource", {}).n("SchemasClient", "ListTagsForResourceCommand").f(void 0, void 0).ser(se_ListTagsForResourceCommand).de(de_ListTagsForResourceCommand).build() {
+};
+__name(_ListTagsForResourceCommand, "ListTagsForResourceCommand");
+var ListTagsForResourceCommand = _ListTagsForResourceCommand;
+
+// src/commands/PutCodeBindingCommand.ts
+
+
+
+
+var _PutCodeBindingCommand = class _PutCodeBindingCommand 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("schemas", "PutCodeBinding", {}).n("SchemasClient", "PutCodeBindingCommand").f(void 0, void 0).ser(se_PutCodeBindingCommand).de(de_PutCodeBindingCommand).build() {
+};
+__name(_PutCodeBindingCommand, "PutCodeBindingCommand");
+var PutCodeBindingCommand = _PutCodeBindingCommand;
+
+// src/commands/PutResourcePolicyCommand.ts
+
+
+
+
+var _PutResourcePolicyCommand = class _PutResourcePolicyCommand 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("schemas", "PutResourcePolicy", {}).n("SchemasClient", "PutResourcePolicyCommand").f(void 0, void 0).ser(se_PutResourcePolicyCommand).de(de_PutResourcePolicyCommand).build() {
+};
+__name(_PutResourcePolicyCommand, "PutResourcePolicyCommand");
+var PutResourcePolicyCommand = _PutResourcePolicyCommand;
+
+// src/commands/SearchSchemasCommand.ts
+
+
+
+
+var _SearchSchemasCommand = class _SearchSchemasCommand 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("schemas", "SearchSchemas", {}).n("SchemasClient", "SearchSchemasCommand").f(void 0, void 0).ser(se_SearchSchemasCommand).de(de_SearchSchemasCommand).build() {
+};
+__name(_SearchSchemasCommand, "SearchSchemasCommand");
+var SearchSchemasCommand = _SearchSchemasCommand;
+
+// src/commands/StartDiscovererCommand.ts
+
+
+
+
+var _StartDiscovererCommand = class _StartDiscovererCommand 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("schemas", "StartDiscoverer", {}).n("SchemasClient", "StartDiscovererCommand").f(void 0, void 0).ser(se_StartDiscovererCommand).de(de_StartDiscovererCommand).build() {
+};
+__name(_StartDiscovererCommand, "StartDiscovererCommand");
+var StartDiscovererCommand = _StartDiscovererCommand;
+
+// src/commands/StopDiscovererCommand.ts
+
+
+
+
+var _StopDiscovererCommand = class _StopDiscovererCommand 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("schemas", "StopDiscoverer", {}).n("SchemasClient", "StopDiscovererCommand").f(void 0, void 0).ser(se_StopDiscovererCommand).de(de_StopDiscovererCommand).build() {
+};
+__name(_StopDiscovererCommand, "StopDiscovererCommand");
+var StopDiscovererCommand = _StopDiscovererCommand;
+
+// 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("schemas", "TagResource", {}).n("SchemasClient", "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("schemas", "UntagResource", {}).n("SchemasClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
+};
+__name(_UntagResourceCommand, "UntagResourceCommand");
+var UntagResourceCommand = _UntagResourceCommand;
+
+// src/commands/UpdateDiscovererCommand.ts
+
+
+
+
+var _UpdateDiscovererCommand = class _UpdateDiscovererCommand 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("schemas", "UpdateDiscoverer", {}).n("SchemasClient", "UpdateDiscovererCommand").f(void 0, void 0).ser(se_UpdateDiscovererCommand).de(de_UpdateDiscovererCommand).build() {
+};
+__name(_UpdateDiscovererCommand, "UpdateDiscovererCommand");
+var UpdateDiscovererCommand = _UpdateDiscovererCommand;
+
+// src/commands/UpdateRegistryCommand.ts
+
+
+
+
+var _UpdateRegistryCommand = class _UpdateRegistryCommand 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("schemas", "UpdateRegistry", {}).n("SchemasClient", "UpdateRegistryCommand").f(void 0, void 0).ser(se_UpdateRegistryCommand).de(de_UpdateRegistryCommand).build() {
+};
+__name(_UpdateRegistryCommand, "UpdateRegistryCommand");
+var UpdateRegistryCommand = _UpdateRegistryCommand;
+
+// src/commands/UpdateSchemaCommand.ts
+
+
+
+
+var _UpdateSchemaCommand = class _UpdateSchemaCommand 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("schemas", "UpdateSchema", {}).n("SchemasClient", "UpdateSchemaCommand").f(void 0, void 0).ser(se_UpdateSchemaCommand).de(de_UpdateSchemaCommand).build() {
+};
+__name(_UpdateSchemaCommand, "UpdateSchemaCommand");
+var UpdateSchemaCommand = _UpdateSchemaCommand;
+
+// src/Schemas.ts
+var commands = {
+  CreateDiscovererCommand,
+  CreateRegistryCommand,
+  CreateSchemaCommand,
+  DeleteDiscovererCommand,
+  DeleteRegistryCommand,
+  DeleteResourcePolicyCommand,
+  DeleteSchemaCommand,
+  DeleteSchemaVersionCommand,
+  DescribeCodeBindingCommand,
+  DescribeDiscovererCommand,
+  DescribeRegistryCommand,
+  DescribeSchemaCommand,
+  ExportSchemaCommand,
+  GetCodeBindingSourceCommand,
+  GetDiscoveredSchemaCommand,
+  GetResourcePolicyCommand,
+  ListDiscoverersCommand,
+  ListRegistriesCommand,
+  ListSchemasCommand,
+  ListSchemaVersionsCommand,
+  ListTagsForResourceCommand,
+  PutCodeBindingCommand,
+  PutResourcePolicyCommand,
+  SearchSchemasCommand,
+  StartDiscovererCommand,
+  StopDiscovererCommand,
+  TagResourceCommand,
+  UntagResourceCommand,
+  UpdateDiscovererCommand,
+  UpdateRegistryCommand,
+  UpdateSchemaCommand
+};
+var _Schemas = class _Schemas extends SchemasClient {
+};
+__name(_Schemas, "Schemas");
+var Schemas = _Schemas;
+(0, import_smithy_client.createAggregatedClient)(commands, Schemas);
+
+// src/pagination/ListDiscoverersPaginator.ts
+
+var paginateListDiscoverers = (0, import_core.createPaginator)(SchemasClient, ListDiscoverersCommand, "NextToken", "NextToken", "Limit");
+
+// src/pagination/ListRegistriesPaginator.ts
+
+var paginateListRegistries = (0, import_core.createPaginator)(SchemasClient, ListRegistriesCommand, "NextToken", "NextToken", "Limit");
+
+// src/pagination/ListSchemaVersionsPaginator.ts
+
+var paginateListSchemaVersions = (0, import_core.createPaginator)(SchemasClient, ListSchemaVersionsCommand, "NextToken", "NextToken", "Limit");
+
+// src/pagination/ListSchemasPaginator.ts
+
+var paginateListSchemas = (0, import_core.createPaginator)(SchemasClient, ListSchemasCommand, "NextToken", "NextToken", "Limit");
+
+// src/pagination/SearchSchemasPaginator.ts
+
+var paginateSearchSchemas = (0, import_core.createPaginator)(SchemasClient, SearchSchemasCommand, "NextToken", "NextToken", "Limit");
+
+// src/waiters/waitForCodeBindingExists.ts
+var import_util_waiter = require("@smithy/util-waiter");
+var checkState = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new DescribeCodeBindingCommand(input));
+    reason = result;
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.Status;
+      }, "returnComparator");
+      if (returnComparator() === "CREATE_COMPLETE") {
+        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.Status;
+      }, "returnComparator");
+      if (returnComparator() === "CREATE_IN_PROGRESS") {
+        return { state: import_util_waiter.WaiterState.RETRY, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.Status;
+      }, "returnComparator");
+      if (returnComparator() === "CREATE_FAILED") {
+        return { state: import_util_waiter.WaiterState.FAILURE, reason };
+      }
+    } catch (e) {
+    }
+  } catch (exception) {
+    reason = exception;
+    if (exception.name && exception.name == "NotFoundException") {
+      return { state: import_util_waiter.WaiterState.FAILURE, reason };
+    }
+  }
+  return { state: import_util_waiter.WaiterState.RETRY, reason };
+}, "checkState");
+var waitForCodeBindingExists = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 2, maxDelay: 120 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+}, "waitForCodeBindingExists");
+var waitUntilCodeBindingExists = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 2, maxDelay: 120 };
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilCodeBindingExists");
+
+// 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 = {
+  BadRequestException,
+  CodeGenerationStatus,
+  ConflictException,
+  CreateDiscovererCommand,
+  CreateRegistryCommand,
+  CreateSchemaCommand,
+  DeleteDiscovererCommand,
+  DeleteRegistryCommand,
+  DeleteResourcePolicyCommand,
+  DeleteSchemaCommand,
+  DeleteSchemaVersionCommand,
+  DescribeCodeBindingCommand,
+  DescribeDiscovererCommand,
+  DescribeRegistryCommand,
+  DescribeSchemaCommand,
+  DiscovererState,
+  ExportSchemaCommand,
+  ForbiddenException,
+  GetCodeBindingSourceCommand,
+  GetDiscoveredSchemaCommand,
+  GetResourcePolicyCommand,
+  GoneException,
+  InternalServerErrorException,
+  ListDiscoverersCommand,
+  ListRegistriesCommand,
+  ListSchemaVersionsCommand,
+  ListSchemasCommand,
+  ListTagsForResourceCommand,
+  NotFoundException,
+  PreconditionFailedException,
+  PutCodeBindingCommand,
+  PutResourcePolicyCommand,
+  Schemas,
+  SchemasClient,
+  SchemasServiceException,
+  SearchSchemasCommand,
+  ServiceUnavailableException,
+  StartDiscovererCommand,
+  StopDiscovererCommand,
+  TagResourceCommand,
+  TooManyRequestsException,
+  Type,
+  UnauthorizedException,
+  UntagResourceCommand,
+  UpdateDiscovererCommand,
+  UpdateRegistryCommand,
+  UpdateSchemaCommand,
+  __Client,
+  paginateListDiscoverers,
+  paginateListRegistries,
+  paginateListSchemaVersions,
+  paginateListSchemas,
+  paginateSearchSchemas,
+  waitForCodeBindingExists,
+  waitUntilCodeBindingExists
+});