@aws-sdk/client-license-manager 3.490.0 → 3.496.0

package/dist-cjs/index.js

@@ -1,11 +1,4822 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LicenseManagerServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./LicenseManagerClient"), exports);
-tslib_1.__exportStar(require("./LicenseManager"), exports);
-tslib_1.__exportStar(require("./commands"), exports);
-tslib_1.__exportStar(require("./models"), exports);
-require("@aws-sdk/util-endpoints");
-var LicenseManagerServiceException_1 = require("./models/LicenseManagerServiceException");
-Object.defineProperty(exports, "LicenseManagerServiceException", { enumerable: true, get: function () { return LicenseManagerServiceException_1.LicenseManagerServiceException; } });
+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, {
+  AcceptGrantCommand: () => AcceptGrantCommand,
+  AccessDeniedException: () => AccessDeniedException,
+  ActivationOverrideBehavior: () => ActivationOverrideBehavior,
+  AllowedOperation: () => AllowedOperation,
+  AuthorizationException: () => AuthorizationException,
+  CheckInLicenseCommand: () => CheckInLicenseCommand,
+  CheckoutBorrowLicenseCommand: () => CheckoutBorrowLicenseCommand,
+  CheckoutLicenseCommand: () => CheckoutLicenseCommand,
+  CheckoutType: () => CheckoutType,
+  ConflictException: () => ConflictException,
+  CreateGrantCommand: () => CreateGrantCommand,
+  CreateGrantVersionCommand: () => CreateGrantVersionCommand,
+  CreateLicenseCommand: () => CreateLicenseCommand,
+  CreateLicenseConfigurationCommand: () => CreateLicenseConfigurationCommand,
+  CreateLicenseConversionTaskForResourceCommand: () => CreateLicenseConversionTaskForResourceCommand,
+  CreateLicenseManagerReportGeneratorCommand: () => CreateLicenseManagerReportGeneratorCommand,
+  CreateLicenseVersionCommand: () => CreateLicenseVersionCommand,
+  CreateTokenCommand: () => CreateTokenCommand,
+  DeleteGrantCommand: () => DeleteGrantCommand,
+  DeleteLicenseCommand: () => DeleteLicenseCommand,
+  DeleteLicenseConfigurationCommand: () => DeleteLicenseConfigurationCommand,
+  DeleteLicenseManagerReportGeneratorCommand: () => DeleteLicenseManagerReportGeneratorCommand,
+  DeleteTokenCommand: () => DeleteTokenCommand,
+  DigitalSignatureMethod: () => DigitalSignatureMethod,
+  EntitlementDataUnit: () => EntitlementDataUnit,
+  EntitlementNotAllowedException: () => EntitlementNotAllowedException,
+  EntitlementUnit: () => EntitlementUnit,
+  ExtendLicenseConsumptionCommand: () => ExtendLicenseConsumptionCommand,
+  FailedDependencyException: () => FailedDependencyException,
+  FilterLimitExceededException: () => FilterLimitExceededException,
+  GetAccessTokenCommand: () => GetAccessTokenCommand,
+  GetGrantCommand: () => GetGrantCommand,
+  GetLicenseCommand: () => GetLicenseCommand,
+  GetLicenseConfigurationCommand: () => GetLicenseConfigurationCommand,
+  GetLicenseConversionTaskCommand: () => GetLicenseConversionTaskCommand,
+  GetLicenseManagerReportGeneratorCommand: () => GetLicenseManagerReportGeneratorCommand,
+  GetLicenseUsageCommand: () => GetLicenseUsageCommand,
+  GetServiceSettingsCommand: () => GetServiceSettingsCommand,
+  GrantStatus: () => GrantStatus,
+  InvalidParameterValueException: () => InvalidParameterValueException,
+  InvalidResourceStateException: () => InvalidResourceStateException,
+  InventoryFilterCondition: () => InventoryFilterCondition,
+  LicenseConfigurationStatus: () => LicenseConfigurationStatus,
+  LicenseConversionTaskStatus: () => LicenseConversionTaskStatus,
+  LicenseCountingType: () => LicenseCountingType,
+  LicenseDeletionStatus: () => LicenseDeletionStatus,
+  LicenseManager: () => LicenseManager,
+  LicenseManagerClient: () => LicenseManagerClient,
+  LicenseManagerServiceException: () => LicenseManagerServiceException,
+  LicenseStatus: () => LicenseStatus,
+  LicenseUsageException: () => LicenseUsageException,
+  ListAssociationsForLicenseConfigurationCommand: () => ListAssociationsForLicenseConfigurationCommand,
+  ListDistributedGrantsCommand: () => ListDistributedGrantsCommand,
+  ListFailuresForLicenseConfigurationOperationsCommand: () => ListFailuresForLicenseConfigurationOperationsCommand,
+  ListLicenseConfigurationsCommand: () => ListLicenseConfigurationsCommand,
+  ListLicenseConversionTasksCommand: () => ListLicenseConversionTasksCommand,
+  ListLicenseManagerReportGeneratorsCommand: () => ListLicenseManagerReportGeneratorsCommand,
+  ListLicenseSpecificationsForResourceCommand: () => ListLicenseSpecificationsForResourceCommand,
+  ListLicenseVersionsCommand: () => ListLicenseVersionsCommand,
+  ListLicensesCommand: () => ListLicensesCommand,
+  ListReceivedGrantsCommand: () => ListReceivedGrantsCommand,
+  ListReceivedGrantsForOrganizationCommand: () => ListReceivedGrantsForOrganizationCommand,
+  ListReceivedLicensesCommand: () => ListReceivedLicensesCommand,
+  ListReceivedLicensesForOrganizationCommand: () => ListReceivedLicensesForOrganizationCommand,
+  ListResourceInventoryCommand: () => ListResourceInventoryCommand,
+  ListTagsForResourceCommand: () => ListTagsForResourceCommand,
+  ListTokensCommand: () => ListTokensCommand,
+  ListUsageForLicenseConfigurationCommand: () => ListUsageForLicenseConfigurationCommand,
+  NoEntitlementsAllowedException: () => NoEntitlementsAllowedException,
+  RateLimitExceededException: () => RateLimitExceededException,
+  ReceivedStatus: () => ReceivedStatus,
+  RedirectException: () => RedirectException,
+  RejectGrantCommand: () => RejectGrantCommand,
+  RenewType: () => RenewType,
+  ReportFrequencyType: () => ReportFrequencyType,
+  ReportType: () => ReportType,
+  ResourceLimitExceededException: () => ResourceLimitExceededException,
+  ResourceNotFoundException: () => ResourceNotFoundException,
+  ResourceType: () => ResourceType,
+  ServerInternalException: () => ServerInternalException,
+  TagResourceCommand: () => TagResourceCommand,
+  TokenType: () => TokenType,
+  UnsupportedDigitalSignatureMethodException: () => UnsupportedDigitalSignatureMethodException,
+  UntagResourceCommand: () => UntagResourceCommand,
+  UpdateLicenseConfigurationCommand: () => UpdateLicenseConfigurationCommand,
+  UpdateLicenseManagerReportGeneratorCommand: () => UpdateLicenseManagerReportGeneratorCommand,
+  UpdateLicenseSpecificationsForResourceCommand: () => UpdateLicenseSpecificationsForResourceCommand,
+  UpdateServiceSettingsCommand: () => UpdateServiceSettingsCommand,
+  ValidationException: () => ValidationException,
+  __Client: () => import_smithy_client.Client
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/LicenseManagerClient.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: "license-manager"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/LicenseManagerClient.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/LicenseManagerClient.ts
+var _LicenseManagerClient = class _LicenseManagerClient 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(_LicenseManagerClient, "LicenseManagerClient");
+var LicenseManagerClient = _LicenseManagerClient;
+
+// src/LicenseManager.ts
+
+
+// src/commands/AcceptGrantCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/protocols/Aws_json1_1.ts
+
+
+
+// src/models/LicenseManagerServiceException.ts
+
+var _LicenseManagerServiceException = class _LicenseManagerServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _LicenseManagerServiceException.prototype);
+  }
+};
+__name(_LicenseManagerServiceException, "LicenseManagerServiceException");
+var LicenseManagerServiceException = _LicenseManagerServiceException;
+
+// src/models/models_0.ts
+var GrantStatus = {
+  ACTIVE: "ACTIVE",
+  DELETED: "DELETED",
+  DISABLED: "DISABLED",
+  FAILED_WORKFLOW: "FAILED_WORKFLOW",
+  PENDING_ACCEPT: "PENDING_ACCEPT",
+  PENDING_DELETE: "PENDING_DELETE",
+  PENDING_WORKFLOW: "PENDING_WORKFLOW",
+  REJECTED: "REJECTED",
+  WORKFLOW_COMPLETED: "WORKFLOW_COMPLETED"
+};
+var _AccessDeniedException = class _AccessDeniedException extends LicenseManagerServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "AccessDeniedException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "AccessDeniedException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _AccessDeniedException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_AccessDeniedException, "AccessDeniedException");
+var AccessDeniedException = _AccessDeniedException;
+var _AuthorizationException = class _AuthorizationException extends LicenseManagerServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "AuthorizationException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "AuthorizationException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _AuthorizationException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_AuthorizationException, "AuthorizationException");
+var AuthorizationException = _AuthorizationException;
+var _InvalidParameterValueException = class _InvalidParameterValueException extends LicenseManagerServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidParameterValueException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidParameterValueException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidParameterValueException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_InvalidParameterValueException, "InvalidParameterValueException");
+var InvalidParameterValueException = _InvalidParameterValueException;
+var _RateLimitExceededException = class _RateLimitExceededException extends LicenseManagerServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "RateLimitExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "RateLimitExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _RateLimitExceededException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_RateLimitExceededException, "RateLimitExceededException");
+var RateLimitExceededException = _RateLimitExceededException;
+var _ResourceLimitExceededException = class _ResourceLimitExceededException extends LicenseManagerServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ResourceLimitExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ResourceLimitExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ResourceLimitExceededException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_ResourceLimitExceededException, "ResourceLimitExceededException");
+var ResourceLimitExceededException = _ResourceLimitExceededException;
+var _ServerInternalException = class _ServerInternalException extends LicenseManagerServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ServerInternalException",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "ServerInternalException";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _ServerInternalException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_ServerInternalException, "ServerInternalException");
+var ServerInternalException = _ServerInternalException;
+var _ValidationException = class _ValidationException extends LicenseManagerServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ValidationException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ValidationException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ValidationException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_ValidationException, "ValidationException");
+var ValidationException = _ValidationException;
+var ActivationOverrideBehavior = {
+  ALL_GRANTS_PERMITTED_BY_ISSUER: "ALL_GRANTS_PERMITTED_BY_ISSUER",
+  DISTRIBUTED_GRANTS_ONLY: "DISTRIBUTED_GRANTS_ONLY"
+};
+var AllowedOperation = {
+  CHECKOUT_BORROW_LICENSE: "CheckoutBorrowLicense",
+  CHECKOUT_LICENSE: "CheckoutLicense",
+  CHECK_IN_LICENSE: "CheckInLicense",
+  CREATE_GRANT: "CreateGrant",
+  CREATE_TOKEN: "CreateToken",
+  EXTEND_CONSUMPTION_LICENSE: "ExtendConsumptionLicense",
+  LIST_PURCHASED_LICENSES: "ListPurchasedLicenses"
+};
+var _ConflictException = class _ConflictException extends LicenseManagerServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ConflictException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ConflictException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ConflictException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_ConflictException, "ConflictException");
+var ConflictException = _ConflictException;
+var _ResourceNotFoundException = class _ResourceNotFoundException extends LicenseManagerServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ResourceNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ResourceNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_ResourceNotFoundException, "ResourceNotFoundException");
+var ResourceNotFoundException = _ResourceNotFoundException;
+var DigitalSignatureMethod = {
+  JWT_PS384: "JWT_PS384"
+};
+var EntitlementDataUnit = {
+  BITS: "Bits",
+  BITS_PER_SECOND: "Bits/Second",
+  BYTES: "Bytes",
+  BYTES_PER_SECOND: "Bytes/Second",
+  COUNT: "Count",
+  COUNT_PER_SECOND: "Count/Second",
+  GIGABITS: "Gigabits",
+  GIGABITS_PER_SECOND: "Gigabits/Second",
+  GIGABYTES: "Gigabytes",
+  GIGABYTES_PER_SECOND: "Gigabytes/Second",
+  KILOBITS: "Kilobits",
+  KILOBITS_PER_SECOND: "Kilobits/Second",
+  KILOBYTES: "Kilobytes",
+  KILOBYTES_PER_SECOND: "Kilobytes/Second",
+  MEGABITS: "Megabits",
+  MEGABITS_PER_SECOND: "Megabits/Second",
+  MEGABYTES: "Megabytes",
+  MEGABYTES_PER_SECOND: "Megabytes/Second",
+  MICROSECONDS: "Microseconds",
+  MILLISECONDS: "Milliseconds",
+  NONE: "None",
+  PERCENT: "Percent",
+  SECONDS: "Seconds",
+  TERABITS: "Terabits",
+  TERABITS_PER_SECOND: "Terabits/Second",
+  TERABYTES: "Terabytes",
+  TERABYTES_PER_SECOND: "Terabytes/Second"
+};
+var _EntitlementNotAllowedException = class _EntitlementNotAllowedException extends LicenseManagerServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "EntitlementNotAllowedException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "EntitlementNotAllowedException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _EntitlementNotAllowedException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_EntitlementNotAllowedException, "EntitlementNotAllowedException");
+var EntitlementNotAllowedException = _EntitlementNotAllowedException;
+var _NoEntitlementsAllowedException = class _NoEntitlementsAllowedException extends LicenseManagerServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "NoEntitlementsAllowedException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "NoEntitlementsAllowedException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _NoEntitlementsAllowedException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_NoEntitlementsAllowedException, "NoEntitlementsAllowedException");
+var NoEntitlementsAllowedException = _NoEntitlementsAllowedException;
+var _RedirectException = class _RedirectException extends LicenseManagerServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "RedirectException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "RedirectException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _RedirectException.prototype);
+    this.Location = opts.Location;
+    this.Message = opts.Message;
+  }
+};
+__name(_RedirectException, "RedirectException");
+var RedirectException = _RedirectException;
+var _UnsupportedDigitalSignatureMethodException = class _UnsupportedDigitalSignatureMethodException extends LicenseManagerServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "UnsupportedDigitalSignatureMethodException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "UnsupportedDigitalSignatureMethodException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _UnsupportedDigitalSignatureMethodException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_UnsupportedDigitalSignatureMethodException, "UnsupportedDigitalSignatureMethodException");
+var UnsupportedDigitalSignatureMethodException = _UnsupportedDigitalSignatureMethodException;
+var CheckoutType = {
+  PERPETUAL: "PERPETUAL",
+  PROVISIONAL: "PROVISIONAL"
+};
+var RenewType = {
+  MONTHLY: "Monthly",
+  NONE: "None",
+  WEEKLY: "Weekly"
+};
+var EntitlementUnit = {
+  BITS: "Bits",
+  BITS_PER_SECOND: "Bits/Second",
+  BYTES: "Bytes",
+  BYTES_PER_SECOND: "Bytes/Second",
+  COUNT: "Count",
+  COUNT_PER_SECOND: "Count/Second",
+  GIGABITS: "Gigabits",
+  GIGABITS_PER_SECOND: "Gigabits/Second",
+  GIGABYTES: "Gigabytes",
+  GIGABYTES_PER_SECOND: "Gigabytes/Second",
+  KILOBITS: "Kilobits",
+  KILOBITS_PER_SECOND: "Kilobits/Second",
+  KILOBYTES: "Kilobytes",
+  KILOBYTES_PER_SECOND: "Kilobytes/Second",
+  MEGABITS: "Megabits",
+  MEGABITS_PER_SECOND: "Megabits/Second",
+  MEGABYTES: "Megabytes",
+  MEGABYTES_PER_SECOND: "Megabytes/Second",
+  MICROSECONDS: "Microseconds",
+  MILLISECONDS: "Milliseconds",
+  NONE: "None",
+  PERCENT: "Percent",
+  SECONDS: "Seconds",
+  TERABITS: "Terabits",
+  TERABITS_PER_SECOND: "Terabits/Second",
+  TERABYTES: "Terabytes",
+  TERABYTES_PER_SECOND: "Terabytes/Second"
+};
+var LicenseStatus = {
+  AVAILABLE: "AVAILABLE",
+  DEACTIVATED: "DEACTIVATED",
+  DELETED: "DELETED",
+  EXPIRED: "EXPIRED",
+  PENDING_AVAILABLE: "PENDING_AVAILABLE",
+  PENDING_DELETE: "PENDING_DELETE",
+  SUSPENDED: "SUSPENDED"
+};
+var LicenseCountingType = {
+  CORE: "Core",
+  INSTANCE: "Instance",
+  SOCKET: "Socket",
+  VCPU: "vCPU"
+};
+var ReportFrequencyType = {
+  DAY: "DAY",
+  MONTH: "MONTH",
+  WEEK: "WEEK"
+};
+var ReportType = {
+  LICENSE_CONFIGURATION_SUMMARY_REPORT: "LicenseConfigurationSummaryReport",
+  LICENSE_CONFIGURATION_USAGE_REPORT: "LicenseConfigurationUsageReport"
+};
+var TokenType = {
+  REFRESH_TOKEN: "REFRESH_TOKEN"
+};
+var LicenseDeletionStatus = {
+  DELETED: "DELETED",
+  PENDING_DELETE: "PENDING_DELETE"
+};
+var ResourceType = {
+  EC2_AMI: "EC2_AMI",
+  EC2_HOST: "EC2_HOST",
+  EC2_INSTANCE: "EC2_INSTANCE",
+  RDS: "RDS",
+  SYSTEMS_MANAGER_MANAGED_INSTANCE: "SYSTEMS_MANAGER_MANAGED_INSTANCE"
+};
+var LicenseConversionTaskStatus = {
+  FAILED: "FAILED",
+  IN_PROGRESS: "IN_PROGRESS",
+  SUCCEEDED: "SUCCEEDED"
+};
+var _FilterLimitExceededException = class _FilterLimitExceededException extends LicenseManagerServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "FilterLimitExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "FilterLimitExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _FilterLimitExceededException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_FilterLimitExceededException, "FilterLimitExceededException");
+var FilterLimitExceededException = _FilterLimitExceededException;
+var ReceivedStatus = {
+  ACTIVE: "ACTIVE",
+  DELETED: "DELETED",
+  DISABLED: "DISABLED",
+  FAILED_WORKFLOW: "FAILED_WORKFLOW",
+  PENDING_ACCEPT: "PENDING_ACCEPT",
+  PENDING_WORKFLOW: "PENDING_WORKFLOW",
+  REJECTED: "REJECTED",
+  WORKFLOW_COMPLETED: "WORKFLOW_COMPLETED"
+};
+var _FailedDependencyException = class _FailedDependencyException extends LicenseManagerServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "FailedDependencyException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "FailedDependencyException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _FailedDependencyException.prototype);
+    this.Message = opts.Message;
+    this.ErrorCode = opts.ErrorCode;
+  }
+};
+__name(_FailedDependencyException, "FailedDependencyException");
+var FailedDependencyException = _FailedDependencyException;
+var InventoryFilterCondition = {
+  BEGINS_WITH: "BEGINS_WITH",
+  CONTAINS: "CONTAINS",
+  EQUALS: "EQUALS",
+  NOT_EQUALS: "NOT_EQUALS"
+};
+var LicenseConfigurationStatus = {
+  AVAILABLE: "AVAILABLE",
+  DISABLED: "DISABLED"
+};
+var _InvalidResourceStateException = class _InvalidResourceStateException extends LicenseManagerServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidResourceStateException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidResourceStateException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidResourceStateException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_InvalidResourceStateException, "InvalidResourceStateException");
+var InvalidResourceStateException = _InvalidResourceStateException;
+var _LicenseUsageException = class _LicenseUsageException extends LicenseManagerServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "LicenseUsageException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "LicenseUsageException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _LicenseUsageException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_LicenseUsageException, "LicenseUsageException");
+var LicenseUsageException = _LicenseUsageException;
+
+// src/protocols/Aws_json1_1.ts
+var se_AcceptGrantCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("AcceptGrant");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_AcceptGrantCommand");
+var se_CheckInLicenseCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CheckInLicense");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CheckInLicenseCommand");
+var se_CheckoutBorrowLicenseCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CheckoutBorrowLicense");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CheckoutBorrowLicenseCommand");
+var se_CheckoutLicenseCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CheckoutLicense");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CheckoutLicenseCommand");
+var se_CreateGrantCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateGrant");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateGrantCommand");
+var se_CreateGrantVersionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateGrantVersion");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateGrantVersionCommand");
+var se_CreateLicenseCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateLicense");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateLicenseCommand");
+var se_CreateLicenseConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateLicenseConfiguration");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateLicenseConfigurationCommand");
+var se_CreateLicenseConversionTaskForResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateLicenseConversionTaskForResource");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateLicenseConversionTaskForResourceCommand");
+var se_CreateLicenseManagerReportGeneratorCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateLicenseManagerReportGenerator");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateLicenseManagerReportGeneratorCommand");
+var se_CreateLicenseVersionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateLicenseVersion");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateLicenseVersionCommand");
+var se_CreateTokenCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateToken");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateTokenCommand");
+var se_DeleteGrantCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteGrant");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteGrantCommand");
+var se_DeleteLicenseCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteLicense");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteLicenseCommand");
+var se_DeleteLicenseConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteLicenseConfiguration");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteLicenseConfigurationCommand");
+var se_DeleteLicenseManagerReportGeneratorCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteLicenseManagerReportGenerator");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteLicenseManagerReportGeneratorCommand");
+var se_DeleteTokenCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteToken");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteTokenCommand");
+var se_ExtendLicenseConsumptionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ExtendLicenseConsumption");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ExtendLicenseConsumptionCommand");
+var se_GetAccessTokenCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetAccessToken");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetAccessTokenCommand");
+var se_GetGrantCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetGrant");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetGrantCommand");
+var se_GetLicenseCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetLicense");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetLicenseCommand");
+var se_GetLicenseConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetLicenseConfiguration");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetLicenseConfigurationCommand");
+var se_GetLicenseConversionTaskCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetLicenseConversionTask");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetLicenseConversionTaskCommand");
+var se_GetLicenseManagerReportGeneratorCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetLicenseManagerReportGenerator");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetLicenseManagerReportGeneratorCommand");
+var se_GetLicenseUsageCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetLicenseUsage");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetLicenseUsageCommand");
+var se_GetServiceSettingsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetServiceSettings");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetServiceSettingsCommand");
+var se_ListAssociationsForLicenseConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListAssociationsForLicenseConfiguration");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListAssociationsForLicenseConfigurationCommand");
+var se_ListDistributedGrantsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListDistributedGrants");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListDistributedGrantsCommand");
+var se_ListFailuresForLicenseConfigurationOperationsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListFailuresForLicenseConfigurationOperations");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListFailuresForLicenseConfigurationOperationsCommand");
+var se_ListLicenseConfigurationsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListLicenseConfigurations");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListLicenseConfigurationsCommand");
+var se_ListLicenseConversionTasksCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListLicenseConversionTasks");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListLicenseConversionTasksCommand");
+var se_ListLicenseManagerReportGeneratorsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListLicenseManagerReportGenerators");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListLicenseManagerReportGeneratorsCommand");
+var se_ListLicensesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListLicenses");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListLicensesCommand");
+var se_ListLicenseSpecificationsForResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListLicenseSpecificationsForResource");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListLicenseSpecificationsForResourceCommand");
+var se_ListLicenseVersionsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListLicenseVersions");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListLicenseVersionsCommand");
+var se_ListReceivedGrantsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListReceivedGrants");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListReceivedGrantsCommand");
+var se_ListReceivedGrantsForOrganizationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListReceivedGrantsForOrganization");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListReceivedGrantsForOrganizationCommand");
+var se_ListReceivedLicensesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListReceivedLicenses");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListReceivedLicensesCommand");
+var se_ListReceivedLicensesForOrganizationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListReceivedLicensesForOrganization");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListReceivedLicensesForOrganizationCommand");
+var se_ListResourceInventoryCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListResourceInventory");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListResourceInventoryCommand");
+var se_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListTagsForResource");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListTagsForResourceCommand");
+var se_ListTokensCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListTokens");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListTokensCommand");
+var se_ListUsageForLicenseConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListUsageForLicenseConfiguration");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListUsageForLicenseConfigurationCommand");
+var se_RejectGrantCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("RejectGrant");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_RejectGrantCommand");
+var se_TagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("TagResource");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_TagResourceCommand");
+var se_UntagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UntagResource");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UntagResourceCommand");
+var se_UpdateLicenseConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateLicenseConfiguration");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateLicenseConfigurationCommand");
+var se_UpdateLicenseManagerReportGeneratorCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateLicenseManagerReportGenerator");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateLicenseManagerReportGeneratorCommand");
+var se_UpdateLicenseSpecificationsForResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateLicenseSpecificationsForResource");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateLicenseSpecificationsForResourceCommand");
+var se_UpdateServiceSettingsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateServiceSettings");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateServiceSettingsCommand");
+var de_AcceptGrantCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_AcceptGrantCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_AcceptGrantCommand");
+var de_AcceptGrantCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.licensemanager#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceLimitExceededException":
+    case "com.amazonaws.licensemanager#ResourceLimitExceededException":
+      throw await de_ResourceLimitExceededExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.licensemanager#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_AcceptGrantCommandError");
+var de_CheckInLicenseCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CheckInLicenseCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CheckInLicenseCommand");
+var de_CheckInLicenseCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.licensemanager#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.licensemanager#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.licensemanager#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.licensemanager#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CheckInLicenseCommandError");
+var de_CheckoutBorrowLicenseCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CheckoutBorrowLicenseCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CheckoutBorrowLicenseCommand");
+var de_CheckoutBorrowLicenseCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "EntitlementNotAllowedException":
+    case "com.amazonaws.licensemanager#EntitlementNotAllowedException":
+      throw await de_EntitlementNotAllowedExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.licensemanager#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "NoEntitlementsAllowedException":
+    case "com.amazonaws.licensemanager#NoEntitlementsAllowedException":
+      throw await de_NoEntitlementsAllowedExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "RedirectException":
+    case "com.amazonaws.licensemanager#RedirectException":
+      throw await de_RedirectExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.licensemanager#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    case "UnsupportedDigitalSignatureMethodException":
+    case "com.amazonaws.licensemanager#UnsupportedDigitalSignatureMethodException":
+      throw await de_UnsupportedDigitalSignatureMethodExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.licensemanager#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CheckoutBorrowLicenseCommandError");
+var de_CheckoutLicenseCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CheckoutLicenseCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CheckoutLicenseCommand");
+var de_CheckoutLicenseCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.licensemanager#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "NoEntitlementsAllowedException":
+    case "com.amazonaws.licensemanager#NoEntitlementsAllowedException":
+      throw await de_NoEntitlementsAllowedExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "RedirectException":
+    case "com.amazonaws.licensemanager#RedirectException":
+      throw await de_RedirectExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.licensemanager#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    case "UnsupportedDigitalSignatureMethodException":
+    case "com.amazonaws.licensemanager#UnsupportedDigitalSignatureMethodException":
+      throw await de_UnsupportedDigitalSignatureMethodExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.licensemanager#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CheckoutLicenseCommandError");
+var de_CreateGrantCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateGrantCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateGrantCommand");
+var de_CreateGrantCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.licensemanager#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceLimitExceededException":
+    case "com.amazonaws.licensemanager#ResourceLimitExceededException":
+      throw await de_ResourceLimitExceededExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.licensemanager#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateGrantCommandError");
+var de_CreateGrantVersionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateGrantVersionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateGrantVersionCommand");
+var de_CreateGrantVersionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.licensemanager#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceLimitExceededException":
+    case "com.amazonaws.licensemanager#ResourceLimitExceededException":
+      throw await de_ResourceLimitExceededExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.licensemanager#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateGrantVersionCommandError");
+var de_CreateLicenseCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateLicenseCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateLicenseCommand");
+var de_CreateLicenseCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.licensemanager#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "RedirectException":
+    case "com.amazonaws.licensemanager#RedirectException":
+      throw await de_RedirectExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.licensemanager#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateLicenseCommandError");
+var de_CreateLicenseConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateLicenseConfigurationCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateLicenseConfigurationCommand");
+var de_CreateLicenseConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.licensemanager#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceLimitExceededException":
+    case "com.amazonaws.licensemanager#ResourceLimitExceededException":
+      throw await de_ResourceLimitExceededExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateLicenseConfigurationCommandError");
+var de_CreateLicenseConversionTaskForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateLicenseConversionTaskForResourceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateLicenseConversionTaskForResourceCommand");
+var de_CreateLicenseConversionTaskForResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.licensemanager#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.licensemanager#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateLicenseConversionTaskForResourceCommandError");
+var de_CreateLicenseManagerReportGeneratorCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateLicenseManagerReportGeneratorCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateLicenseManagerReportGeneratorCommand");
+var de_CreateLicenseManagerReportGeneratorCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.licensemanager#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceLimitExceededException":
+    case "com.amazonaws.licensemanager#ResourceLimitExceededException":
+      throw await de_ResourceLimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.licensemanager#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.licensemanager#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateLicenseManagerReportGeneratorCommandError");
+var de_CreateLicenseVersionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateLicenseVersionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateLicenseVersionCommand");
+var de_CreateLicenseVersionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.licensemanager#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "RedirectException":
+    case "com.amazonaws.licensemanager#RedirectException":
+      throw await de_RedirectExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.licensemanager#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.licensemanager#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateLicenseVersionCommandError");
+var de_CreateTokenCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateTokenCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateTokenCommand");
+var de_CreateTokenCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "RedirectException":
+    case "com.amazonaws.licensemanager#RedirectException":
+      throw await de_RedirectExceptionRes(parsedOutput, context);
+    case "ResourceLimitExceededException":
+    case "com.amazonaws.licensemanager#ResourceLimitExceededException":
+      throw await de_ResourceLimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.licensemanager#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.licensemanager#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateTokenCommandError");
+var de_DeleteGrantCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteGrantCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteGrantCommand");
+var de_DeleteGrantCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.licensemanager#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceLimitExceededException":
+    case "com.amazonaws.licensemanager#ResourceLimitExceededException":
+      throw await de_ResourceLimitExceededExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.licensemanager#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteGrantCommandError");
+var de_DeleteLicenseCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteLicenseCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteLicenseCommand");
+var de_DeleteLicenseCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.licensemanager#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.licensemanager#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "RedirectException":
+    case "com.amazonaws.licensemanager#RedirectException":
+      throw await de_RedirectExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.licensemanager#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteLicenseCommandError");
+var de_DeleteLicenseConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteLicenseConfigurationCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteLicenseConfigurationCommand");
+var de_DeleteLicenseConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.licensemanager#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteLicenseConfigurationCommandError");
+var de_DeleteLicenseManagerReportGeneratorCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteLicenseManagerReportGeneratorCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteLicenseManagerReportGeneratorCommand");
+var de_DeleteLicenseManagerReportGeneratorCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.licensemanager#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceLimitExceededException":
+    case "com.amazonaws.licensemanager#ResourceLimitExceededException":
+      throw await de_ResourceLimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.licensemanager#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.licensemanager#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteLicenseManagerReportGeneratorCommandError");
+var de_DeleteTokenCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteTokenCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteTokenCommand");
+var de_DeleteTokenCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "RedirectException":
+    case "com.amazonaws.licensemanager#RedirectException":
+      throw await de_RedirectExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.licensemanager#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.licensemanager#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteTokenCommandError");
+var de_ExtendLicenseConsumptionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ExtendLicenseConsumptionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ExtendLicenseConsumptionCommand");
+var de_ExtendLicenseConsumptionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.licensemanager#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.licensemanager#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.licensemanager#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ExtendLicenseConsumptionCommandError");
+var de_GetAccessTokenCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetAccessTokenCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetAccessTokenCommand");
+var de_GetAccessTokenCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.licensemanager#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetAccessTokenCommandError");
+var de_GetGrantCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetGrantCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetGrantCommand");
+var de_GetGrantCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.licensemanager#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceLimitExceededException":
+    case "com.amazonaws.licensemanager#ResourceLimitExceededException":
+      throw await de_ResourceLimitExceededExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.licensemanager#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetGrantCommandError");
+var de_GetLicenseCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetLicenseCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetLicenseCommand");
+var de_GetLicenseCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.licensemanager#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.licensemanager#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetLicenseCommandError");
+var de_GetLicenseConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetLicenseConfigurationCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_GetLicenseConfigurationResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetLicenseConfigurationCommand");
+var de_GetLicenseConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.licensemanager#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetLicenseConfigurationCommandError");
+var de_GetLicenseConversionTaskCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetLicenseConversionTaskCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_GetLicenseConversionTaskResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetLicenseConversionTaskCommand");
+var de_GetLicenseConversionTaskCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.licensemanager#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetLicenseConversionTaskCommandError");
+var de_GetLicenseManagerReportGeneratorCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetLicenseManagerReportGeneratorCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetLicenseManagerReportGeneratorCommand");
+var de_GetLicenseManagerReportGeneratorCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.licensemanager#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceLimitExceededException":
+    case "com.amazonaws.licensemanager#ResourceLimitExceededException":
+      throw await de_ResourceLimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.licensemanager#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.licensemanager#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetLicenseManagerReportGeneratorCommandError");
+var de_GetLicenseUsageCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetLicenseUsageCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetLicenseUsageCommand");
+var de_GetLicenseUsageCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.licensemanager#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.licensemanager#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetLicenseUsageCommandError");
+var de_GetServiceSettingsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetServiceSettingsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetServiceSettingsCommand");
+var de_GetServiceSettingsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetServiceSettingsCommandError");
+var de_ListAssociationsForLicenseConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListAssociationsForLicenseConfigurationCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListAssociationsForLicenseConfigurationResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListAssociationsForLicenseConfigurationCommand");
+var de_ListAssociationsForLicenseConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "FilterLimitExceededException":
+    case "com.amazonaws.licensemanager#FilterLimitExceededException":
+      throw await de_FilterLimitExceededExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.licensemanager#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListAssociationsForLicenseConfigurationCommandError");
+var de_ListDistributedGrantsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListDistributedGrantsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListDistributedGrantsCommand");
+var de_ListDistributedGrantsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.licensemanager#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceLimitExceededException":
+    case "com.amazonaws.licensemanager#ResourceLimitExceededException":
+      throw await de_ResourceLimitExceededExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.licensemanager#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListDistributedGrantsCommandError");
+var de_ListFailuresForLicenseConfigurationOperationsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListFailuresForLicenseConfigurationOperationsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListFailuresForLicenseConfigurationOperationsResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListFailuresForLicenseConfigurationOperationsCommand");
+var de_ListFailuresForLicenseConfigurationOperationsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.licensemanager#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListFailuresForLicenseConfigurationOperationsCommandError");
+var de_ListLicenseConfigurationsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListLicenseConfigurationsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListLicenseConfigurationsResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListLicenseConfigurationsCommand");
+var de_ListLicenseConfigurationsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "FilterLimitExceededException":
+    case "com.amazonaws.licensemanager#FilterLimitExceededException":
+      throw await de_FilterLimitExceededExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.licensemanager#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListLicenseConfigurationsCommandError");
+var de_ListLicenseConversionTasksCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListLicenseConversionTasksCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListLicenseConversionTasksResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListLicenseConversionTasksCommand");
+var de_ListLicenseConversionTasksCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.licensemanager#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListLicenseConversionTasksCommandError");
+var de_ListLicenseManagerReportGeneratorsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListLicenseManagerReportGeneratorsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListLicenseManagerReportGeneratorsCommand");
+var de_ListLicenseManagerReportGeneratorsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.licensemanager#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceLimitExceededException":
+    case "com.amazonaws.licensemanager#ResourceLimitExceededException":
+      throw await de_ResourceLimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.licensemanager#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.licensemanager#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListLicenseManagerReportGeneratorsCommandError");
+var de_ListLicensesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListLicensesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListLicensesCommand");
+var de_ListLicensesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.licensemanager#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.licensemanager#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListLicensesCommandError");
+var de_ListLicenseSpecificationsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListLicenseSpecificationsForResourceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListLicenseSpecificationsForResourceCommand");
+var de_ListLicenseSpecificationsForResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.licensemanager#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListLicenseSpecificationsForResourceCommandError");
+var de_ListLicenseVersionsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListLicenseVersionsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListLicenseVersionsCommand");
+var de_ListLicenseVersionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.licensemanager#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListLicenseVersionsCommandError");
+var de_ListReceivedGrantsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListReceivedGrantsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListReceivedGrantsCommand");
+var de_ListReceivedGrantsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.licensemanager#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceLimitExceededException":
+    case "com.amazonaws.licensemanager#ResourceLimitExceededException":
+      throw await de_ResourceLimitExceededExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.licensemanager#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListReceivedGrantsCommandError");
+var de_ListReceivedGrantsForOrganizationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListReceivedGrantsForOrganizationCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListReceivedGrantsForOrganizationCommand");
+var de_ListReceivedGrantsForOrganizationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.licensemanager#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceLimitExceededException":
+    case "com.amazonaws.licensemanager#ResourceLimitExceededException":
+      throw await de_ResourceLimitExceededExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.licensemanager#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListReceivedGrantsForOrganizationCommandError");
+var de_ListReceivedLicensesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListReceivedLicensesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListReceivedLicensesCommand");
+var de_ListReceivedLicensesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.licensemanager#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceLimitExceededException":
+    case "com.amazonaws.licensemanager#ResourceLimitExceededException":
+      throw await de_ResourceLimitExceededExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.licensemanager#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListReceivedLicensesCommandError");
+var de_ListReceivedLicensesForOrganizationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListReceivedLicensesForOrganizationCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListReceivedLicensesForOrganizationCommand");
+var de_ListReceivedLicensesForOrganizationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.licensemanager#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceLimitExceededException":
+    case "com.amazonaws.licensemanager#ResourceLimitExceededException":
+      throw await de_ResourceLimitExceededExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.licensemanager#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListReceivedLicensesForOrganizationCommandError");
+var de_ListResourceInventoryCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListResourceInventoryCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListResourceInventoryCommand");
+var de_ListResourceInventoryCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "FailedDependencyException":
+    case "com.amazonaws.licensemanager#FailedDependencyException":
+      throw await de_FailedDependencyExceptionRes(parsedOutput, context);
+    case "FilterLimitExceededException":
+    case "com.amazonaws.licensemanager#FilterLimitExceededException":
+      throw await de_FilterLimitExceededExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.licensemanager#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListResourceInventoryCommandError");
+var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListTagsForResourceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListTagsForResourceCommand");
+var de_ListTagsForResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.licensemanager#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListTagsForResourceCommandError");
+var de_ListTokensCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListTokensCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListTokensCommand");
+var de_ListTokensCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.licensemanager#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListTokensCommandError");
+var de_ListUsageForLicenseConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListUsageForLicenseConfigurationCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListUsageForLicenseConfigurationResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListUsageForLicenseConfigurationCommand");
+var de_ListUsageForLicenseConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "FilterLimitExceededException":
+    case "com.amazonaws.licensemanager#FilterLimitExceededException":
+      throw await de_FilterLimitExceededExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.licensemanager#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListUsageForLicenseConfigurationCommandError");
+var de_RejectGrantCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_RejectGrantCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_RejectGrantCommand");
+var de_RejectGrantCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.licensemanager#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceLimitExceededException":
+    case "com.amazonaws.licensemanager#ResourceLimitExceededException":
+      throw await de_ResourceLimitExceededExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.licensemanager#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_RejectGrantCommandError");
+var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_TagResourceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_TagResourceCommand");
+var de_TagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.licensemanager#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_TagResourceCommandError");
+var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UntagResourceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UntagResourceCommand");
+var de_UntagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.licensemanager#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UntagResourceCommandError");
+var de_UpdateLicenseConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateLicenseConfigurationCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateLicenseConfigurationCommand");
+var de_UpdateLicenseConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.licensemanager#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceLimitExceededException":
+    case "com.amazonaws.licensemanager#ResourceLimitExceededException":
+      throw await de_ResourceLimitExceededExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateLicenseConfigurationCommandError");
+var de_UpdateLicenseManagerReportGeneratorCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateLicenseManagerReportGeneratorCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateLicenseManagerReportGeneratorCommand");
+var de_UpdateLicenseManagerReportGeneratorCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.licensemanager#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceLimitExceededException":
+    case "com.amazonaws.licensemanager#ResourceLimitExceededException":
+      throw await de_ResourceLimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.licensemanager#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.licensemanager#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateLicenseManagerReportGeneratorCommandError");
+var de_UpdateLicenseSpecificationsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateLicenseSpecificationsForResourceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateLicenseSpecificationsForResourceCommand");
+var de_UpdateLicenseSpecificationsForResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.licensemanager#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "InvalidResourceStateException":
+    case "com.amazonaws.licensemanager#InvalidResourceStateException":
+      throw await de_InvalidResourceStateExceptionRes(parsedOutput, context);
+    case "LicenseUsageException":
+    case "com.amazonaws.licensemanager#LicenseUsageException":
+      throw await de_LicenseUsageExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateLicenseSpecificationsForResourceCommandError");
+var de_UpdateServiceSettingsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateServiceSettingsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateServiceSettingsCommand");
+var de_UpdateServiceSettingsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.licensemanager#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "AuthorizationException":
+    case "com.amazonaws.licensemanager#AuthorizationException":
+      throw await de_AuthorizationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.licensemanager#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "RateLimitExceededException":
+    case "com.amazonaws.licensemanager#RateLimitExceededException":
+      throw await de_RateLimitExceededExceptionRes(parsedOutput, context);
+    case "ServerInternalException":
+    case "com.amazonaws.licensemanager#ServerInternalException":
+      throw await de_ServerInternalExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateServiceSettingsCommandError");
+var de_AccessDeniedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new AccessDeniedException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_AccessDeniedExceptionRes");
+var de_AuthorizationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new AuthorizationException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_AuthorizationExceptionRes");
+var de_ConflictExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ConflictException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ConflictExceptionRes");
+var de_EntitlementNotAllowedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new EntitlementNotAllowedException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_EntitlementNotAllowedExceptionRes");
+var de_FailedDependencyExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new FailedDependencyException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_FailedDependencyExceptionRes");
+var de_FilterLimitExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new FilterLimitExceededException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_FilterLimitExceededExceptionRes");
+var de_InvalidParameterValueExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidParameterValueException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidParameterValueExceptionRes");
+var de_InvalidResourceStateExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidResourceStateException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidResourceStateExceptionRes");
+var de_LicenseUsageExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new LicenseUsageException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_LicenseUsageExceptionRes");
+var de_NoEntitlementsAllowedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new NoEntitlementsAllowedException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_NoEntitlementsAllowedExceptionRes");
+var de_RateLimitExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new RateLimitExceededException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_RateLimitExceededExceptionRes");
+var de_RedirectExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new RedirectException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_RedirectExceptionRes");
+var de_ResourceLimitExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ResourceLimitExceededException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ResourceLimitExceededExceptionRes");
+var de_ResourceNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ResourceNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ResourceNotFoundExceptionRes");
+var de_ServerInternalExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ServerInternalException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ServerInternalExceptionRes");
+var de_UnsupportedDigitalSignatureMethodExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new UnsupportedDigitalSignatureMethodException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_UnsupportedDigitalSignatureMethodExceptionRes");
+var de_ValidationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ValidationException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ValidationExceptionRes");
+var de_AutomatedDiscoveryInformation = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    LastRunTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_)))
+  });
+}, "de_AutomatedDiscoveryInformation");
+var de_GetLicenseConfigurationResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AutomatedDiscoveryInformation: (_) => de_AutomatedDiscoveryInformation(_, context),
+    ConsumedLicenseSummaryList: import_smithy_client._json,
+    ConsumedLicenses: import_smithy_client.expectLong,
+    Description: import_smithy_client.expectString,
+    DisassociateWhenNotFound: import_smithy_client.expectBoolean,
+    LicenseConfigurationArn: import_smithy_client.expectString,
+    LicenseConfigurationId: import_smithy_client.expectString,
+    LicenseCount: import_smithy_client.expectLong,
+    LicenseCountHardLimit: import_smithy_client.expectBoolean,
+    LicenseCountingType: import_smithy_client.expectString,
+    LicenseRules: import_smithy_client._json,
+    ManagedResourceSummaryList: import_smithy_client._json,
+    Name: import_smithy_client.expectString,
+    OwnerAccountId: import_smithy_client.expectString,
+    ProductInformationList: import_smithy_client._json,
+    Status: import_smithy_client.expectString,
+    Tags: import_smithy_client._json
+  });
+}, "de_GetLicenseConfigurationResponse");
+var de_GetLicenseConversionTaskResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    DestinationLicenseContext: import_smithy_client._json,
+    EndTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    LicenseConversionTaskId: import_smithy_client.expectString,
+    LicenseConversionTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    ResourceArn: import_smithy_client.expectString,
+    SourceLicenseContext: import_smithy_client._json,
+    StartTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Status: import_smithy_client.expectString,
+    StatusMessage: import_smithy_client.expectString
+  });
+}, "de_GetLicenseConversionTaskResponse");
+var de_LicenseConfiguration = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AutomatedDiscoveryInformation: (_) => de_AutomatedDiscoveryInformation(_, context),
+    ConsumedLicenseSummaryList: import_smithy_client._json,
+    ConsumedLicenses: import_smithy_client.expectLong,
+    Description: import_smithy_client.expectString,
+    DisassociateWhenNotFound: import_smithy_client.expectBoolean,
+    LicenseConfigurationArn: import_smithy_client.expectString,
+    LicenseConfigurationId: import_smithy_client.expectString,
+    LicenseCount: import_smithy_client.expectLong,
+    LicenseCountHardLimit: import_smithy_client.expectBoolean,
+    LicenseCountingType: import_smithy_client.expectString,
+    LicenseRules: import_smithy_client._json,
+    ManagedResourceSummaryList: import_smithy_client._json,
+    Name: import_smithy_client.expectString,
+    OwnerAccountId: import_smithy_client.expectString,
+    ProductInformationList: import_smithy_client._json,
+    Status: import_smithy_client.expectString
+  });
+}, "de_LicenseConfiguration");
+var de_LicenseConfigurationAssociation = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AmiAssociationScope: import_smithy_client.expectString,
+    AssociationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    ResourceArn: import_smithy_client.expectString,
+    ResourceOwnerId: import_smithy_client.expectString,
+    ResourceType: import_smithy_client.expectString
+  });
+}, "de_LicenseConfigurationAssociation");
+var de_LicenseConfigurationAssociations = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_LicenseConfigurationAssociation(entry, context);
+  });
+  return retVal;
+}, "de_LicenseConfigurationAssociations");
+var de_LicenseConfigurations = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_LicenseConfiguration(entry, context);
+  });
+  return retVal;
+}, "de_LicenseConfigurations");
+var de_LicenseConfigurationUsage = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AssociationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    ConsumedLicenses: import_smithy_client.expectLong,
+    ResourceArn: import_smithy_client.expectString,
+    ResourceOwnerId: import_smithy_client.expectString,
+    ResourceStatus: import_smithy_client.expectString,
+    ResourceType: import_smithy_client.expectString
+  });
+}, "de_LicenseConfigurationUsage");
+var de_LicenseConfigurationUsageList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_LicenseConfigurationUsage(entry, context);
+  });
+  return retVal;
+}, "de_LicenseConfigurationUsageList");
+var de_LicenseConversionTask = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    DestinationLicenseContext: import_smithy_client._json,
+    EndTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    LicenseConversionTaskId: import_smithy_client.expectString,
+    LicenseConversionTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    ResourceArn: import_smithy_client.expectString,
+    SourceLicenseContext: import_smithy_client._json,
+    StartTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Status: import_smithy_client.expectString,
+    StatusMessage: import_smithy_client.expectString
+  });
+}, "de_LicenseConversionTask");
+var de_LicenseConversionTasks = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_LicenseConversionTask(entry, context);
+  });
+  return retVal;
+}, "de_LicenseConversionTasks");
+var de_LicenseOperationFailure = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    ErrorMessage: import_smithy_client.expectString,
+    FailureTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    MetadataList: import_smithy_client._json,
+    OperationName: import_smithy_client.expectString,
+    OperationRequestedBy: import_smithy_client.expectString,
+    ResourceArn: import_smithy_client.expectString,
+    ResourceOwnerId: import_smithy_client.expectString,
+    ResourceType: import_smithy_client.expectString
+  });
+}, "de_LicenseOperationFailure");
+var de_LicenseOperationFailureList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_LicenseOperationFailure(entry, context);
+  });
+  return retVal;
+}, "de_LicenseOperationFailureList");
+var de_ListAssociationsForLicenseConfigurationResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    LicenseConfigurationAssociations: (_) => de_LicenseConfigurationAssociations(_, context),
+    NextToken: import_smithy_client.expectString
+  });
+}, "de_ListAssociationsForLicenseConfigurationResponse");
+var de_ListFailuresForLicenseConfigurationOperationsResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    LicenseOperationFailureList: (_) => de_LicenseOperationFailureList(_, context),
+    NextToken: import_smithy_client.expectString
+  });
+}, "de_ListFailuresForLicenseConfigurationOperationsResponse");
+var de_ListLicenseConfigurationsResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    LicenseConfigurations: (_) => de_LicenseConfigurations(_, context),
+    NextToken: import_smithy_client.expectString
+  });
+}, "de_ListLicenseConfigurationsResponse");
+var de_ListLicenseConversionTasksResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    LicenseConversionTasks: (_) => de_LicenseConversionTasks(_, context),
+    NextToken: import_smithy_client.expectString
+  });
+}, "de_ListLicenseConversionTasksResponse");
+var de_ListUsageForLicenseConfigurationResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    LicenseConfigurationUsageList: (_) => de_LicenseConfigurationUsageList(_, context),
+    NextToken: import_smithy_client.expectString
+  });
+}, "de_ListUsageForLicenseConfigurationResponse");
+var deserializeMetadata = /* @__PURE__ */ __name((output) => ({
+  httpStatusCode: output.statusCode,
+  requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
+  extendedRequestId: output.headers["x-amz-id-2"],
+  cfId: output.headers["x-amz-cf-id"]
+}), "deserializeMetadata");
+var collectBodyString = /* @__PURE__ */ __name((streamBody, context) => (0, import_smithy_client.collectBody)(streamBody, context).then((body) => context.utf8Encoder(body)), "collectBodyString");
+var throwDefaultError = (0, import_smithy_client.withBaseException)(LicenseManagerServiceException);
+var buildHttpRpcRequest = /* @__PURE__ */ __name(async (context, headers, path, resolvedHostname, body) => {
+  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+  const contents = {
+    protocol,
+    hostname,
+    port,
+    method: "POST",
+    path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
+    headers
+  };
+  if (resolvedHostname !== void 0) {
+    contents.hostname = resolvedHostname;
+  }
+  if (body !== void 0) {
+    contents.body = body;
+  }
+  return new import_protocol_http.HttpRequest(contents);
+}, "buildHttpRpcRequest");
+function sharedHeaders(operation) {
+  return {
+    "content-type": "application/x-amz-json-1.1",
+    "x-amz-target": `AWSLicenseManager.${operation}`
+  };
+}
+__name(sharedHeaders, "sharedHeaders");
+var parseBody = /* @__PURE__ */ __name((streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
+  if (encoded.length) {
+    return JSON.parse(encoded);
+  }
+  return {};
+}), "parseBody");
+var parseErrorBody = /* @__PURE__ */ __name(async (errorBody, context) => {
+  const value = await parseBody(errorBody, context);
+  value.message = value.message ?? value.Message;
+  return value;
+}, "parseErrorBody");
+var loadRestJsonErrorCode = /* @__PURE__ */ __name((output, data) => {
+  const findKey = /* @__PURE__ */ __name((object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase()), "findKey");
+  const sanitizeErrorCode = /* @__PURE__ */ __name((rawValue) => {
+    let cleanValue = rawValue;
+    if (typeof cleanValue === "number") {
+      cleanValue = cleanValue.toString();
+    }
+    if (cleanValue.indexOf(",") >= 0) {
+      cleanValue = cleanValue.split(",")[0];
+    }
+    if (cleanValue.indexOf(":") >= 0) {
+      cleanValue = cleanValue.split(":")[0];
+    }
+    if (cleanValue.indexOf("#") >= 0) {
+      cleanValue = cleanValue.split("#")[1];
+    }
+    return cleanValue;
+  }, "sanitizeErrorCode");
+  const headerKey = findKey(output.headers, "x-amzn-errortype");
+  if (headerKey !== void 0) {
+    return sanitizeErrorCode(output.headers[headerKey]);
+  }
+  if (data.code !== void 0) {
+    return sanitizeErrorCode(data.code);
+  }
+  if (data["__type"] !== void 0) {
+    return sanitizeErrorCode(data["__type"]);
+  }
+}, "loadRestJsonErrorCode");
+
+// src/commands/AcceptGrantCommand.ts
+var _AcceptGrantCommand = class _AcceptGrantCommand 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("AWSLicenseManager", "AcceptGrant", {}).n("LicenseManagerClient", "AcceptGrantCommand").f(void 0, void 0).ser(se_AcceptGrantCommand).de(de_AcceptGrantCommand).build() {
+};
+__name(_AcceptGrantCommand, "AcceptGrantCommand");
+var AcceptGrantCommand = _AcceptGrantCommand;
+
+// src/commands/CheckInLicenseCommand.ts
+
+
+
+
+var _CheckInLicenseCommand = class _CheckInLicenseCommand 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("AWSLicenseManager", "CheckInLicense", {}).n("LicenseManagerClient", "CheckInLicenseCommand").f(void 0, void 0).ser(se_CheckInLicenseCommand).de(de_CheckInLicenseCommand).build() {
+};
+__name(_CheckInLicenseCommand, "CheckInLicenseCommand");
+var CheckInLicenseCommand = _CheckInLicenseCommand;
+
+// src/commands/CheckoutBorrowLicenseCommand.ts
+
+
+
+
+var _CheckoutBorrowLicenseCommand = class _CheckoutBorrowLicenseCommand 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("AWSLicenseManager", "CheckoutBorrowLicense", {}).n("LicenseManagerClient", "CheckoutBorrowLicenseCommand").f(void 0, void 0).ser(se_CheckoutBorrowLicenseCommand).de(de_CheckoutBorrowLicenseCommand).build() {
+};
+__name(_CheckoutBorrowLicenseCommand, "CheckoutBorrowLicenseCommand");
+var CheckoutBorrowLicenseCommand = _CheckoutBorrowLicenseCommand;
+
+// src/commands/CheckoutLicenseCommand.ts
+
+
+
+
+var _CheckoutLicenseCommand = class _CheckoutLicenseCommand 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("AWSLicenseManager", "CheckoutLicense", {}).n("LicenseManagerClient", "CheckoutLicenseCommand").f(void 0, void 0).ser(se_CheckoutLicenseCommand).de(de_CheckoutLicenseCommand).build() {
+};
+__name(_CheckoutLicenseCommand, "CheckoutLicenseCommand");
+var CheckoutLicenseCommand = _CheckoutLicenseCommand;
+
+// src/commands/CreateGrantCommand.ts
+
+
+
+
+var _CreateGrantCommand = class _CreateGrantCommand 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("AWSLicenseManager", "CreateGrant", {}).n("LicenseManagerClient", "CreateGrantCommand").f(void 0, void 0).ser(se_CreateGrantCommand).de(de_CreateGrantCommand).build() {
+};
+__name(_CreateGrantCommand, "CreateGrantCommand");
+var CreateGrantCommand = _CreateGrantCommand;
+
+// src/commands/CreateGrantVersionCommand.ts
+
+
+
+
+var _CreateGrantVersionCommand = class _CreateGrantVersionCommand 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("AWSLicenseManager", "CreateGrantVersion", {}).n("LicenseManagerClient", "CreateGrantVersionCommand").f(void 0, void 0).ser(se_CreateGrantVersionCommand).de(de_CreateGrantVersionCommand).build() {
+};
+__name(_CreateGrantVersionCommand, "CreateGrantVersionCommand");
+var CreateGrantVersionCommand = _CreateGrantVersionCommand;
+
+// src/commands/CreateLicenseCommand.ts
+
+
+
+
+var _CreateLicenseCommand = class _CreateLicenseCommand 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("AWSLicenseManager", "CreateLicense", {}).n("LicenseManagerClient", "CreateLicenseCommand").f(void 0, void 0).ser(se_CreateLicenseCommand).de(de_CreateLicenseCommand).build() {
+};
+__name(_CreateLicenseCommand, "CreateLicenseCommand");
+var CreateLicenseCommand = _CreateLicenseCommand;
+
+// src/commands/CreateLicenseConfigurationCommand.ts
+
+
+
+
+var _CreateLicenseConfigurationCommand = class _CreateLicenseConfigurationCommand 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("AWSLicenseManager", "CreateLicenseConfiguration", {}).n("LicenseManagerClient", "CreateLicenseConfigurationCommand").f(void 0, void 0).ser(se_CreateLicenseConfigurationCommand).de(de_CreateLicenseConfigurationCommand).build() {
+};
+__name(_CreateLicenseConfigurationCommand, "CreateLicenseConfigurationCommand");
+var CreateLicenseConfigurationCommand = _CreateLicenseConfigurationCommand;
+
+// src/commands/CreateLicenseConversionTaskForResourceCommand.ts
+
+
+
+
+var _CreateLicenseConversionTaskForResourceCommand = class _CreateLicenseConversionTaskForResourceCommand 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("AWSLicenseManager", "CreateLicenseConversionTaskForResource", {}).n("LicenseManagerClient", "CreateLicenseConversionTaskForResourceCommand").f(void 0, void 0).ser(se_CreateLicenseConversionTaskForResourceCommand).de(de_CreateLicenseConversionTaskForResourceCommand).build() {
+};
+__name(_CreateLicenseConversionTaskForResourceCommand, "CreateLicenseConversionTaskForResourceCommand");
+var CreateLicenseConversionTaskForResourceCommand = _CreateLicenseConversionTaskForResourceCommand;
+
+// src/commands/CreateLicenseManagerReportGeneratorCommand.ts
+
+
+
+
+var _CreateLicenseManagerReportGeneratorCommand = class _CreateLicenseManagerReportGeneratorCommand 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("AWSLicenseManager", "CreateLicenseManagerReportGenerator", {}).n("LicenseManagerClient", "CreateLicenseManagerReportGeneratorCommand").f(void 0, void 0).ser(se_CreateLicenseManagerReportGeneratorCommand).de(de_CreateLicenseManagerReportGeneratorCommand).build() {
+};
+__name(_CreateLicenseManagerReportGeneratorCommand, "CreateLicenseManagerReportGeneratorCommand");
+var CreateLicenseManagerReportGeneratorCommand = _CreateLicenseManagerReportGeneratorCommand;
+
+// src/commands/CreateLicenseVersionCommand.ts
+
+
+
+
+var _CreateLicenseVersionCommand = class _CreateLicenseVersionCommand 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("AWSLicenseManager", "CreateLicenseVersion", {}).n("LicenseManagerClient", "CreateLicenseVersionCommand").f(void 0, void 0).ser(se_CreateLicenseVersionCommand).de(de_CreateLicenseVersionCommand).build() {
+};
+__name(_CreateLicenseVersionCommand, "CreateLicenseVersionCommand");
+var CreateLicenseVersionCommand = _CreateLicenseVersionCommand;
+
+// src/commands/CreateTokenCommand.ts
+
+
+
+
+var _CreateTokenCommand = class _CreateTokenCommand 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("AWSLicenseManager", "CreateToken", {}).n("LicenseManagerClient", "CreateTokenCommand").f(void 0, void 0).ser(se_CreateTokenCommand).de(de_CreateTokenCommand).build() {
+};
+__name(_CreateTokenCommand, "CreateTokenCommand");
+var CreateTokenCommand = _CreateTokenCommand;
+
+// src/commands/DeleteGrantCommand.ts
+
+
+
+
+var _DeleteGrantCommand = class _DeleteGrantCommand 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("AWSLicenseManager", "DeleteGrant", {}).n("LicenseManagerClient", "DeleteGrantCommand").f(void 0, void 0).ser(se_DeleteGrantCommand).de(de_DeleteGrantCommand).build() {
+};
+__name(_DeleteGrantCommand, "DeleteGrantCommand");
+var DeleteGrantCommand = _DeleteGrantCommand;
+
+// src/commands/DeleteLicenseCommand.ts
+
+
+
+
+var _DeleteLicenseCommand = class _DeleteLicenseCommand 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("AWSLicenseManager", "DeleteLicense", {}).n("LicenseManagerClient", "DeleteLicenseCommand").f(void 0, void 0).ser(se_DeleteLicenseCommand).de(de_DeleteLicenseCommand).build() {
+};
+__name(_DeleteLicenseCommand, "DeleteLicenseCommand");
+var DeleteLicenseCommand = _DeleteLicenseCommand;
+
+// src/commands/DeleteLicenseConfigurationCommand.ts
+
+
+
+
+var _DeleteLicenseConfigurationCommand = class _DeleteLicenseConfigurationCommand 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("AWSLicenseManager", "DeleteLicenseConfiguration", {}).n("LicenseManagerClient", "DeleteLicenseConfigurationCommand").f(void 0, void 0).ser(se_DeleteLicenseConfigurationCommand).de(de_DeleteLicenseConfigurationCommand).build() {
+};
+__name(_DeleteLicenseConfigurationCommand, "DeleteLicenseConfigurationCommand");
+var DeleteLicenseConfigurationCommand = _DeleteLicenseConfigurationCommand;
+
+// src/commands/DeleteLicenseManagerReportGeneratorCommand.ts
+
+
+
+
+var _DeleteLicenseManagerReportGeneratorCommand = class _DeleteLicenseManagerReportGeneratorCommand 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("AWSLicenseManager", "DeleteLicenseManagerReportGenerator", {}).n("LicenseManagerClient", "DeleteLicenseManagerReportGeneratorCommand").f(void 0, void 0).ser(se_DeleteLicenseManagerReportGeneratorCommand).de(de_DeleteLicenseManagerReportGeneratorCommand).build() {
+};
+__name(_DeleteLicenseManagerReportGeneratorCommand, "DeleteLicenseManagerReportGeneratorCommand");
+var DeleteLicenseManagerReportGeneratorCommand = _DeleteLicenseManagerReportGeneratorCommand;
+
+// src/commands/DeleteTokenCommand.ts
+
+
+
+
+var _DeleteTokenCommand = class _DeleteTokenCommand 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("AWSLicenseManager", "DeleteToken", {}).n("LicenseManagerClient", "DeleteTokenCommand").f(void 0, void 0).ser(se_DeleteTokenCommand).de(de_DeleteTokenCommand).build() {
+};
+__name(_DeleteTokenCommand, "DeleteTokenCommand");
+var DeleteTokenCommand = _DeleteTokenCommand;
+
+// src/commands/ExtendLicenseConsumptionCommand.ts
+
+
+
+
+var _ExtendLicenseConsumptionCommand = class _ExtendLicenseConsumptionCommand 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("AWSLicenseManager", "ExtendLicenseConsumption", {}).n("LicenseManagerClient", "ExtendLicenseConsumptionCommand").f(void 0, void 0).ser(se_ExtendLicenseConsumptionCommand).de(de_ExtendLicenseConsumptionCommand).build() {
+};
+__name(_ExtendLicenseConsumptionCommand, "ExtendLicenseConsumptionCommand");
+var ExtendLicenseConsumptionCommand = _ExtendLicenseConsumptionCommand;
+
+// src/commands/GetAccessTokenCommand.ts
+
+
+
+
+var _GetAccessTokenCommand = class _GetAccessTokenCommand 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("AWSLicenseManager", "GetAccessToken", {}).n("LicenseManagerClient", "GetAccessTokenCommand").f(void 0, void 0).ser(se_GetAccessTokenCommand).de(de_GetAccessTokenCommand).build() {
+};
+__name(_GetAccessTokenCommand, "GetAccessTokenCommand");
+var GetAccessTokenCommand = _GetAccessTokenCommand;
+
+// src/commands/GetGrantCommand.ts
+
+
+
+
+var _GetGrantCommand = class _GetGrantCommand 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("AWSLicenseManager", "GetGrant", {}).n("LicenseManagerClient", "GetGrantCommand").f(void 0, void 0).ser(se_GetGrantCommand).de(de_GetGrantCommand).build() {
+};
+__name(_GetGrantCommand, "GetGrantCommand");
+var GetGrantCommand = _GetGrantCommand;
+
+// src/commands/GetLicenseCommand.ts
+
+
+
+
+var _GetLicenseCommand = class _GetLicenseCommand 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("AWSLicenseManager", "GetLicense", {}).n("LicenseManagerClient", "GetLicenseCommand").f(void 0, void 0).ser(se_GetLicenseCommand).de(de_GetLicenseCommand).build() {
+};
+__name(_GetLicenseCommand, "GetLicenseCommand");
+var GetLicenseCommand = _GetLicenseCommand;
+
+// src/commands/GetLicenseConfigurationCommand.ts
+
+
+
+
+var _GetLicenseConfigurationCommand = class _GetLicenseConfigurationCommand 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("AWSLicenseManager", "GetLicenseConfiguration", {}).n("LicenseManagerClient", "GetLicenseConfigurationCommand").f(void 0, void 0).ser(se_GetLicenseConfigurationCommand).de(de_GetLicenseConfigurationCommand).build() {
+};
+__name(_GetLicenseConfigurationCommand, "GetLicenseConfigurationCommand");
+var GetLicenseConfigurationCommand = _GetLicenseConfigurationCommand;
+
+// src/commands/GetLicenseConversionTaskCommand.ts
+
+
+
+
+var _GetLicenseConversionTaskCommand = class _GetLicenseConversionTaskCommand 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("AWSLicenseManager", "GetLicenseConversionTask", {}).n("LicenseManagerClient", "GetLicenseConversionTaskCommand").f(void 0, void 0).ser(se_GetLicenseConversionTaskCommand).de(de_GetLicenseConversionTaskCommand).build() {
+};
+__name(_GetLicenseConversionTaskCommand, "GetLicenseConversionTaskCommand");
+var GetLicenseConversionTaskCommand = _GetLicenseConversionTaskCommand;
+
+// src/commands/GetLicenseManagerReportGeneratorCommand.ts
+
+
+
+
+var _GetLicenseManagerReportGeneratorCommand = class _GetLicenseManagerReportGeneratorCommand 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("AWSLicenseManager", "GetLicenseManagerReportGenerator", {}).n("LicenseManagerClient", "GetLicenseManagerReportGeneratorCommand").f(void 0, void 0).ser(se_GetLicenseManagerReportGeneratorCommand).de(de_GetLicenseManagerReportGeneratorCommand).build() {
+};
+__name(_GetLicenseManagerReportGeneratorCommand, "GetLicenseManagerReportGeneratorCommand");
+var GetLicenseManagerReportGeneratorCommand = _GetLicenseManagerReportGeneratorCommand;
+
+// src/commands/GetLicenseUsageCommand.ts
+
+
+
+
+var _GetLicenseUsageCommand = class _GetLicenseUsageCommand 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("AWSLicenseManager", "GetLicenseUsage", {}).n("LicenseManagerClient", "GetLicenseUsageCommand").f(void 0, void 0).ser(se_GetLicenseUsageCommand).de(de_GetLicenseUsageCommand).build() {
+};
+__name(_GetLicenseUsageCommand, "GetLicenseUsageCommand");
+var GetLicenseUsageCommand = _GetLicenseUsageCommand;
+
+// src/commands/GetServiceSettingsCommand.ts
+
+
+
+
+var _GetServiceSettingsCommand = class _GetServiceSettingsCommand 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("AWSLicenseManager", "GetServiceSettings", {}).n("LicenseManagerClient", "GetServiceSettingsCommand").f(void 0, void 0).ser(se_GetServiceSettingsCommand).de(de_GetServiceSettingsCommand).build() {
+};
+__name(_GetServiceSettingsCommand, "GetServiceSettingsCommand");
+var GetServiceSettingsCommand = _GetServiceSettingsCommand;
+
+// src/commands/ListAssociationsForLicenseConfigurationCommand.ts
+
+
+
+
+var _ListAssociationsForLicenseConfigurationCommand = class _ListAssociationsForLicenseConfigurationCommand 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("AWSLicenseManager", "ListAssociationsForLicenseConfiguration", {}).n("LicenseManagerClient", "ListAssociationsForLicenseConfigurationCommand").f(void 0, void 0).ser(se_ListAssociationsForLicenseConfigurationCommand).de(de_ListAssociationsForLicenseConfigurationCommand).build() {
+};
+__name(_ListAssociationsForLicenseConfigurationCommand, "ListAssociationsForLicenseConfigurationCommand");
+var ListAssociationsForLicenseConfigurationCommand = _ListAssociationsForLicenseConfigurationCommand;
+
+// src/commands/ListDistributedGrantsCommand.ts
+
+
+
+
+var _ListDistributedGrantsCommand = class _ListDistributedGrantsCommand 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("AWSLicenseManager", "ListDistributedGrants", {}).n("LicenseManagerClient", "ListDistributedGrantsCommand").f(void 0, void 0).ser(se_ListDistributedGrantsCommand).de(de_ListDistributedGrantsCommand).build() {
+};
+__name(_ListDistributedGrantsCommand, "ListDistributedGrantsCommand");
+var ListDistributedGrantsCommand = _ListDistributedGrantsCommand;
+
+// src/commands/ListFailuresForLicenseConfigurationOperationsCommand.ts
+
+
+
+
+var _ListFailuresForLicenseConfigurationOperationsCommand = class _ListFailuresForLicenseConfigurationOperationsCommand 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("AWSLicenseManager", "ListFailuresForLicenseConfigurationOperations", {}).n("LicenseManagerClient", "ListFailuresForLicenseConfigurationOperationsCommand").f(void 0, void 0).ser(se_ListFailuresForLicenseConfigurationOperationsCommand).de(de_ListFailuresForLicenseConfigurationOperationsCommand).build() {
+};
+__name(_ListFailuresForLicenseConfigurationOperationsCommand, "ListFailuresForLicenseConfigurationOperationsCommand");
+var ListFailuresForLicenseConfigurationOperationsCommand = _ListFailuresForLicenseConfigurationOperationsCommand;
+
+// src/commands/ListLicenseConfigurationsCommand.ts
+
+
+
+
+var _ListLicenseConfigurationsCommand = class _ListLicenseConfigurationsCommand 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("AWSLicenseManager", "ListLicenseConfigurations", {}).n("LicenseManagerClient", "ListLicenseConfigurationsCommand").f(void 0, void 0).ser(se_ListLicenseConfigurationsCommand).de(de_ListLicenseConfigurationsCommand).build() {
+};
+__name(_ListLicenseConfigurationsCommand, "ListLicenseConfigurationsCommand");
+var ListLicenseConfigurationsCommand = _ListLicenseConfigurationsCommand;
+
+// src/commands/ListLicenseConversionTasksCommand.ts
+
+
+
+
+var _ListLicenseConversionTasksCommand = class _ListLicenseConversionTasksCommand 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("AWSLicenseManager", "ListLicenseConversionTasks", {}).n("LicenseManagerClient", "ListLicenseConversionTasksCommand").f(void 0, void 0).ser(se_ListLicenseConversionTasksCommand).de(de_ListLicenseConversionTasksCommand).build() {
+};
+__name(_ListLicenseConversionTasksCommand, "ListLicenseConversionTasksCommand");
+var ListLicenseConversionTasksCommand = _ListLicenseConversionTasksCommand;
+
+// src/commands/ListLicenseManagerReportGeneratorsCommand.ts
+
+
+
+
+var _ListLicenseManagerReportGeneratorsCommand = class _ListLicenseManagerReportGeneratorsCommand 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("AWSLicenseManager", "ListLicenseManagerReportGenerators", {}).n("LicenseManagerClient", "ListLicenseManagerReportGeneratorsCommand").f(void 0, void 0).ser(se_ListLicenseManagerReportGeneratorsCommand).de(de_ListLicenseManagerReportGeneratorsCommand).build() {
+};
+__name(_ListLicenseManagerReportGeneratorsCommand, "ListLicenseManagerReportGeneratorsCommand");
+var ListLicenseManagerReportGeneratorsCommand = _ListLicenseManagerReportGeneratorsCommand;
+
+// src/commands/ListLicensesCommand.ts
+
+
+
+
+var _ListLicensesCommand = class _ListLicensesCommand 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("AWSLicenseManager", "ListLicenses", {}).n("LicenseManagerClient", "ListLicensesCommand").f(void 0, void 0).ser(se_ListLicensesCommand).de(de_ListLicensesCommand).build() {
+};
+__name(_ListLicensesCommand, "ListLicensesCommand");
+var ListLicensesCommand = _ListLicensesCommand;
+
+// src/commands/ListLicenseSpecificationsForResourceCommand.ts
+
+
+
+
+var _ListLicenseSpecificationsForResourceCommand = class _ListLicenseSpecificationsForResourceCommand 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("AWSLicenseManager", "ListLicenseSpecificationsForResource", {}).n("LicenseManagerClient", "ListLicenseSpecificationsForResourceCommand").f(void 0, void 0).ser(se_ListLicenseSpecificationsForResourceCommand).de(de_ListLicenseSpecificationsForResourceCommand).build() {
+};
+__name(_ListLicenseSpecificationsForResourceCommand, "ListLicenseSpecificationsForResourceCommand");
+var ListLicenseSpecificationsForResourceCommand = _ListLicenseSpecificationsForResourceCommand;
+
+// src/commands/ListLicenseVersionsCommand.ts
+
+
+
+
+var _ListLicenseVersionsCommand = class _ListLicenseVersionsCommand 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("AWSLicenseManager", "ListLicenseVersions", {}).n("LicenseManagerClient", "ListLicenseVersionsCommand").f(void 0, void 0).ser(se_ListLicenseVersionsCommand).de(de_ListLicenseVersionsCommand).build() {
+};
+__name(_ListLicenseVersionsCommand, "ListLicenseVersionsCommand");
+var ListLicenseVersionsCommand = _ListLicenseVersionsCommand;
+
+// src/commands/ListReceivedGrantsCommand.ts
+
+
+
+
+var _ListReceivedGrantsCommand = class _ListReceivedGrantsCommand 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("AWSLicenseManager", "ListReceivedGrants", {}).n("LicenseManagerClient", "ListReceivedGrantsCommand").f(void 0, void 0).ser(se_ListReceivedGrantsCommand).de(de_ListReceivedGrantsCommand).build() {
+};
+__name(_ListReceivedGrantsCommand, "ListReceivedGrantsCommand");
+var ListReceivedGrantsCommand = _ListReceivedGrantsCommand;
+
+// src/commands/ListReceivedGrantsForOrganizationCommand.ts
+
+
+
+
+var _ListReceivedGrantsForOrganizationCommand = class _ListReceivedGrantsForOrganizationCommand 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("AWSLicenseManager", "ListReceivedGrantsForOrganization", {}).n("LicenseManagerClient", "ListReceivedGrantsForOrganizationCommand").f(void 0, void 0).ser(se_ListReceivedGrantsForOrganizationCommand).de(de_ListReceivedGrantsForOrganizationCommand).build() {
+};
+__name(_ListReceivedGrantsForOrganizationCommand, "ListReceivedGrantsForOrganizationCommand");
+var ListReceivedGrantsForOrganizationCommand = _ListReceivedGrantsForOrganizationCommand;
+
+// src/commands/ListReceivedLicensesCommand.ts
+
+
+
+
+var _ListReceivedLicensesCommand = class _ListReceivedLicensesCommand 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("AWSLicenseManager", "ListReceivedLicenses", {}).n("LicenseManagerClient", "ListReceivedLicensesCommand").f(void 0, void 0).ser(se_ListReceivedLicensesCommand).de(de_ListReceivedLicensesCommand).build() {
+};
+__name(_ListReceivedLicensesCommand, "ListReceivedLicensesCommand");
+var ListReceivedLicensesCommand = _ListReceivedLicensesCommand;
+
+// src/commands/ListReceivedLicensesForOrganizationCommand.ts
+
+
+
+
+var _ListReceivedLicensesForOrganizationCommand = class _ListReceivedLicensesForOrganizationCommand 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("AWSLicenseManager", "ListReceivedLicensesForOrganization", {}).n("LicenseManagerClient", "ListReceivedLicensesForOrganizationCommand").f(void 0, void 0).ser(se_ListReceivedLicensesForOrganizationCommand).de(de_ListReceivedLicensesForOrganizationCommand).build() {
+};
+__name(_ListReceivedLicensesForOrganizationCommand, "ListReceivedLicensesForOrganizationCommand");
+var ListReceivedLicensesForOrganizationCommand = _ListReceivedLicensesForOrganizationCommand;
+
+// src/commands/ListResourceInventoryCommand.ts
+
+
+
+
+var _ListResourceInventoryCommand = class _ListResourceInventoryCommand 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("AWSLicenseManager", "ListResourceInventory", {}).n("LicenseManagerClient", "ListResourceInventoryCommand").f(void 0, void 0).ser(se_ListResourceInventoryCommand).de(de_ListResourceInventoryCommand).build() {
+};
+__name(_ListResourceInventoryCommand, "ListResourceInventoryCommand");
+var ListResourceInventoryCommand = _ListResourceInventoryCommand;
+
+// 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("AWSLicenseManager", "ListTagsForResource", {}).n("LicenseManagerClient", "ListTagsForResourceCommand").f(void 0, void 0).ser(se_ListTagsForResourceCommand).de(de_ListTagsForResourceCommand).build() {
+};
+__name(_ListTagsForResourceCommand, "ListTagsForResourceCommand");
+var ListTagsForResourceCommand = _ListTagsForResourceCommand;
+
+// src/commands/ListTokensCommand.ts
+
+
+
+
+var _ListTokensCommand = class _ListTokensCommand 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("AWSLicenseManager", "ListTokens", {}).n("LicenseManagerClient", "ListTokensCommand").f(void 0, void 0).ser(se_ListTokensCommand).de(de_ListTokensCommand).build() {
+};
+__name(_ListTokensCommand, "ListTokensCommand");
+var ListTokensCommand = _ListTokensCommand;
+
+// src/commands/ListUsageForLicenseConfigurationCommand.ts
+
+
+
+
+var _ListUsageForLicenseConfigurationCommand = class _ListUsageForLicenseConfigurationCommand 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("AWSLicenseManager", "ListUsageForLicenseConfiguration", {}).n("LicenseManagerClient", "ListUsageForLicenseConfigurationCommand").f(void 0, void 0).ser(se_ListUsageForLicenseConfigurationCommand).de(de_ListUsageForLicenseConfigurationCommand).build() {
+};
+__name(_ListUsageForLicenseConfigurationCommand, "ListUsageForLicenseConfigurationCommand");
+var ListUsageForLicenseConfigurationCommand = _ListUsageForLicenseConfigurationCommand;
+
+// src/commands/RejectGrantCommand.ts
+
+
+
+
+var _RejectGrantCommand = class _RejectGrantCommand 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("AWSLicenseManager", "RejectGrant", {}).n("LicenseManagerClient", "RejectGrantCommand").f(void 0, void 0).ser(se_RejectGrantCommand).de(de_RejectGrantCommand).build() {
+};
+__name(_RejectGrantCommand, "RejectGrantCommand");
+var RejectGrantCommand = _RejectGrantCommand;
+
+// 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("AWSLicenseManager", "TagResource", {}).n("LicenseManagerClient", "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("AWSLicenseManager", "UntagResource", {}).n("LicenseManagerClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
+};
+__name(_UntagResourceCommand, "UntagResourceCommand");
+var UntagResourceCommand = _UntagResourceCommand;
+
+// src/commands/UpdateLicenseConfigurationCommand.ts
+
+
+
+
+var _UpdateLicenseConfigurationCommand = class _UpdateLicenseConfigurationCommand 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("AWSLicenseManager", "UpdateLicenseConfiguration", {}).n("LicenseManagerClient", "UpdateLicenseConfigurationCommand").f(void 0, void 0).ser(se_UpdateLicenseConfigurationCommand).de(de_UpdateLicenseConfigurationCommand).build() {
+};
+__name(_UpdateLicenseConfigurationCommand, "UpdateLicenseConfigurationCommand");
+var UpdateLicenseConfigurationCommand = _UpdateLicenseConfigurationCommand;
+
+// src/commands/UpdateLicenseManagerReportGeneratorCommand.ts
+
+
+
+
+var _UpdateLicenseManagerReportGeneratorCommand = class _UpdateLicenseManagerReportGeneratorCommand 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("AWSLicenseManager", "UpdateLicenseManagerReportGenerator", {}).n("LicenseManagerClient", "UpdateLicenseManagerReportGeneratorCommand").f(void 0, void 0).ser(se_UpdateLicenseManagerReportGeneratorCommand).de(de_UpdateLicenseManagerReportGeneratorCommand).build() {
+};
+__name(_UpdateLicenseManagerReportGeneratorCommand, "UpdateLicenseManagerReportGeneratorCommand");
+var UpdateLicenseManagerReportGeneratorCommand = _UpdateLicenseManagerReportGeneratorCommand;
+
+// src/commands/UpdateLicenseSpecificationsForResourceCommand.ts
+
+
+
+
+var _UpdateLicenseSpecificationsForResourceCommand = class _UpdateLicenseSpecificationsForResourceCommand 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("AWSLicenseManager", "UpdateLicenseSpecificationsForResource", {}).n("LicenseManagerClient", "UpdateLicenseSpecificationsForResourceCommand").f(void 0, void 0).ser(se_UpdateLicenseSpecificationsForResourceCommand).de(de_UpdateLicenseSpecificationsForResourceCommand).build() {
+};
+__name(_UpdateLicenseSpecificationsForResourceCommand, "UpdateLicenseSpecificationsForResourceCommand");
+var UpdateLicenseSpecificationsForResourceCommand = _UpdateLicenseSpecificationsForResourceCommand;
+
+// src/commands/UpdateServiceSettingsCommand.ts
+
+
+
+
+var _UpdateServiceSettingsCommand = class _UpdateServiceSettingsCommand 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("AWSLicenseManager", "UpdateServiceSettings", {}).n("LicenseManagerClient", "UpdateServiceSettingsCommand").f(void 0, void 0).ser(se_UpdateServiceSettingsCommand).de(de_UpdateServiceSettingsCommand).build() {
+};
+__name(_UpdateServiceSettingsCommand, "UpdateServiceSettingsCommand");
+var UpdateServiceSettingsCommand = _UpdateServiceSettingsCommand;
+
+// src/LicenseManager.ts
+var commands = {
+  AcceptGrantCommand,
+  CheckInLicenseCommand,
+  CheckoutBorrowLicenseCommand,
+  CheckoutLicenseCommand,
+  CreateGrantCommand,
+  CreateGrantVersionCommand,
+  CreateLicenseCommand,
+  CreateLicenseConfigurationCommand,
+  CreateLicenseConversionTaskForResourceCommand,
+  CreateLicenseManagerReportGeneratorCommand,
+  CreateLicenseVersionCommand,
+  CreateTokenCommand,
+  DeleteGrantCommand,
+  DeleteLicenseCommand,
+  DeleteLicenseConfigurationCommand,
+  DeleteLicenseManagerReportGeneratorCommand,
+  DeleteTokenCommand,
+  ExtendLicenseConsumptionCommand,
+  GetAccessTokenCommand,
+  GetGrantCommand,
+  GetLicenseCommand,
+  GetLicenseConfigurationCommand,
+  GetLicenseConversionTaskCommand,
+  GetLicenseManagerReportGeneratorCommand,
+  GetLicenseUsageCommand,
+  GetServiceSettingsCommand,
+  ListAssociationsForLicenseConfigurationCommand,
+  ListDistributedGrantsCommand,
+  ListFailuresForLicenseConfigurationOperationsCommand,
+  ListLicenseConfigurationsCommand,
+  ListLicenseConversionTasksCommand,
+  ListLicenseManagerReportGeneratorsCommand,
+  ListLicensesCommand,
+  ListLicenseSpecificationsForResourceCommand,
+  ListLicenseVersionsCommand,
+  ListReceivedGrantsCommand,
+  ListReceivedGrantsForOrganizationCommand,
+  ListReceivedLicensesCommand,
+  ListReceivedLicensesForOrganizationCommand,
+  ListResourceInventoryCommand,
+  ListTagsForResourceCommand,
+  ListTokensCommand,
+  ListUsageForLicenseConfigurationCommand,
+  RejectGrantCommand,
+  TagResourceCommand,
+  UntagResourceCommand,
+  UpdateLicenseConfigurationCommand,
+  UpdateLicenseManagerReportGeneratorCommand,
+  UpdateLicenseSpecificationsForResourceCommand,
+  UpdateServiceSettingsCommand
+};
+var _LicenseManager = class _LicenseManager extends LicenseManagerClient {
+};
+__name(_LicenseManager, "LicenseManager");
+var LicenseManager = _LicenseManager;
+(0, import_smithy_client.createAggregatedClient)(commands, LicenseManager);
+
+// 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 = {
+  AcceptGrantCommand,
+  AccessDeniedException,
+  ActivationOverrideBehavior,
+  AllowedOperation,
+  AuthorizationException,
+  CheckInLicenseCommand,
+  CheckoutBorrowLicenseCommand,
+  CheckoutLicenseCommand,
+  CheckoutType,
+  ConflictException,
+  CreateGrantCommand,
+  CreateGrantVersionCommand,
+  CreateLicenseCommand,
+  CreateLicenseConfigurationCommand,
+  CreateLicenseConversionTaskForResourceCommand,
+  CreateLicenseManagerReportGeneratorCommand,
+  CreateLicenseVersionCommand,
+  CreateTokenCommand,
+  DeleteGrantCommand,
+  DeleteLicenseCommand,
+  DeleteLicenseConfigurationCommand,
+  DeleteLicenseManagerReportGeneratorCommand,
+  DeleteTokenCommand,
+  DigitalSignatureMethod,
+  EntitlementDataUnit,
+  EntitlementNotAllowedException,
+  EntitlementUnit,
+  ExtendLicenseConsumptionCommand,
+  FailedDependencyException,
+  FilterLimitExceededException,
+  GetAccessTokenCommand,
+  GetGrantCommand,
+  GetLicenseCommand,
+  GetLicenseConfigurationCommand,
+  GetLicenseConversionTaskCommand,
+  GetLicenseManagerReportGeneratorCommand,
+  GetLicenseUsageCommand,
+  GetServiceSettingsCommand,
+  GrantStatus,
+  InvalidParameterValueException,
+  InvalidResourceStateException,
+  InventoryFilterCondition,
+  LicenseConfigurationStatus,
+  LicenseConversionTaskStatus,
+  LicenseCountingType,
+  LicenseDeletionStatus,
+  LicenseManager,
+  LicenseManagerClient,
+  LicenseManagerServiceException,
+  LicenseStatus,
+  LicenseUsageException,
+  ListAssociationsForLicenseConfigurationCommand,
+  ListDistributedGrantsCommand,
+  ListFailuresForLicenseConfigurationOperationsCommand,
+  ListLicenseConfigurationsCommand,
+  ListLicenseConversionTasksCommand,
+  ListLicenseManagerReportGeneratorsCommand,
+  ListLicenseSpecificationsForResourceCommand,
+  ListLicenseVersionsCommand,
+  ListLicensesCommand,
+  ListReceivedGrantsCommand,
+  ListReceivedGrantsForOrganizationCommand,
+  ListReceivedLicensesCommand,
+  ListReceivedLicensesForOrganizationCommand,
+  ListResourceInventoryCommand,
+  ListTagsForResourceCommand,
+  ListTokensCommand,
+  ListUsageForLicenseConfigurationCommand,
+  NoEntitlementsAllowedException,
+  RateLimitExceededException,
+  ReceivedStatus,
+  RedirectException,
+  RejectGrantCommand,
+  RenewType,
+  ReportFrequencyType,
+  ReportType,
+  ResourceLimitExceededException,
+  ResourceNotFoundException,
+  ResourceType,
+  ServerInternalException,
+  TagResourceCommand,
+  TokenType,
+  UnsupportedDigitalSignatureMethodException,
+  UntagResourceCommand,
+  UpdateLicenseConfigurationCommand,
+  UpdateLicenseManagerReportGeneratorCommand,
+  UpdateLicenseSpecificationsForResourceCommand,
+  UpdateServiceSettingsCommand,
+  ValidationException,
+  __Client
+});
+