@aws-sdk/client-cost-explorer 3.489.0 → 3.495.0

package/dist-cjs/index.js

@@ -1,12 +1,3696 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CostExplorerServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./CostExplorerClient"), exports);
-tslib_1.__exportStar(require("./CostExplorer"), exports);
-tslib_1.__exportStar(require("./commands"), exports);
-tslib_1.__exportStar(require("./pagination"), exports);
-tslib_1.__exportStar(require("./models"), exports);
-require("@aws-sdk/util-endpoints");
-var CostExplorerServiceException_1 = require("./models/CostExplorerServiceException");
-Object.defineProperty(exports, "CostExplorerServiceException", { enumerable: true, get: function () { return CostExplorerServiceException_1.CostExplorerServiceException; } });
+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, {
+  AccountScope: () => AccountScope,
+  AnomalyFeedbackType: () => AnomalyFeedbackType,
+  AnomalySubscriptionFrequency: () => AnomalySubscriptionFrequency,
+  BillExpirationException: () => BillExpirationException,
+  Context: () => Context,
+  CostAllocationTagStatus: () => CostAllocationTagStatus,
+  CostAllocationTagType: () => CostAllocationTagType,
+  CostCategoryInheritedValueDimensionName: () => CostCategoryInheritedValueDimensionName,
+  CostCategoryRuleType: () => CostCategoryRuleType,
+  CostCategoryRuleVersion: () => CostCategoryRuleVersion,
+  CostCategorySplitChargeMethod: () => CostCategorySplitChargeMethod,
+  CostCategorySplitChargeRuleParameterType: () => CostCategorySplitChargeRuleParameterType,
+  CostCategoryStatus: () => CostCategoryStatus,
+  CostCategoryStatusComponent: () => CostCategoryStatusComponent,
+  CostExplorer: () => CostExplorer,
+  CostExplorerClient: () => CostExplorerClient,
+  CostExplorerServiceException: () => CostExplorerServiceException,
+  CreateAnomalyMonitorCommand: () => CreateAnomalyMonitorCommand,
+  CreateAnomalySubscriptionCommand: () => CreateAnomalySubscriptionCommand,
+  CreateCostCategoryDefinitionCommand: () => CreateCostCategoryDefinitionCommand,
+  DataUnavailableException: () => DataUnavailableException,
+  DeleteAnomalyMonitorCommand: () => DeleteAnomalyMonitorCommand,
+  DeleteAnomalySubscriptionCommand: () => DeleteAnomalySubscriptionCommand,
+  DeleteCostCategoryDefinitionCommand: () => DeleteCostCategoryDefinitionCommand,
+  DescribeCostCategoryDefinitionCommand: () => DescribeCostCategoryDefinitionCommand,
+  Dimension: () => Dimension,
+  FindingReasonCode: () => FindingReasonCode,
+  GenerationExistsException: () => GenerationExistsException,
+  GenerationStatus: () => GenerationStatus,
+  GetAnomaliesCommand: () => GetAnomaliesCommand,
+  GetAnomalyMonitorsCommand: () => GetAnomalyMonitorsCommand,
+  GetAnomalySubscriptionsCommand: () => GetAnomalySubscriptionsCommand,
+  GetCostAndUsageCommand: () => GetCostAndUsageCommand,
+  GetCostAndUsageWithResourcesCommand: () => GetCostAndUsageWithResourcesCommand,
+  GetCostCategoriesCommand: () => GetCostCategoriesCommand,
+  GetCostForecastCommand: () => GetCostForecastCommand,
+  GetDimensionValuesCommand: () => GetDimensionValuesCommand,
+  GetReservationCoverageCommand: () => GetReservationCoverageCommand,
+  GetReservationPurchaseRecommendationCommand: () => GetReservationPurchaseRecommendationCommand,
+  GetReservationUtilizationCommand: () => GetReservationUtilizationCommand,
+  GetRightsizingRecommendationCommand: () => GetRightsizingRecommendationCommand,
+  GetSavingsPlanPurchaseRecommendationDetailsCommand: () => GetSavingsPlanPurchaseRecommendationDetailsCommand,
+  GetSavingsPlansCoverageCommand: () => GetSavingsPlansCoverageCommand,
+  GetSavingsPlansPurchaseRecommendationCommand: () => GetSavingsPlansPurchaseRecommendationCommand,
+  GetSavingsPlansUtilizationCommand: () => GetSavingsPlansUtilizationCommand,
+  GetSavingsPlansUtilizationDetailsCommand: () => GetSavingsPlansUtilizationDetailsCommand,
+  GetTagsCommand: () => GetTagsCommand,
+  GetUsageForecastCommand: () => GetUsageForecastCommand,
+  Granularity: () => Granularity,
+  GroupDefinitionType: () => GroupDefinitionType,
+  InvalidNextTokenException: () => InvalidNextTokenException,
+  LimitExceededException: () => LimitExceededException,
+  ListCostAllocationTagsCommand: () => ListCostAllocationTagsCommand,
+  ListCostCategoryDefinitionsCommand: () => ListCostCategoryDefinitionsCommand,
+  ListSavingsPlansPurchaseRecommendationGenerationCommand: () => ListSavingsPlansPurchaseRecommendationGenerationCommand,
+  ListTagsForResourceCommand: () => ListTagsForResourceCommand,
+  LookbackPeriodInDays: () => LookbackPeriodInDays,
+  MatchOption: () => MatchOption,
+  Metric: () => Metric,
+  MonitorDimension: () => MonitorDimension,
+  MonitorType: () => MonitorType,
+  NumericOperator: () => NumericOperator,
+  OfferingClass: () => OfferingClass,
+  PaymentOption: () => PaymentOption,
+  PlatformDifference: () => PlatformDifference,
+  ProvideAnomalyFeedbackCommand: () => ProvideAnomalyFeedbackCommand,
+  RecommendationTarget: () => RecommendationTarget,
+  RequestChangedException: () => RequestChangedException,
+  ResourceNotFoundException: () => ResourceNotFoundException,
+  RightsizingType: () => RightsizingType,
+  SavingsPlansDataType: () => SavingsPlansDataType,
+  ServiceQuotaExceededException: () => ServiceQuotaExceededException,
+  SortOrder: () => SortOrder,
+  StartSavingsPlansPurchaseRecommendationGenerationCommand: () => StartSavingsPlansPurchaseRecommendationGenerationCommand,
+  SubscriberStatus: () => SubscriberStatus,
+  SubscriberType: () => SubscriberType,
+  SupportedSavingsPlansType: () => SupportedSavingsPlansType,
+  TagResourceCommand: () => TagResourceCommand,
+  TermInYears: () => TermInYears,
+  TooManyTagsException: () => TooManyTagsException,
+  UnknownMonitorException: () => UnknownMonitorException,
+  UnknownSubscriptionException: () => UnknownSubscriptionException,
+  UnresolvableUsageUnitException: () => UnresolvableUsageUnitException,
+  UntagResourceCommand: () => UntagResourceCommand,
+  UpdateAnomalyMonitorCommand: () => UpdateAnomalyMonitorCommand,
+  UpdateAnomalySubscriptionCommand: () => UpdateAnomalySubscriptionCommand,
+  UpdateCostAllocationTagsStatusCommand: () => UpdateCostAllocationTagsStatusCommand,
+  UpdateCostCategoryDefinitionCommand: () => UpdateCostCategoryDefinitionCommand,
+  __Client: () => import_smithy_client.Client,
+  paginateGetSavingsPlansCoverage: () => paginateGetSavingsPlansCoverage,
+  paginateGetSavingsPlansUtilizationDetails: () => paginateGetSavingsPlansUtilizationDetails,
+  paginateListCostAllocationTags: () => paginateListCostAllocationTags,
+  paginateListCostCategoryDefinitions: () => paginateListCostCategoryDefinitions
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/CostExplorerClient.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: "ce"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/CostExplorerClient.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/CostExplorerClient.ts
+var _CostExplorerClient = class _CostExplorerClient 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(_CostExplorerClient, "CostExplorerClient");
+var CostExplorerClient = _CostExplorerClient;
+
+// src/CostExplorer.ts
+
+
+// src/commands/CreateAnomalyMonitorCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/protocols/Aws_json1_1.ts
+
+
+
+// src/models/CostExplorerServiceException.ts
+
+var _CostExplorerServiceException = class _CostExplorerServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _CostExplorerServiceException.prototype);
+  }
+};
+__name(_CostExplorerServiceException, "CostExplorerServiceException");
+var CostExplorerServiceException = _CostExplorerServiceException;
+
+// src/models/models_0.ts
+var AccountScope = {
+  LINKED: "LINKED",
+  PAYER: "PAYER"
+};
+var AnomalyFeedbackType = {
+  NO: "NO",
+  PLANNED_ACTIVITY: "PLANNED_ACTIVITY",
+  YES: "YES"
+};
+var MonitorDimension = {
+  SERVICE: "SERVICE"
+};
+var MatchOption = {
+  ABSENT: "ABSENT",
+  CASE_INSENSITIVE: "CASE_INSENSITIVE",
+  CASE_SENSITIVE: "CASE_SENSITIVE",
+  CONTAINS: "CONTAINS",
+  ENDS_WITH: "ENDS_WITH",
+  EQUALS: "EQUALS",
+  GREATER_THAN_OR_EQUAL: "GREATER_THAN_OR_EQUAL",
+  STARTS_WITH: "STARTS_WITH"
+};
+var Dimension = {
+  AGREEMENT_END_DATE_TIME_AFTER: "AGREEMENT_END_DATE_TIME_AFTER",
+  AGREEMENT_END_DATE_TIME_BEFORE: "AGREEMENT_END_DATE_TIME_BEFORE",
+  ANOMALY_TOTAL_IMPACT_ABSOLUTE: "ANOMALY_TOTAL_IMPACT_ABSOLUTE",
+  ANOMALY_TOTAL_IMPACT_PERCENTAGE: "ANOMALY_TOTAL_IMPACT_PERCENTAGE",
+  AZ: "AZ",
+  BILLING_ENTITY: "BILLING_ENTITY",
+  CACHE_ENGINE: "CACHE_ENGINE",
+  DATABASE_ENGINE: "DATABASE_ENGINE",
+  DEPLOYMENT_OPTION: "DEPLOYMENT_OPTION",
+  INSTANCE_TYPE: "INSTANCE_TYPE",
+  INSTANCE_TYPE_FAMILY: "INSTANCE_TYPE_FAMILY",
+  INVOICING_ENTITY: "INVOICING_ENTITY",
+  LEGAL_ENTITY_NAME: "LEGAL_ENTITY_NAME",
+  LINKED_ACCOUNT: "LINKED_ACCOUNT",
+  LINKED_ACCOUNT_NAME: "LINKED_ACCOUNT_NAME",
+  OPERATING_SYSTEM: "OPERATING_SYSTEM",
+  OPERATION: "OPERATION",
+  PAYMENT_OPTION: "PAYMENT_OPTION",
+  PLATFORM: "PLATFORM",
+  PURCHASE_TYPE: "PURCHASE_TYPE",
+  RECORD_TYPE: "RECORD_TYPE",
+  REGION: "REGION",
+  RESERVATION_ID: "RESERVATION_ID",
+  RESOURCE_ID: "RESOURCE_ID",
+  RIGHTSIZING_TYPE: "RIGHTSIZING_TYPE",
+  SAVINGS_PLANS_TYPE: "SAVINGS_PLANS_TYPE",
+  SAVINGS_PLAN_ARN: "SAVINGS_PLAN_ARN",
+  SCOPE: "SCOPE",
+  SERVICE: "SERVICE",
+  SERVICE_CODE: "SERVICE_CODE",
+  SUBSCRIPTION_ID: "SUBSCRIPTION_ID",
+  TENANCY: "TENANCY",
+  USAGE_TYPE: "USAGE_TYPE",
+  USAGE_TYPE_GROUP: "USAGE_TYPE_GROUP"
+};
+var MonitorType = {
+  CUSTOM: "CUSTOM",
+  DIMENSIONAL: "DIMENSIONAL"
+};
+var AnomalySubscriptionFrequency = {
+  DAILY: "DAILY",
+  IMMEDIATE: "IMMEDIATE",
+  WEEKLY: "WEEKLY"
+};
+var SubscriberStatus = {
+  CONFIRMED: "CONFIRMED",
+  DECLINED: "DECLINED"
+};
+var SubscriberType = {
+  EMAIL: "EMAIL",
+  SNS: "SNS"
+};
+var _LimitExceededException = class _LimitExceededException extends CostExplorerServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "LimitExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "LimitExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _LimitExceededException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_LimitExceededException, "LimitExceededException");
+var LimitExceededException = _LimitExceededException;
+var _UnknownMonitorException = class _UnknownMonitorException extends CostExplorerServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "UnknownMonitorException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "UnknownMonitorException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _UnknownMonitorException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_UnknownMonitorException, "UnknownMonitorException");
+var UnknownMonitorException = _UnknownMonitorException;
+var CostCategoryInheritedValueDimensionName = {
+  LINKED_ACCOUNT_NAME: "LINKED_ACCOUNT_NAME",
+  TAG: "TAG"
+};
+var CostCategoryRuleType = {
+  INHERITED_VALUE: "INHERITED_VALUE",
+  REGULAR: "REGULAR"
+};
+var CostCategoryRuleVersion = {
+  CostCategoryExpressionV1: "CostCategoryExpression.v1"
+};
+var CostCategorySplitChargeMethod = {
+  EVEN: "EVEN",
+  FIXED: "FIXED",
+  PROPORTIONAL: "PROPORTIONAL"
+};
+var CostCategorySplitChargeRuleParameterType = {
+  ALLOCATION_PERCENTAGES: "ALLOCATION_PERCENTAGES"
+};
+var _ServiceQuotaExceededException = class _ServiceQuotaExceededException extends CostExplorerServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ServiceQuotaExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ServiceQuotaExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ServiceQuotaExceededException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_ServiceQuotaExceededException, "ServiceQuotaExceededException");
+var ServiceQuotaExceededException = _ServiceQuotaExceededException;
+var _UnknownSubscriptionException = class _UnknownSubscriptionException extends CostExplorerServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "UnknownSubscriptionException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "UnknownSubscriptionException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _UnknownSubscriptionException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_UnknownSubscriptionException, "UnknownSubscriptionException");
+var UnknownSubscriptionException = _UnknownSubscriptionException;
+var _ResourceNotFoundException = class _ResourceNotFoundException extends CostExplorerServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ResourceNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ResourceNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
+    this.Message = opts.Message;
+    this.ResourceName = opts.ResourceName;
+  }
+};
+__name(_ResourceNotFoundException, "ResourceNotFoundException");
+var ResourceNotFoundException = _ResourceNotFoundException;
+var CostCategoryStatusComponent = {
+  COST_EXPLORER: "COST_EXPLORER"
+};
+var CostCategoryStatus = {
+  APPLIED: "APPLIED",
+  PROCESSING: "PROCESSING"
+};
+var NumericOperator = {
+  BETWEEN: "BETWEEN",
+  EQUAL: "EQUAL",
+  GREATER_THAN: "GREATER_THAN",
+  GREATER_THAN_OR_EQUAL: "GREATER_THAN_OR_EQUAL",
+  LESS_THAN: "LESS_THAN",
+  LESS_THAN_OR_EQUAL: "LESS_THAN_OR_EQUAL"
+};
+var _InvalidNextTokenException = class _InvalidNextTokenException extends CostExplorerServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidNextTokenException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidNextTokenException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidNextTokenException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_InvalidNextTokenException, "InvalidNextTokenException");
+var InvalidNextTokenException = _InvalidNextTokenException;
+var _BillExpirationException = class _BillExpirationException extends CostExplorerServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "BillExpirationException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "BillExpirationException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _BillExpirationException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_BillExpirationException, "BillExpirationException");
+var BillExpirationException = _BillExpirationException;
+var _DataUnavailableException = class _DataUnavailableException extends CostExplorerServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "DataUnavailableException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "DataUnavailableException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _DataUnavailableException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_DataUnavailableException, "DataUnavailableException");
+var DataUnavailableException = _DataUnavailableException;
+var Granularity = {
+  DAILY: "DAILY",
+  HOURLY: "HOURLY",
+  MONTHLY: "MONTHLY"
+};
+var GroupDefinitionType = {
+  COST_CATEGORY: "COST_CATEGORY",
+  DIMENSION: "DIMENSION",
+  TAG: "TAG"
+};
+var _RequestChangedException = class _RequestChangedException extends CostExplorerServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "RequestChangedException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "RequestChangedException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _RequestChangedException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_RequestChangedException, "RequestChangedException");
+var RequestChangedException = _RequestChangedException;
+var SortOrder = {
+  ASCENDING: "ASCENDING",
+  DESCENDING: "DESCENDING"
+};
+var Metric = {
+  AMORTIZED_COST: "AMORTIZED_COST",
+  BLENDED_COST: "BLENDED_COST",
+  NET_AMORTIZED_COST: "NET_AMORTIZED_COST",
+  NET_UNBLENDED_COST: "NET_UNBLENDED_COST",
+  NORMALIZED_USAGE_AMOUNT: "NORMALIZED_USAGE_AMOUNT",
+  UNBLENDED_COST: "UNBLENDED_COST",
+  USAGE_QUANTITY: "USAGE_QUANTITY"
+};
+var Context = {
+  COST_AND_USAGE: "COST_AND_USAGE",
+  RESERVATIONS: "RESERVATIONS",
+  SAVINGS_PLANS: "SAVINGS_PLANS"
+};
+var LookbackPeriodInDays = {
+  SEVEN_DAYS: "SEVEN_DAYS",
+  SIXTY_DAYS: "SIXTY_DAYS",
+  THIRTY_DAYS: "THIRTY_DAYS"
+};
+var PaymentOption = {
+  ALL_UPFRONT: "ALL_UPFRONT",
+  HEAVY_UTILIZATION: "HEAVY_UTILIZATION",
+  LIGHT_UTILIZATION: "LIGHT_UTILIZATION",
+  MEDIUM_UTILIZATION: "MEDIUM_UTILIZATION",
+  NO_UPFRONT: "NO_UPFRONT",
+  PARTIAL_UPFRONT: "PARTIAL_UPFRONT"
+};
+var OfferingClass = {
+  CONVERTIBLE: "CONVERTIBLE",
+  STANDARD: "STANDARD"
+};
+var TermInYears = {
+  ONE_YEAR: "ONE_YEAR",
+  THREE_YEARS: "THREE_YEARS"
+};
+var RecommendationTarget = {
+  CROSS_INSTANCE_FAMILY: "CROSS_INSTANCE_FAMILY",
+  SAME_INSTANCE_FAMILY: "SAME_INSTANCE_FAMILY"
+};
+var FindingReasonCode = {
+  CPU_OVER_PROVISIONED: "CPU_OVER_PROVISIONED",
+  CPU_UNDER_PROVISIONED: "CPU_UNDER_PROVISIONED",
+  DISK_IOPS_OVER_PROVISIONED: "DISK_IOPS_OVER_PROVISIONED",
+  DISK_IOPS_UNDER_PROVISIONED: "DISK_IOPS_UNDER_PROVISIONED",
+  DISK_THROUGHPUT_OVER_PROVISIONED: "DISK_THROUGHPUT_OVER_PROVISIONED",
+  DISK_THROUGHPUT_UNDER_PROVISIONED: "DISK_THROUGHPUT_UNDER_PROVISIONED",
+  EBS_IOPS_OVER_PROVISIONED: "EBS_IOPS_OVER_PROVISIONED",
+  EBS_IOPS_UNDER_PROVISIONED: "EBS_IOPS_UNDER_PROVISIONED",
+  EBS_THROUGHPUT_OVER_PROVISIONED: "EBS_THROUGHPUT_OVER_PROVISIONED",
+  EBS_THROUGHPUT_UNDER_PROVISIONED: "EBS_THROUGHPUT_UNDER_PROVISIONED",
+  MEMORY_OVER_PROVISIONED: "MEMORY_OVER_PROVISIONED",
+  MEMORY_UNDER_PROVISIONED: "MEMORY_UNDER_PROVISIONED",
+  NETWORK_BANDWIDTH_OVER_PROVISIONED: "NETWORK_BANDWIDTH_OVER_PROVISIONED",
+  NETWORK_BANDWIDTH_UNDER_PROVISIONED: "NETWORK_BANDWIDTH_UNDER_PROVISIONED",
+  NETWORK_PPS_OVER_PROVISIONED: "NETWORK_PPS_OVER_PROVISIONED",
+  NETWORK_PPS_UNDER_PROVISIONED: "NETWORK_PPS_UNDER_PROVISIONED"
+};
+var PlatformDifference = {
+  HYPERVISOR: "HYPERVISOR",
+  INSTANCE_STORE_AVAILABILITY: "INSTANCE_STORE_AVAILABILITY",
+  NETWORK_INTERFACE: "NETWORK_INTERFACE",
+  STORAGE_INTERFACE: "STORAGE_INTERFACE",
+  VIRTUALIZATION_TYPE: "VIRTUALIZATION_TYPE"
+};
+var RightsizingType = {
+  MODIFY: "MODIFY",
+  TERMINATE: "TERMINATE"
+};
+var SupportedSavingsPlansType = {
+  COMPUTE_SP: "COMPUTE_SP",
+  EC2_INSTANCE_SP: "EC2_INSTANCE_SP",
+  SAGEMAKER_SP: "SAGEMAKER_SP"
+};
+var SavingsPlansDataType = {
+  AMORTIZED_COMMITMENT: "AMORTIZED_COMMITMENT",
+  ATTRIBUTES: "ATTRIBUTES",
+  SAVINGS: "SAVINGS",
+  UTILIZATION: "UTILIZATION"
+};
+var _UnresolvableUsageUnitException = class _UnresolvableUsageUnitException extends CostExplorerServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "UnresolvableUsageUnitException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "UnresolvableUsageUnitException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _UnresolvableUsageUnitException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_UnresolvableUsageUnitException, "UnresolvableUsageUnitException");
+var UnresolvableUsageUnitException = _UnresolvableUsageUnitException;
+var CostAllocationTagStatus = {
+  ACTIVE: "Active",
+  INACTIVE: "Inactive"
+};
+var CostAllocationTagType = {
+  AWS_GENERATED: "AWSGenerated",
+  USER_DEFINED: "UserDefined"
+};
+var GenerationStatus = {
+  FAILED: "FAILED",
+  PROCESSING: "PROCESSING",
+  SUCCEEDED: "SUCCEEDED"
+};
+var _GenerationExistsException = class _GenerationExistsException extends CostExplorerServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "GenerationExistsException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "GenerationExistsException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _GenerationExistsException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_GenerationExistsException, "GenerationExistsException");
+var GenerationExistsException = _GenerationExistsException;
+var _TooManyTagsException = class _TooManyTagsException extends CostExplorerServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "TooManyTagsException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "TooManyTagsException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _TooManyTagsException.prototype);
+    this.Message = opts.Message;
+    this.ResourceName = opts.ResourceName;
+  }
+};
+__name(_TooManyTagsException, "TooManyTagsException");
+var TooManyTagsException = _TooManyTagsException;
+
+// src/protocols/Aws_json1_1.ts
+var se_CreateAnomalyMonitorCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateAnomalyMonitor");
+  let body;
+  body = JSON.stringify(se_CreateAnomalyMonitorRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateAnomalyMonitorCommand");
+var se_CreateAnomalySubscriptionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateAnomalySubscription");
+  let body;
+  body = JSON.stringify(se_CreateAnomalySubscriptionRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateAnomalySubscriptionCommand");
+var se_CreateCostCategoryDefinitionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateCostCategoryDefinition");
+  let body;
+  body = JSON.stringify(se_CreateCostCategoryDefinitionRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateCostCategoryDefinitionCommand");
+var se_DeleteAnomalyMonitorCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteAnomalyMonitor");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteAnomalyMonitorCommand");
+var se_DeleteAnomalySubscriptionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteAnomalySubscription");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteAnomalySubscriptionCommand");
+var se_DeleteCostCategoryDefinitionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteCostCategoryDefinition");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteCostCategoryDefinitionCommand");
+var se_DescribeCostCategoryDefinitionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeCostCategoryDefinition");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeCostCategoryDefinitionCommand");
+var se_GetAnomaliesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetAnomalies");
+  let body;
+  body = JSON.stringify(se_GetAnomaliesRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetAnomaliesCommand");
+var se_GetAnomalyMonitorsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetAnomalyMonitors");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetAnomalyMonitorsCommand");
+var se_GetAnomalySubscriptionsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetAnomalySubscriptions");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetAnomalySubscriptionsCommand");
+var se_GetCostAndUsageCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetCostAndUsage");
+  let body;
+  body = JSON.stringify(se_GetCostAndUsageRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetCostAndUsageCommand");
+var se_GetCostAndUsageWithResourcesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetCostAndUsageWithResources");
+  let body;
+  body = JSON.stringify(se_GetCostAndUsageWithResourcesRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetCostAndUsageWithResourcesCommand");
+var se_GetCostCategoriesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetCostCategories");
+  let body;
+  body = JSON.stringify(se_GetCostCategoriesRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetCostCategoriesCommand");
+var se_GetCostForecastCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetCostForecast");
+  let body;
+  body = JSON.stringify(se_GetCostForecastRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetCostForecastCommand");
+var se_GetDimensionValuesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetDimensionValues");
+  let body;
+  body = JSON.stringify(se_GetDimensionValuesRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetDimensionValuesCommand");
+var se_GetReservationCoverageCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetReservationCoverage");
+  let body;
+  body = JSON.stringify(se_GetReservationCoverageRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetReservationCoverageCommand");
+var se_GetReservationPurchaseRecommendationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetReservationPurchaseRecommendation");
+  let body;
+  body = JSON.stringify(se_GetReservationPurchaseRecommendationRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetReservationPurchaseRecommendationCommand");
+var se_GetReservationUtilizationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetReservationUtilization");
+  let body;
+  body = JSON.stringify(se_GetReservationUtilizationRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetReservationUtilizationCommand");
+var se_GetRightsizingRecommendationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetRightsizingRecommendation");
+  let body;
+  body = JSON.stringify(se_GetRightsizingRecommendationRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetRightsizingRecommendationCommand");
+var se_GetSavingsPlanPurchaseRecommendationDetailsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetSavingsPlanPurchaseRecommendationDetails");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetSavingsPlanPurchaseRecommendationDetailsCommand");
+var se_GetSavingsPlansCoverageCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetSavingsPlansCoverage");
+  let body;
+  body = JSON.stringify(se_GetSavingsPlansCoverageRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetSavingsPlansCoverageCommand");
+var se_GetSavingsPlansPurchaseRecommendationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetSavingsPlansPurchaseRecommendation");
+  let body;
+  body = JSON.stringify(se_GetSavingsPlansPurchaseRecommendationRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetSavingsPlansPurchaseRecommendationCommand");
+var se_GetSavingsPlansUtilizationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetSavingsPlansUtilization");
+  let body;
+  body = JSON.stringify(se_GetSavingsPlansUtilizationRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetSavingsPlansUtilizationCommand");
+var se_GetSavingsPlansUtilizationDetailsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetSavingsPlansUtilizationDetails");
+  let body;
+  body = JSON.stringify(se_GetSavingsPlansUtilizationDetailsRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetSavingsPlansUtilizationDetailsCommand");
+var se_GetTagsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetTags");
+  let body;
+  body = JSON.stringify(se_GetTagsRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetTagsCommand");
+var se_GetUsageForecastCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetUsageForecast");
+  let body;
+  body = JSON.stringify(se_GetUsageForecastRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetUsageForecastCommand");
+var se_ListCostAllocationTagsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListCostAllocationTags");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListCostAllocationTagsCommand");
+var se_ListCostCategoryDefinitionsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListCostCategoryDefinitions");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListCostCategoryDefinitionsCommand");
+var se_ListSavingsPlansPurchaseRecommendationGenerationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListSavingsPlansPurchaseRecommendationGeneration");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListSavingsPlansPurchaseRecommendationGenerationCommand");
+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_ProvideAnomalyFeedbackCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ProvideAnomalyFeedback");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ProvideAnomalyFeedbackCommand");
+var se_StartSavingsPlansPurchaseRecommendationGenerationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("StartSavingsPlansPurchaseRecommendationGeneration");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_StartSavingsPlansPurchaseRecommendationGenerationCommand");
+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_UpdateAnomalyMonitorCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateAnomalyMonitor");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateAnomalyMonitorCommand");
+var se_UpdateAnomalySubscriptionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateAnomalySubscription");
+  let body;
+  body = JSON.stringify(se_UpdateAnomalySubscriptionRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateAnomalySubscriptionCommand");
+var se_UpdateCostAllocationTagsStatusCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateCostAllocationTagsStatus");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateCostAllocationTagsStatusCommand");
+var se_UpdateCostCategoryDefinitionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateCostCategoryDefinition");
+  let body;
+  body = JSON.stringify(se_UpdateCostCategoryDefinitionRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateCostCategoryDefinitionCommand");
+var de_CreateAnomalyMonitorCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateAnomalyMonitorCommandError(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_CreateAnomalyMonitorCommand");
+var de_CreateAnomalyMonitorCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "LimitExceededException":
+    case "com.amazonaws.costexplorer#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateAnomalyMonitorCommandError");
+var de_CreateAnomalySubscriptionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateAnomalySubscriptionCommandError(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_CreateAnomalySubscriptionCommand");
+var de_CreateAnomalySubscriptionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "LimitExceededException":
+    case "com.amazonaws.costexplorer#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "UnknownMonitorException":
+    case "com.amazonaws.costexplorer#UnknownMonitorException":
+      throw await de_UnknownMonitorExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateAnomalySubscriptionCommandError");
+var de_CreateCostCategoryDefinitionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateCostCategoryDefinitionCommandError(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_CreateCostCategoryDefinitionCommand");
+var de_CreateCostCategoryDefinitionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "LimitExceededException":
+    case "com.amazonaws.costexplorer#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.costexplorer#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateCostCategoryDefinitionCommandError");
+var de_DeleteAnomalyMonitorCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteAnomalyMonitorCommandError(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_DeleteAnomalyMonitorCommand");
+var de_DeleteAnomalyMonitorCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "LimitExceededException":
+    case "com.amazonaws.costexplorer#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "UnknownMonitorException":
+    case "com.amazonaws.costexplorer#UnknownMonitorException":
+      throw await de_UnknownMonitorExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteAnomalyMonitorCommandError");
+var de_DeleteAnomalySubscriptionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteAnomalySubscriptionCommandError(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_DeleteAnomalySubscriptionCommand");
+var de_DeleteAnomalySubscriptionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "LimitExceededException":
+    case "com.amazonaws.costexplorer#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "UnknownSubscriptionException":
+    case "com.amazonaws.costexplorer#UnknownSubscriptionException":
+      throw await de_UnknownSubscriptionExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteAnomalySubscriptionCommandError");
+var de_DeleteCostCategoryDefinitionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteCostCategoryDefinitionCommandError(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_DeleteCostCategoryDefinitionCommand");
+var de_DeleteCostCategoryDefinitionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "LimitExceededException":
+    case "com.amazonaws.costexplorer#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.costexplorer#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteCostCategoryDefinitionCommandError");
+var de_DescribeCostCategoryDefinitionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeCostCategoryDefinitionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeCostCategoryDefinitionResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeCostCategoryDefinitionCommand");
+var de_DescribeCostCategoryDefinitionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "LimitExceededException":
+    case "com.amazonaws.costexplorer#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.costexplorer#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeCostCategoryDefinitionCommandError");
+var de_GetAnomaliesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetAnomaliesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_GetAnomaliesResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetAnomaliesCommand");
+var de_GetAnomaliesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidNextTokenException":
+    case "com.amazonaws.costexplorer#InvalidNextTokenException":
+      throw await de_InvalidNextTokenExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.costexplorer#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetAnomaliesCommandError");
+var de_GetAnomalyMonitorsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetAnomalyMonitorsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_GetAnomalyMonitorsResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetAnomalyMonitorsCommand");
+var de_GetAnomalyMonitorsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidNextTokenException":
+    case "com.amazonaws.costexplorer#InvalidNextTokenException":
+      throw await de_InvalidNextTokenExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.costexplorer#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "UnknownMonitorException":
+    case "com.amazonaws.costexplorer#UnknownMonitorException":
+      throw await de_UnknownMonitorExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetAnomalyMonitorsCommandError");
+var de_GetAnomalySubscriptionsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetAnomalySubscriptionsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_GetAnomalySubscriptionsResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetAnomalySubscriptionsCommand");
+var de_GetAnomalySubscriptionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidNextTokenException":
+    case "com.amazonaws.costexplorer#InvalidNextTokenException":
+      throw await de_InvalidNextTokenExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.costexplorer#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "UnknownSubscriptionException":
+    case "com.amazonaws.costexplorer#UnknownSubscriptionException":
+      throw await de_UnknownSubscriptionExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetAnomalySubscriptionsCommandError");
+var de_GetCostAndUsageCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetCostAndUsageCommandError(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_GetCostAndUsageCommand");
+var de_GetCostAndUsageCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BillExpirationException":
+    case "com.amazonaws.costexplorer#BillExpirationException":
+      throw await de_BillExpirationExceptionRes(parsedOutput, context);
+    case "DataUnavailableException":
+    case "com.amazonaws.costexplorer#DataUnavailableException":
+      throw await de_DataUnavailableExceptionRes(parsedOutput, context);
+    case "InvalidNextTokenException":
+    case "com.amazonaws.costexplorer#InvalidNextTokenException":
+      throw await de_InvalidNextTokenExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.costexplorer#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "RequestChangedException":
+    case "com.amazonaws.costexplorer#RequestChangedException":
+      throw await de_RequestChangedExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetCostAndUsageCommandError");
+var de_GetCostAndUsageWithResourcesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetCostAndUsageWithResourcesCommandError(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_GetCostAndUsageWithResourcesCommand");
+var de_GetCostAndUsageWithResourcesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BillExpirationException":
+    case "com.amazonaws.costexplorer#BillExpirationException":
+      throw await de_BillExpirationExceptionRes(parsedOutput, context);
+    case "DataUnavailableException":
+    case "com.amazonaws.costexplorer#DataUnavailableException":
+      throw await de_DataUnavailableExceptionRes(parsedOutput, context);
+    case "InvalidNextTokenException":
+    case "com.amazonaws.costexplorer#InvalidNextTokenException":
+      throw await de_InvalidNextTokenExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.costexplorer#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "RequestChangedException":
+    case "com.amazonaws.costexplorer#RequestChangedException":
+      throw await de_RequestChangedExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetCostAndUsageWithResourcesCommandError");
+var de_GetCostCategoriesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetCostCategoriesCommandError(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_GetCostCategoriesCommand");
+var de_GetCostCategoriesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BillExpirationException":
+    case "com.amazonaws.costexplorer#BillExpirationException":
+      throw await de_BillExpirationExceptionRes(parsedOutput, context);
+    case "DataUnavailableException":
+    case "com.amazonaws.costexplorer#DataUnavailableException":
+      throw await de_DataUnavailableExceptionRes(parsedOutput, context);
+    case "InvalidNextTokenException":
+    case "com.amazonaws.costexplorer#InvalidNextTokenException":
+      throw await de_InvalidNextTokenExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.costexplorer#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "RequestChangedException":
+    case "com.amazonaws.costexplorer#RequestChangedException":
+      throw await de_RequestChangedExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetCostCategoriesCommandError");
+var de_GetCostForecastCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetCostForecastCommandError(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_GetCostForecastCommand");
+var de_GetCostForecastCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DataUnavailableException":
+    case "com.amazonaws.costexplorer#DataUnavailableException":
+      throw await de_DataUnavailableExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.costexplorer#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetCostForecastCommandError");
+var de_GetDimensionValuesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetDimensionValuesCommandError(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_GetDimensionValuesCommand");
+var de_GetDimensionValuesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BillExpirationException":
+    case "com.amazonaws.costexplorer#BillExpirationException":
+      throw await de_BillExpirationExceptionRes(parsedOutput, context);
+    case "DataUnavailableException":
+    case "com.amazonaws.costexplorer#DataUnavailableException":
+      throw await de_DataUnavailableExceptionRes(parsedOutput, context);
+    case "InvalidNextTokenException":
+    case "com.amazonaws.costexplorer#InvalidNextTokenException":
+      throw await de_InvalidNextTokenExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.costexplorer#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "RequestChangedException":
+    case "com.amazonaws.costexplorer#RequestChangedException":
+      throw await de_RequestChangedExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetDimensionValuesCommandError");
+var de_GetReservationCoverageCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetReservationCoverageCommandError(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_GetReservationCoverageCommand");
+var de_GetReservationCoverageCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DataUnavailableException":
+    case "com.amazonaws.costexplorer#DataUnavailableException":
+      throw await de_DataUnavailableExceptionRes(parsedOutput, context);
+    case "InvalidNextTokenException":
+    case "com.amazonaws.costexplorer#InvalidNextTokenException":
+      throw await de_InvalidNextTokenExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.costexplorer#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetReservationCoverageCommandError");
+var de_GetReservationPurchaseRecommendationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetReservationPurchaseRecommendationCommandError(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_GetReservationPurchaseRecommendationCommand");
+var de_GetReservationPurchaseRecommendationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DataUnavailableException":
+    case "com.amazonaws.costexplorer#DataUnavailableException":
+      throw await de_DataUnavailableExceptionRes(parsedOutput, context);
+    case "InvalidNextTokenException":
+    case "com.amazonaws.costexplorer#InvalidNextTokenException":
+      throw await de_InvalidNextTokenExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.costexplorer#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetReservationPurchaseRecommendationCommandError");
+var de_GetReservationUtilizationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetReservationUtilizationCommandError(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_GetReservationUtilizationCommand");
+var de_GetReservationUtilizationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DataUnavailableException":
+    case "com.amazonaws.costexplorer#DataUnavailableException":
+      throw await de_DataUnavailableExceptionRes(parsedOutput, context);
+    case "InvalidNextTokenException":
+    case "com.amazonaws.costexplorer#InvalidNextTokenException":
+      throw await de_InvalidNextTokenExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.costexplorer#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetReservationUtilizationCommandError");
+var de_GetRightsizingRecommendationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetRightsizingRecommendationCommandError(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_GetRightsizingRecommendationCommand");
+var de_GetRightsizingRecommendationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidNextTokenException":
+    case "com.amazonaws.costexplorer#InvalidNextTokenException":
+      throw await de_InvalidNextTokenExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.costexplorer#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetRightsizingRecommendationCommandError");
+var de_GetSavingsPlanPurchaseRecommendationDetailsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetSavingsPlanPurchaseRecommendationDetailsCommandError(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_GetSavingsPlanPurchaseRecommendationDetailsCommand");
+var de_GetSavingsPlanPurchaseRecommendationDetailsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DataUnavailableException":
+    case "com.amazonaws.costexplorer#DataUnavailableException":
+      throw await de_DataUnavailableExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.costexplorer#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetSavingsPlanPurchaseRecommendationDetailsCommandError");
+var de_GetSavingsPlansCoverageCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetSavingsPlansCoverageCommandError(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_GetSavingsPlansCoverageCommand");
+var de_GetSavingsPlansCoverageCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DataUnavailableException":
+    case "com.amazonaws.costexplorer#DataUnavailableException":
+      throw await de_DataUnavailableExceptionRes(parsedOutput, context);
+    case "InvalidNextTokenException":
+    case "com.amazonaws.costexplorer#InvalidNextTokenException":
+      throw await de_InvalidNextTokenExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.costexplorer#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetSavingsPlansCoverageCommandError");
+var de_GetSavingsPlansPurchaseRecommendationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetSavingsPlansPurchaseRecommendationCommandError(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_GetSavingsPlansPurchaseRecommendationCommand");
+var de_GetSavingsPlansPurchaseRecommendationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidNextTokenException":
+    case "com.amazonaws.costexplorer#InvalidNextTokenException":
+      throw await de_InvalidNextTokenExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.costexplorer#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetSavingsPlansPurchaseRecommendationCommandError");
+var de_GetSavingsPlansUtilizationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetSavingsPlansUtilizationCommandError(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_GetSavingsPlansUtilizationCommand");
+var de_GetSavingsPlansUtilizationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DataUnavailableException":
+    case "com.amazonaws.costexplorer#DataUnavailableException":
+      throw await de_DataUnavailableExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.costexplorer#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetSavingsPlansUtilizationCommandError");
+var de_GetSavingsPlansUtilizationDetailsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetSavingsPlansUtilizationDetailsCommandError(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_GetSavingsPlansUtilizationDetailsCommand");
+var de_GetSavingsPlansUtilizationDetailsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DataUnavailableException":
+    case "com.amazonaws.costexplorer#DataUnavailableException":
+      throw await de_DataUnavailableExceptionRes(parsedOutput, context);
+    case "InvalidNextTokenException":
+    case "com.amazonaws.costexplorer#InvalidNextTokenException":
+      throw await de_InvalidNextTokenExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.costexplorer#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetSavingsPlansUtilizationDetailsCommandError");
+var de_GetTagsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetTagsCommandError(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_GetTagsCommand");
+var de_GetTagsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BillExpirationException":
+    case "com.amazonaws.costexplorer#BillExpirationException":
+      throw await de_BillExpirationExceptionRes(parsedOutput, context);
+    case "DataUnavailableException":
+    case "com.amazonaws.costexplorer#DataUnavailableException":
+      throw await de_DataUnavailableExceptionRes(parsedOutput, context);
+    case "InvalidNextTokenException":
+    case "com.amazonaws.costexplorer#InvalidNextTokenException":
+      throw await de_InvalidNextTokenExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.costexplorer#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "RequestChangedException":
+    case "com.amazonaws.costexplorer#RequestChangedException":
+      throw await de_RequestChangedExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetTagsCommandError");
+var de_GetUsageForecastCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetUsageForecastCommandError(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_GetUsageForecastCommand");
+var de_GetUsageForecastCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DataUnavailableException":
+    case "com.amazonaws.costexplorer#DataUnavailableException":
+      throw await de_DataUnavailableExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.costexplorer#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "UnresolvableUsageUnitException":
+    case "com.amazonaws.costexplorer#UnresolvableUsageUnitException":
+      throw await de_UnresolvableUsageUnitExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetUsageForecastCommandError");
+var de_ListCostAllocationTagsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListCostAllocationTagsCommandError(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_ListCostAllocationTagsCommand");
+var de_ListCostAllocationTagsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidNextTokenException":
+    case "com.amazonaws.costexplorer#InvalidNextTokenException":
+      throw await de_InvalidNextTokenExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.costexplorer#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListCostAllocationTagsCommandError");
+var de_ListCostCategoryDefinitionsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListCostCategoryDefinitionsCommandError(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_ListCostCategoryDefinitionsCommand");
+var de_ListCostCategoryDefinitionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "LimitExceededException":
+    case "com.amazonaws.costexplorer#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListCostCategoryDefinitionsCommandError");
+var de_ListSavingsPlansPurchaseRecommendationGenerationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListSavingsPlansPurchaseRecommendationGenerationCommandError(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_ListSavingsPlansPurchaseRecommendationGenerationCommand");
+var de_ListSavingsPlansPurchaseRecommendationGenerationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DataUnavailableException":
+    case "com.amazonaws.costexplorer#DataUnavailableException":
+      throw await de_DataUnavailableExceptionRes(parsedOutput, context);
+    case "InvalidNextTokenException":
+    case "com.amazonaws.costexplorer#InvalidNextTokenException":
+      throw await de_InvalidNextTokenExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.costexplorer#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListSavingsPlansPurchaseRecommendationGenerationCommandError");
+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 "LimitExceededException":
+    case "com.amazonaws.costexplorer#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.costexplorer#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListTagsForResourceCommandError");
+var de_ProvideAnomalyFeedbackCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ProvideAnomalyFeedbackCommandError(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_ProvideAnomalyFeedbackCommand");
+var de_ProvideAnomalyFeedbackCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "LimitExceededException":
+    case "com.amazonaws.costexplorer#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ProvideAnomalyFeedbackCommandError");
+var de_StartSavingsPlansPurchaseRecommendationGenerationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_StartSavingsPlansPurchaseRecommendationGenerationCommandError(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_StartSavingsPlansPurchaseRecommendationGenerationCommand");
+var de_StartSavingsPlansPurchaseRecommendationGenerationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DataUnavailableException":
+    case "com.amazonaws.costexplorer#DataUnavailableException":
+      throw await de_DataUnavailableExceptionRes(parsedOutput, context);
+    case "GenerationExistsException":
+    case "com.amazonaws.costexplorer#GenerationExistsException":
+      throw await de_GenerationExistsExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.costexplorer#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.costexplorer#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_StartSavingsPlansPurchaseRecommendationGenerationCommandError");
+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 "LimitExceededException":
+    case "com.amazonaws.costexplorer#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.costexplorer#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "TooManyTagsException":
+    case "com.amazonaws.costexplorer#TooManyTagsException":
+      throw await de_TooManyTagsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_TagResourceCommandError");
+var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UntagResourceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UntagResourceCommand");
+var de_UntagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "LimitExceededException":
+    case "com.amazonaws.costexplorer#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.costexplorer#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UntagResourceCommandError");
+var de_UpdateAnomalyMonitorCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateAnomalyMonitorCommandError(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_UpdateAnomalyMonitorCommand");
+var de_UpdateAnomalyMonitorCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "LimitExceededException":
+    case "com.amazonaws.costexplorer#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "UnknownMonitorException":
+    case "com.amazonaws.costexplorer#UnknownMonitorException":
+      throw await de_UnknownMonitorExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateAnomalyMonitorCommandError");
+var de_UpdateAnomalySubscriptionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateAnomalySubscriptionCommandError(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_UpdateAnomalySubscriptionCommand");
+var de_UpdateAnomalySubscriptionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "LimitExceededException":
+    case "com.amazonaws.costexplorer#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "UnknownMonitorException":
+    case "com.amazonaws.costexplorer#UnknownMonitorException":
+      throw await de_UnknownMonitorExceptionRes(parsedOutput, context);
+    case "UnknownSubscriptionException":
+    case "com.amazonaws.costexplorer#UnknownSubscriptionException":
+      throw await de_UnknownSubscriptionExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateAnomalySubscriptionCommandError");
+var de_UpdateCostAllocationTagsStatusCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateCostAllocationTagsStatusCommandError(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_UpdateCostAllocationTagsStatusCommand");
+var de_UpdateCostAllocationTagsStatusCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "LimitExceededException":
+    case "com.amazonaws.costexplorer#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateCostAllocationTagsStatusCommandError");
+var de_UpdateCostCategoryDefinitionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateCostCategoryDefinitionCommandError(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_UpdateCostCategoryDefinitionCommand");
+var de_UpdateCostCategoryDefinitionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "LimitExceededException":
+    case "com.amazonaws.costexplorer#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.costexplorer#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.costexplorer#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateCostCategoryDefinitionCommandError");
+var de_BillExpirationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new BillExpirationException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_BillExpirationExceptionRes");
+var de_DataUnavailableExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new DataUnavailableException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_DataUnavailableExceptionRes");
+var de_GenerationExistsExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new GenerationExistsException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_GenerationExistsExceptionRes");
+var de_InvalidNextTokenExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidNextTokenException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidNextTokenExceptionRes");
+var de_LimitExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new LimitExceededException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_LimitExceededExceptionRes");
+var de_RequestChangedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new RequestChangedException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_RequestChangedExceptionRes");
+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_ServiceQuotaExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ServiceQuotaExceededException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ServiceQuotaExceededExceptionRes");
+var de_TooManyTagsExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new TooManyTagsException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_TooManyTagsExceptionRes");
+var de_UnknownMonitorExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new UnknownMonitorException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_UnknownMonitorExceptionRes");
+var de_UnknownSubscriptionExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new UnknownSubscriptionException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_UnknownSubscriptionExceptionRes");
+var de_UnresolvableUsageUnitExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new UnresolvableUsageUnitException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_UnresolvableUsageUnitExceptionRes");
+var se_AnomalyMonitor = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    CreationDate: [],
+    DimensionalValueCount: [],
+    LastEvaluatedDate: [],
+    LastUpdatedDate: [],
+    MonitorArn: [],
+    MonitorDimension: [],
+    MonitorName: [],
+    MonitorSpecification: (_) => se_Expression(_, context),
+    MonitorType: []
+  });
+}, "se_AnomalyMonitor");
+var se_AnomalySubscription = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    AccountId: [],
+    Frequency: [],
+    MonitorArnList: import_smithy_client._json,
+    Subscribers: import_smithy_client._json,
+    SubscriptionArn: [],
+    SubscriptionName: [],
+    Threshold: import_smithy_client.serializeFloat,
+    ThresholdExpression: (_) => se_Expression(_, context)
+  });
+}, "se_AnomalySubscription");
+var se_CostCategoryRule = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    InheritedValue: import_smithy_client._json,
+    Rule: (_) => se_Expression(_, context),
+    Type: [],
+    Value: []
+  });
+}, "se_CostCategoryRule");
+var se_CostCategoryRulesList = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_CostCategoryRule(entry, context);
+  });
+}, "se_CostCategoryRulesList");
+var se_CreateAnomalyMonitorRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    AnomalyMonitor: (_) => se_AnomalyMonitor(_, context),
+    ResourceTags: import_smithy_client._json
+  });
+}, "se_CreateAnomalyMonitorRequest");
+var se_CreateAnomalySubscriptionRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    AnomalySubscription: (_) => se_AnomalySubscription(_, context),
+    ResourceTags: import_smithy_client._json
+  });
+}, "se_CreateAnomalySubscriptionRequest");
+var se_CreateCostCategoryDefinitionRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    DefaultValue: [],
+    EffectiveStart: [],
+    Name: [],
+    ResourceTags: import_smithy_client._json,
+    RuleVersion: [],
+    Rules: (_) => se_CostCategoryRulesList(_, context),
+    SplitChargeRules: import_smithy_client._json
+  });
+}, "se_CreateCostCategoryDefinitionRequest");
+var se_Expression = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    And: (_) => se_Expressions(_, context),
+    CostCategories: import_smithy_client._json,
+    Dimensions: import_smithy_client._json,
+    Not: (_) => se_Expression(_, context),
+    Or: (_) => se_Expressions(_, context),
+    Tags: import_smithy_client._json
+  });
+}, "se_Expression");
+var se_Expressions = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_Expression(entry, context);
+  });
+}, "se_Expressions");
+var se_GetAnomaliesRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    DateInterval: import_smithy_client._json,
+    Feedback: [],
+    MaxResults: [],
+    MonitorArn: [],
+    NextPageToken: [],
+    TotalImpact: (_) => se_TotalImpactFilter(_, context)
+  });
+}, "se_GetAnomaliesRequest");
+var se_GetCostAndUsageRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Filter: (_) => se_Expression(_, context),
+    Granularity: [],
+    GroupBy: import_smithy_client._json,
+    Metrics: import_smithy_client._json,
+    NextPageToken: [],
+    TimePeriod: import_smithy_client._json
+  });
+}, "se_GetCostAndUsageRequest");
+var se_GetCostAndUsageWithResourcesRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Filter: (_) => se_Expression(_, context),
+    Granularity: [],
+    GroupBy: import_smithy_client._json,
+    Metrics: import_smithy_client._json,
+    NextPageToken: [],
+    TimePeriod: import_smithy_client._json
+  });
+}, "se_GetCostAndUsageWithResourcesRequest");
+var se_GetCostCategoriesRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    CostCategoryName: [],
+    Filter: (_) => se_Expression(_, context),
+    MaxResults: [],
+    NextPageToken: [],
+    SearchString: [],
+    SortBy: import_smithy_client._json,
+    TimePeriod: import_smithy_client._json
+  });
+}, "se_GetCostCategoriesRequest");
+var se_GetCostForecastRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Filter: (_) => se_Expression(_, context),
+    Granularity: [],
+    Metric: [],
+    PredictionIntervalLevel: [],
+    TimePeriod: import_smithy_client._json
+  });
+}, "se_GetCostForecastRequest");
+var se_GetDimensionValuesRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Context: [],
+    Dimension: [],
+    Filter: (_) => se_Expression(_, context),
+    MaxResults: [],
+    NextPageToken: [],
+    SearchString: [],
+    SortBy: import_smithy_client._json,
+    TimePeriod: import_smithy_client._json
+  });
+}, "se_GetDimensionValuesRequest");
+var se_GetReservationCoverageRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Filter: (_) => se_Expression(_, context),
+    Granularity: [],
+    GroupBy: import_smithy_client._json,
+    MaxResults: [],
+    Metrics: import_smithy_client._json,
+    NextPageToken: [],
+    SortBy: import_smithy_client._json,
+    TimePeriod: import_smithy_client._json
+  });
+}, "se_GetReservationCoverageRequest");
+var se_GetReservationPurchaseRecommendationRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    AccountId: [],
+    AccountScope: [],
+    Filter: (_) => se_Expression(_, context),
+    LookbackPeriodInDays: [],
+    NextPageToken: [],
+    PageSize: [],
+    PaymentOption: [],
+    Service: [],
+    ServiceSpecification: import_smithy_client._json,
+    TermInYears: []
+  });
+}, "se_GetReservationPurchaseRecommendationRequest");
+var se_GetReservationUtilizationRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Filter: (_) => se_Expression(_, context),
+    Granularity: [],
+    GroupBy: import_smithy_client._json,
+    MaxResults: [],
+    NextPageToken: [],
+    SortBy: import_smithy_client._json,
+    TimePeriod: import_smithy_client._json
+  });
+}, "se_GetReservationUtilizationRequest");
+var se_GetRightsizingRecommendationRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Configuration: import_smithy_client._json,
+    Filter: (_) => se_Expression(_, context),
+    NextPageToken: [],
+    PageSize: [],
+    Service: []
+  });
+}, "se_GetRightsizingRecommendationRequest");
+var se_GetSavingsPlansCoverageRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Filter: (_) => se_Expression(_, context),
+    Granularity: [],
+    GroupBy: import_smithy_client._json,
+    MaxResults: [],
+    Metrics: import_smithy_client._json,
+    NextToken: [],
+    SortBy: import_smithy_client._json,
+    TimePeriod: import_smithy_client._json
+  });
+}, "se_GetSavingsPlansCoverageRequest");
+var se_GetSavingsPlansPurchaseRecommendationRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    AccountScope: [],
+    Filter: (_) => se_Expression(_, context),
+    LookbackPeriodInDays: [],
+    NextPageToken: [],
+    PageSize: [],
+    PaymentOption: [],
+    SavingsPlansType: [],
+    TermInYears: []
+  });
+}, "se_GetSavingsPlansPurchaseRecommendationRequest");
+var se_GetSavingsPlansUtilizationDetailsRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    DataType: import_smithy_client._json,
+    Filter: (_) => se_Expression(_, context),
+    MaxResults: [],
+    NextToken: [],
+    SortBy: import_smithy_client._json,
+    TimePeriod: import_smithy_client._json
+  });
+}, "se_GetSavingsPlansUtilizationDetailsRequest");
+var se_GetSavingsPlansUtilizationRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Filter: (_) => se_Expression(_, context),
+    Granularity: [],
+    SortBy: import_smithy_client._json,
+    TimePeriod: import_smithy_client._json
+  });
+}, "se_GetSavingsPlansUtilizationRequest");
+var se_GetTagsRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Filter: (_) => se_Expression(_, context),
+    MaxResults: [],
+    NextPageToken: [],
+    SearchString: [],
+    SortBy: import_smithy_client._json,
+    TagKey: [],
+    TimePeriod: import_smithy_client._json
+  });
+}, "se_GetTagsRequest");
+var se_GetUsageForecastRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Filter: (_) => se_Expression(_, context),
+    Granularity: [],
+    Metric: [],
+    PredictionIntervalLevel: [],
+    TimePeriod: import_smithy_client._json
+  });
+}, "se_GetUsageForecastRequest");
+var se_TotalImpactFilter = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    EndValue: import_smithy_client.serializeFloat,
+    NumericOperator: [],
+    StartValue: import_smithy_client.serializeFloat
+  });
+}, "se_TotalImpactFilter");
+var se_UpdateAnomalySubscriptionRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Frequency: [],
+    MonitorArnList: import_smithy_client._json,
+    Subscribers: import_smithy_client._json,
+    SubscriptionArn: [],
+    SubscriptionName: [],
+    Threshold: import_smithy_client.serializeFloat,
+    ThresholdExpression: (_) => se_Expression(_, context)
+  });
+}, "se_UpdateAnomalySubscriptionRequest");
+var se_UpdateCostCategoryDefinitionRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    CostCategoryArn: [],
+    DefaultValue: [],
+    EffectiveStart: [],
+    RuleVersion: [],
+    Rules: (_) => se_CostCategoryRulesList(_, context),
+    SplitChargeRules: import_smithy_client._json
+  });
+}, "se_UpdateCostCategoryDefinitionRequest");
+var de_Anomalies = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Anomaly(entry, context);
+  });
+  return retVal;
+}, "de_Anomalies");
+var de_Anomaly = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AnomalyEndDate: import_smithy_client.expectString,
+    AnomalyId: import_smithy_client.expectString,
+    AnomalyScore: (_) => de_AnomalyScore(_, context),
+    AnomalyStartDate: import_smithy_client.expectString,
+    DimensionValue: import_smithy_client.expectString,
+    Feedback: import_smithy_client.expectString,
+    Impact: (_) => de_Impact(_, context),
+    MonitorArn: import_smithy_client.expectString,
+    RootCauses: import_smithy_client._json
+  });
+}, "de_Anomaly");
+var de_AnomalyMonitor = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    CreationDate: import_smithy_client.expectString,
+    DimensionalValueCount: import_smithy_client.expectInt32,
+    LastEvaluatedDate: import_smithy_client.expectString,
+    LastUpdatedDate: import_smithy_client.expectString,
+    MonitorArn: import_smithy_client.expectString,
+    MonitorDimension: import_smithy_client.expectString,
+    MonitorName: import_smithy_client.expectString,
+    MonitorSpecification: (_) => de_Expression(_, context),
+    MonitorType: import_smithy_client.expectString
+  });
+}, "de_AnomalyMonitor");
+var de_AnomalyMonitors = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_AnomalyMonitor(entry, context);
+  });
+  return retVal;
+}, "de_AnomalyMonitors");
+var de_AnomalyScore = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    CurrentScore: import_smithy_client.limitedParseDouble,
+    MaxScore: import_smithy_client.limitedParseDouble
+  });
+}, "de_AnomalyScore");
+var de_AnomalySubscription = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AccountId: import_smithy_client.expectString,
+    Frequency: import_smithy_client.expectString,
+    MonitorArnList: import_smithy_client._json,
+    Subscribers: import_smithy_client._json,
+    SubscriptionArn: import_smithy_client.expectString,
+    SubscriptionName: import_smithy_client.expectString,
+    Threshold: import_smithy_client.limitedParseDouble,
+    ThresholdExpression: (_) => de_Expression(_, context)
+  });
+}, "de_AnomalySubscription");
+var de_AnomalySubscriptions = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_AnomalySubscription(entry, context);
+  });
+  return retVal;
+}, "de_AnomalySubscriptions");
+var de_CostCategory = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    CostCategoryArn: import_smithy_client.expectString,
+    DefaultValue: import_smithy_client.expectString,
+    EffectiveEnd: import_smithy_client.expectString,
+    EffectiveStart: import_smithy_client.expectString,
+    Name: import_smithy_client.expectString,
+    ProcessingStatus: import_smithy_client._json,
+    RuleVersion: import_smithy_client.expectString,
+    Rules: (_) => de_CostCategoryRulesList(_, context),
+    SplitChargeRules: import_smithy_client._json
+  });
+}, "de_CostCategory");
+var de_CostCategoryRule = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    InheritedValue: import_smithy_client._json,
+    Rule: (_) => de_Expression(_, context),
+    Type: import_smithy_client.expectString,
+    Value: import_smithy_client.expectString
+  });
+}, "de_CostCategoryRule");
+var de_CostCategoryRulesList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_CostCategoryRule(entry, context);
+  });
+  return retVal;
+}, "de_CostCategoryRulesList");
+var de_DescribeCostCategoryDefinitionResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    CostCategory: (_) => de_CostCategory(_, context)
+  });
+}, "de_DescribeCostCategoryDefinitionResponse");
+var de_Expression = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    And: (_) => de_Expressions(_, context),
+    CostCategories: import_smithy_client._json,
+    Dimensions: import_smithy_client._json,
+    Not: (_) => de_Expression(_, context),
+    Or: (_) => de_Expressions(_, context),
+    Tags: import_smithy_client._json
+  });
+}, "de_Expression");
+var de_Expressions = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Expression(entry, context);
+  });
+  return retVal;
+}, "de_Expressions");
+var de_GetAnomaliesResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Anomalies: (_) => de_Anomalies(_, context),
+    NextPageToken: import_smithy_client.expectString
+  });
+}, "de_GetAnomaliesResponse");
+var de_GetAnomalyMonitorsResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AnomalyMonitors: (_) => de_AnomalyMonitors(_, context),
+    NextPageToken: import_smithy_client.expectString
+  });
+}, "de_GetAnomalyMonitorsResponse");
+var de_GetAnomalySubscriptionsResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AnomalySubscriptions: (_) => de_AnomalySubscriptions(_, context),
+    NextPageToken: import_smithy_client.expectString
+  });
+}, "de_GetAnomalySubscriptionsResponse");
+var de_Impact = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    MaxImpact: import_smithy_client.limitedParseDouble,
+    TotalActualSpend: import_smithy_client.limitedParseDouble,
+    TotalExpectedSpend: import_smithy_client.limitedParseDouble,
+    TotalImpact: import_smithy_client.limitedParseDouble,
+    TotalImpactPercentage: import_smithy_client.limitedParseDouble
+  });
+}, "de_Impact");
+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)(CostExplorerServiceException);
+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": `AWSInsightsIndexService.${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/CreateAnomalyMonitorCommand.ts
+var _CreateAnomalyMonitorCommand = class _CreateAnomalyMonitorCommand 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("AWSInsightsIndexService", "CreateAnomalyMonitor", {}).n("CostExplorerClient", "CreateAnomalyMonitorCommand").f(void 0, void 0).ser(se_CreateAnomalyMonitorCommand).de(de_CreateAnomalyMonitorCommand).build() {
+};
+__name(_CreateAnomalyMonitorCommand, "CreateAnomalyMonitorCommand");
+var CreateAnomalyMonitorCommand = _CreateAnomalyMonitorCommand;
+
+// src/commands/CreateAnomalySubscriptionCommand.ts
+
+
+
+
+var _CreateAnomalySubscriptionCommand = class _CreateAnomalySubscriptionCommand 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("AWSInsightsIndexService", "CreateAnomalySubscription", {}).n("CostExplorerClient", "CreateAnomalySubscriptionCommand").f(void 0, void 0).ser(se_CreateAnomalySubscriptionCommand).de(de_CreateAnomalySubscriptionCommand).build() {
+};
+__name(_CreateAnomalySubscriptionCommand, "CreateAnomalySubscriptionCommand");
+var CreateAnomalySubscriptionCommand = _CreateAnomalySubscriptionCommand;
+
+// src/commands/CreateCostCategoryDefinitionCommand.ts
+
+
+
+
+var _CreateCostCategoryDefinitionCommand = class _CreateCostCategoryDefinitionCommand 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("AWSInsightsIndexService", "CreateCostCategoryDefinition", {}).n("CostExplorerClient", "CreateCostCategoryDefinitionCommand").f(void 0, void 0).ser(se_CreateCostCategoryDefinitionCommand).de(de_CreateCostCategoryDefinitionCommand).build() {
+};
+__name(_CreateCostCategoryDefinitionCommand, "CreateCostCategoryDefinitionCommand");
+var CreateCostCategoryDefinitionCommand = _CreateCostCategoryDefinitionCommand;
+
+// src/commands/DeleteAnomalyMonitorCommand.ts
+
+
+
+
+var _DeleteAnomalyMonitorCommand = class _DeleteAnomalyMonitorCommand 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("AWSInsightsIndexService", "DeleteAnomalyMonitor", {}).n("CostExplorerClient", "DeleteAnomalyMonitorCommand").f(void 0, void 0).ser(se_DeleteAnomalyMonitorCommand).de(de_DeleteAnomalyMonitorCommand).build() {
+};
+__name(_DeleteAnomalyMonitorCommand, "DeleteAnomalyMonitorCommand");
+var DeleteAnomalyMonitorCommand = _DeleteAnomalyMonitorCommand;
+
+// src/commands/DeleteAnomalySubscriptionCommand.ts
+
+
+
+
+var _DeleteAnomalySubscriptionCommand = class _DeleteAnomalySubscriptionCommand 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("AWSInsightsIndexService", "DeleteAnomalySubscription", {}).n("CostExplorerClient", "DeleteAnomalySubscriptionCommand").f(void 0, void 0).ser(se_DeleteAnomalySubscriptionCommand).de(de_DeleteAnomalySubscriptionCommand).build() {
+};
+__name(_DeleteAnomalySubscriptionCommand, "DeleteAnomalySubscriptionCommand");
+var DeleteAnomalySubscriptionCommand = _DeleteAnomalySubscriptionCommand;
+
+// src/commands/DeleteCostCategoryDefinitionCommand.ts
+
+
+
+
+var _DeleteCostCategoryDefinitionCommand = class _DeleteCostCategoryDefinitionCommand 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("AWSInsightsIndexService", "DeleteCostCategoryDefinition", {}).n("CostExplorerClient", "DeleteCostCategoryDefinitionCommand").f(void 0, void 0).ser(se_DeleteCostCategoryDefinitionCommand).de(de_DeleteCostCategoryDefinitionCommand).build() {
+};
+__name(_DeleteCostCategoryDefinitionCommand, "DeleteCostCategoryDefinitionCommand");
+var DeleteCostCategoryDefinitionCommand = _DeleteCostCategoryDefinitionCommand;
+
+// src/commands/DescribeCostCategoryDefinitionCommand.ts
+
+
+
+
+var _DescribeCostCategoryDefinitionCommand = class _DescribeCostCategoryDefinitionCommand 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("AWSInsightsIndexService", "DescribeCostCategoryDefinition", {}).n("CostExplorerClient", "DescribeCostCategoryDefinitionCommand").f(void 0, void 0).ser(se_DescribeCostCategoryDefinitionCommand).de(de_DescribeCostCategoryDefinitionCommand).build() {
+};
+__name(_DescribeCostCategoryDefinitionCommand, "DescribeCostCategoryDefinitionCommand");
+var DescribeCostCategoryDefinitionCommand = _DescribeCostCategoryDefinitionCommand;
+
+// src/commands/GetAnomaliesCommand.ts
+
+
+
+
+var _GetAnomaliesCommand = class _GetAnomaliesCommand 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("AWSInsightsIndexService", "GetAnomalies", {}).n("CostExplorerClient", "GetAnomaliesCommand").f(void 0, void 0).ser(se_GetAnomaliesCommand).de(de_GetAnomaliesCommand).build() {
+};
+__name(_GetAnomaliesCommand, "GetAnomaliesCommand");
+var GetAnomaliesCommand = _GetAnomaliesCommand;
+
+// src/commands/GetAnomalyMonitorsCommand.ts
+
+
+
+
+var _GetAnomalyMonitorsCommand = class _GetAnomalyMonitorsCommand 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("AWSInsightsIndexService", "GetAnomalyMonitors", {}).n("CostExplorerClient", "GetAnomalyMonitorsCommand").f(void 0, void 0).ser(se_GetAnomalyMonitorsCommand).de(de_GetAnomalyMonitorsCommand).build() {
+};
+__name(_GetAnomalyMonitorsCommand, "GetAnomalyMonitorsCommand");
+var GetAnomalyMonitorsCommand = _GetAnomalyMonitorsCommand;
+
+// src/commands/GetAnomalySubscriptionsCommand.ts
+
+
+
+
+var _GetAnomalySubscriptionsCommand = class _GetAnomalySubscriptionsCommand 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("AWSInsightsIndexService", "GetAnomalySubscriptions", {}).n("CostExplorerClient", "GetAnomalySubscriptionsCommand").f(void 0, void 0).ser(se_GetAnomalySubscriptionsCommand).de(de_GetAnomalySubscriptionsCommand).build() {
+};
+__name(_GetAnomalySubscriptionsCommand, "GetAnomalySubscriptionsCommand");
+var GetAnomalySubscriptionsCommand = _GetAnomalySubscriptionsCommand;
+
+// src/commands/GetCostAndUsageCommand.ts
+
+
+
+
+var _GetCostAndUsageCommand = class _GetCostAndUsageCommand 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("AWSInsightsIndexService", "GetCostAndUsage", {}).n("CostExplorerClient", "GetCostAndUsageCommand").f(void 0, void 0).ser(se_GetCostAndUsageCommand).de(de_GetCostAndUsageCommand).build() {
+};
+__name(_GetCostAndUsageCommand, "GetCostAndUsageCommand");
+var GetCostAndUsageCommand = _GetCostAndUsageCommand;
+
+// src/commands/GetCostAndUsageWithResourcesCommand.ts
+
+
+
+
+var _GetCostAndUsageWithResourcesCommand = class _GetCostAndUsageWithResourcesCommand 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("AWSInsightsIndexService", "GetCostAndUsageWithResources", {}).n("CostExplorerClient", "GetCostAndUsageWithResourcesCommand").f(void 0, void 0).ser(se_GetCostAndUsageWithResourcesCommand).de(de_GetCostAndUsageWithResourcesCommand).build() {
+};
+__name(_GetCostAndUsageWithResourcesCommand, "GetCostAndUsageWithResourcesCommand");
+var GetCostAndUsageWithResourcesCommand = _GetCostAndUsageWithResourcesCommand;
+
+// src/commands/GetCostCategoriesCommand.ts
+
+
+
+
+var _GetCostCategoriesCommand = class _GetCostCategoriesCommand 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("AWSInsightsIndexService", "GetCostCategories", {}).n("CostExplorerClient", "GetCostCategoriesCommand").f(void 0, void 0).ser(se_GetCostCategoriesCommand).de(de_GetCostCategoriesCommand).build() {
+};
+__name(_GetCostCategoriesCommand, "GetCostCategoriesCommand");
+var GetCostCategoriesCommand = _GetCostCategoriesCommand;
+
+// src/commands/GetCostForecastCommand.ts
+
+
+
+
+var _GetCostForecastCommand = class _GetCostForecastCommand 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("AWSInsightsIndexService", "GetCostForecast", {}).n("CostExplorerClient", "GetCostForecastCommand").f(void 0, void 0).ser(se_GetCostForecastCommand).de(de_GetCostForecastCommand).build() {
+};
+__name(_GetCostForecastCommand, "GetCostForecastCommand");
+var GetCostForecastCommand = _GetCostForecastCommand;
+
+// src/commands/GetDimensionValuesCommand.ts
+
+
+
+
+var _GetDimensionValuesCommand = class _GetDimensionValuesCommand 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("AWSInsightsIndexService", "GetDimensionValues", {}).n("CostExplorerClient", "GetDimensionValuesCommand").f(void 0, void 0).ser(se_GetDimensionValuesCommand).de(de_GetDimensionValuesCommand).build() {
+};
+__name(_GetDimensionValuesCommand, "GetDimensionValuesCommand");
+var GetDimensionValuesCommand = _GetDimensionValuesCommand;
+
+// src/commands/GetReservationCoverageCommand.ts
+
+
+
+
+var _GetReservationCoverageCommand = class _GetReservationCoverageCommand 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("AWSInsightsIndexService", "GetReservationCoverage", {}).n("CostExplorerClient", "GetReservationCoverageCommand").f(void 0, void 0).ser(se_GetReservationCoverageCommand).de(de_GetReservationCoverageCommand).build() {
+};
+__name(_GetReservationCoverageCommand, "GetReservationCoverageCommand");
+var GetReservationCoverageCommand = _GetReservationCoverageCommand;
+
+// src/commands/GetReservationPurchaseRecommendationCommand.ts
+
+
+
+
+var _GetReservationPurchaseRecommendationCommand = class _GetReservationPurchaseRecommendationCommand 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("AWSInsightsIndexService", "GetReservationPurchaseRecommendation", {}).n("CostExplorerClient", "GetReservationPurchaseRecommendationCommand").f(void 0, void 0).ser(se_GetReservationPurchaseRecommendationCommand).de(de_GetReservationPurchaseRecommendationCommand).build() {
+};
+__name(_GetReservationPurchaseRecommendationCommand, "GetReservationPurchaseRecommendationCommand");
+var GetReservationPurchaseRecommendationCommand = _GetReservationPurchaseRecommendationCommand;
+
+// src/commands/GetReservationUtilizationCommand.ts
+
+
+
+
+var _GetReservationUtilizationCommand = class _GetReservationUtilizationCommand 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("AWSInsightsIndexService", "GetReservationUtilization", {}).n("CostExplorerClient", "GetReservationUtilizationCommand").f(void 0, void 0).ser(se_GetReservationUtilizationCommand).de(de_GetReservationUtilizationCommand).build() {
+};
+__name(_GetReservationUtilizationCommand, "GetReservationUtilizationCommand");
+var GetReservationUtilizationCommand = _GetReservationUtilizationCommand;
+
+// src/commands/GetRightsizingRecommendationCommand.ts
+
+
+
+
+var _GetRightsizingRecommendationCommand = class _GetRightsizingRecommendationCommand 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("AWSInsightsIndexService", "GetRightsizingRecommendation", {}).n("CostExplorerClient", "GetRightsizingRecommendationCommand").f(void 0, void 0).ser(se_GetRightsizingRecommendationCommand).de(de_GetRightsizingRecommendationCommand).build() {
+};
+__name(_GetRightsizingRecommendationCommand, "GetRightsizingRecommendationCommand");
+var GetRightsizingRecommendationCommand = _GetRightsizingRecommendationCommand;
+
+// src/commands/GetSavingsPlanPurchaseRecommendationDetailsCommand.ts
+
+
+
+
+var _GetSavingsPlanPurchaseRecommendationDetailsCommand = class _GetSavingsPlanPurchaseRecommendationDetailsCommand 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("AWSInsightsIndexService", "GetSavingsPlanPurchaseRecommendationDetails", {}).n("CostExplorerClient", "GetSavingsPlanPurchaseRecommendationDetailsCommand").f(void 0, void 0).ser(se_GetSavingsPlanPurchaseRecommendationDetailsCommand).de(de_GetSavingsPlanPurchaseRecommendationDetailsCommand).build() {
+};
+__name(_GetSavingsPlanPurchaseRecommendationDetailsCommand, "GetSavingsPlanPurchaseRecommendationDetailsCommand");
+var GetSavingsPlanPurchaseRecommendationDetailsCommand = _GetSavingsPlanPurchaseRecommendationDetailsCommand;
+
+// src/commands/GetSavingsPlansCoverageCommand.ts
+
+
+
+
+var _GetSavingsPlansCoverageCommand = class _GetSavingsPlansCoverageCommand 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("AWSInsightsIndexService", "GetSavingsPlansCoverage", {}).n("CostExplorerClient", "GetSavingsPlansCoverageCommand").f(void 0, void 0).ser(se_GetSavingsPlansCoverageCommand).de(de_GetSavingsPlansCoverageCommand).build() {
+};
+__name(_GetSavingsPlansCoverageCommand, "GetSavingsPlansCoverageCommand");
+var GetSavingsPlansCoverageCommand = _GetSavingsPlansCoverageCommand;
+
+// src/commands/GetSavingsPlansPurchaseRecommendationCommand.ts
+
+
+
+
+var _GetSavingsPlansPurchaseRecommendationCommand = class _GetSavingsPlansPurchaseRecommendationCommand 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("AWSInsightsIndexService", "GetSavingsPlansPurchaseRecommendation", {}).n("CostExplorerClient", "GetSavingsPlansPurchaseRecommendationCommand").f(void 0, void 0).ser(se_GetSavingsPlansPurchaseRecommendationCommand).de(de_GetSavingsPlansPurchaseRecommendationCommand).build() {
+};
+__name(_GetSavingsPlansPurchaseRecommendationCommand, "GetSavingsPlansPurchaseRecommendationCommand");
+var GetSavingsPlansPurchaseRecommendationCommand = _GetSavingsPlansPurchaseRecommendationCommand;
+
+// src/commands/GetSavingsPlansUtilizationCommand.ts
+
+
+
+
+var _GetSavingsPlansUtilizationCommand = class _GetSavingsPlansUtilizationCommand 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("AWSInsightsIndexService", "GetSavingsPlansUtilization", {}).n("CostExplorerClient", "GetSavingsPlansUtilizationCommand").f(void 0, void 0).ser(se_GetSavingsPlansUtilizationCommand).de(de_GetSavingsPlansUtilizationCommand).build() {
+};
+__name(_GetSavingsPlansUtilizationCommand, "GetSavingsPlansUtilizationCommand");
+var GetSavingsPlansUtilizationCommand = _GetSavingsPlansUtilizationCommand;
+
+// src/commands/GetSavingsPlansUtilizationDetailsCommand.ts
+
+
+
+
+var _GetSavingsPlansUtilizationDetailsCommand = class _GetSavingsPlansUtilizationDetailsCommand 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("AWSInsightsIndexService", "GetSavingsPlansUtilizationDetails", {}).n("CostExplorerClient", "GetSavingsPlansUtilizationDetailsCommand").f(void 0, void 0).ser(se_GetSavingsPlansUtilizationDetailsCommand).de(de_GetSavingsPlansUtilizationDetailsCommand).build() {
+};
+__name(_GetSavingsPlansUtilizationDetailsCommand, "GetSavingsPlansUtilizationDetailsCommand");
+var GetSavingsPlansUtilizationDetailsCommand = _GetSavingsPlansUtilizationDetailsCommand;
+
+// src/commands/GetTagsCommand.ts
+
+
+
+
+var _GetTagsCommand = class _GetTagsCommand 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("AWSInsightsIndexService", "GetTags", {}).n("CostExplorerClient", "GetTagsCommand").f(void 0, void 0).ser(se_GetTagsCommand).de(de_GetTagsCommand).build() {
+};
+__name(_GetTagsCommand, "GetTagsCommand");
+var GetTagsCommand = _GetTagsCommand;
+
+// src/commands/GetUsageForecastCommand.ts
+
+
+
+
+var _GetUsageForecastCommand = class _GetUsageForecastCommand 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("AWSInsightsIndexService", "GetUsageForecast", {}).n("CostExplorerClient", "GetUsageForecastCommand").f(void 0, void 0).ser(se_GetUsageForecastCommand).de(de_GetUsageForecastCommand).build() {
+};
+__name(_GetUsageForecastCommand, "GetUsageForecastCommand");
+var GetUsageForecastCommand = _GetUsageForecastCommand;
+
+// src/commands/ListCostAllocationTagsCommand.ts
+
+
+
+
+var _ListCostAllocationTagsCommand = class _ListCostAllocationTagsCommand 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("AWSInsightsIndexService", "ListCostAllocationTags", {}).n("CostExplorerClient", "ListCostAllocationTagsCommand").f(void 0, void 0).ser(se_ListCostAllocationTagsCommand).de(de_ListCostAllocationTagsCommand).build() {
+};
+__name(_ListCostAllocationTagsCommand, "ListCostAllocationTagsCommand");
+var ListCostAllocationTagsCommand = _ListCostAllocationTagsCommand;
+
+// src/commands/ListCostCategoryDefinitionsCommand.ts
+
+
+
+
+var _ListCostCategoryDefinitionsCommand = class _ListCostCategoryDefinitionsCommand 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("AWSInsightsIndexService", "ListCostCategoryDefinitions", {}).n("CostExplorerClient", "ListCostCategoryDefinitionsCommand").f(void 0, void 0).ser(se_ListCostCategoryDefinitionsCommand).de(de_ListCostCategoryDefinitionsCommand).build() {
+};
+__name(_ListCostCategoryDefinitionsCommand, "ListCostCategoryDefinitionsCommand");
+var ListCostCategoryDefinitionsCommand = _ListCostCategoryDefinitionsCommand;
+
+// src/commands/ListSavingsPlansPurchaseRecommendationGenerationCommand.ts
+
+
+
+
+var _ListSavingsPlansPurchaseRecommendationGenerationCommand = class _ListSavingsPlansPurchaseRecommendationGenerationCommand 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("AWSInsightsIndexService", "ListSavingsPlansPurchaseRecommendationGeneration", {}).n("CostExplorerClient", "ListSavingsPlansPurchaseRecommendationGenerationCommand").f(void 0, void 0).ser(se_ListSavingsPlansPurchaseRecommendationGenerationCommand).de(de_ListSavingsPlansPurchaseRecommendationGenerationCommand).build() {
+};
+__name(_ListSavingsPlansPurchaseRecommendationGenerationCommand, "ListSavingsPlansPurchaseRecommendationGenerationCommand");
+var ListSavingsPlansPurchaseRecommendationGenerationCommand = _ListSavingsPlansPurchaseRecommendationGenerationCommand;
+
+// 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("AWSInsightsIndexService", "ListTagsForResource", {}).n("CostExplorerClient", "ListTagsForResourceCommand").f(void 0, void 0).ser(se_ListTagsForResourceCommand).de(de_ListTagsForResourceCommand).build() {
+};
+__name(_ListTagsForResourceCommand, "ListTagsForResourceCommand");
+var ListTagsForResourceCommand = _ListTagsForResourceCommand;
+
+// src/commands/ProvideAnomalyFeedbackCommand.ts
+
+
+
+
+var _ProvideAnomalyFeedbackCommand = class _ProvideAnomalyFeedbackCommand 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("AWSInsightsIndexService", "ProvideAnomalyFeedback", {}).n("CostExplorerClient", "ProvideAnomalyFeedbackCommand").f(void 0, void 0).ser(se_ProvideAnomalyFeedbackCommand).de(de_ProvideAnomalyFeedbackCommand).build() {
+};
+__name(_ProvideAnomalyFeedbackCommand, "ProvideAnomalyFeedbackCommand");
+var ProvideAnomalyFeedbackCommand = _ProvideAnomalyFeedbackCommand;
+
+// src/commands/StartSavingsPlansPurchaseRecommendationGenerationCommand.ts
+
+
+
+
+var _StartSavingsPlansPurchaseRecommendationGenerationCommand = class _StartSavingsPlansPurchaseRecommendationGenerationCommand 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("AWSInsightsIndexService", "StartSavingsPlansPurchaseRecommendationGeneration", {}).n("CostExplorerClient", "StartSavingsPlansPurchaseRecommendationGenerationCommand").f(void 0, void 0).ser(se_StartSavingsPlansPurchaseRecommendationGenerationCommand).de(de_StartSavingsPlansPurchaseRecommendationGenerationCommand).build() {
+};
+__name(_StartSavingsPlansPurchaseRecommendationGenerationCommand, "StartSavingsPlansPurchaseRecommendationGenerationCommand");
+var StartSavingsPlansPurchaseRecommendationGenerationCommand = _StartSavingsPlansPurchaseRecommendationGenerationCommand;
+
+// 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("AWSInsightsIndexService", "TagResource", {}).n("CostExplorerClient", "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("AWSInsightsIndexService", "UntagResource", {}).n("CostExplorerClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
+};
+__name(_UntagResourceCommand, "UntagResourceCommand");
+var UntagResourceCommand = _UntagResourceCommand;
+
+// src/commands/UpdateAnomalyMonitorCommand.ts
+
+
+
+
+var _UpdateAnomalyMonitorCommand = class _UpdateAnomalyMonitorCommand 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("AWSInsightsIndexService", "UpdateAnomalyMonitor", {}).n("CostExplorerClient", "UpdateAnomalyMonitorCommand").f(void 0, void 0).ser(se_UpdateAnomalyMonitorCommand).de(de_UpdateAnomalyMonitorCommand).build() {
+};
+__name(_UpdateAnomalyMonitorCommand, "UpdateAnomalyMonitorCommand");
+var UpdateAnomalyMonitorCommand = _UpdateAnomalyMonitorCommand;
+
+// src/commands/UpdateAnomalySubscriptionCommand.ts
+
+
+
+
+var _UpdateAnomalySubscriptionCommand = class _UpdateAnomalySubscriptionCommand 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("AWSInsightsIndexService", "UpdateAnomalySubscription", {}).n("CostExplorerClient", "UpdateAnomalySubscriptionCommand").f(void 0, void 0).ser(se_UpdateAnomalySubscriptionCommand).de(de_UpdateAnomalySubscriptionCommand).build() {
+};
+__name(_UpdateAnomalySubscriptionCommand, "UpdateAnomalySubscriptionCommand");
+var UpdateAnomalySubscriptionCommand = _UpdateAnomalySubscriptionCommand;
+
+// src/commands/UpdateCostAllocationTagsStatusCommand.ts
+
+
+
+
+var _UpdateCostAllocationTagsStatusCommand = class _UpdateCostAllocationTagsStatusCommand 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("AWSInsightsIndexService", "UpdateCostAllocationTagsStatus", {}).n("CostExplorerClient", "UpdateCostAllocationTagsStatusCommand").f(void 0, void 0).ser(se_UpdateCostAllocationTagsStatusCommand).de(de_UpdateCostAllocationTagsStatusCommand).build() {
+};
+__name(_UpdateCostAllocationTagsStatusCommand, "UpdateCostAllocationTagsStatusCommand");
+var UpdateCostAllocationTagsStatusCommand = _UpdateCostAllocationTagsStatusCommand;
+
+// src/commands/UpdateCostCategoryDefinitionCommand.ts
+
+
+
+
+var _UpdateCostCategoryDefinitionCommand = class _UpdateCostCategoryDefinitionCommand 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("AWSInsightsIndexService", "UpdateCostCategoryDefinition", {}).n("CostExplorerClient", "UpdateCostCategoryDefinitionCommand").f(void 0, void 0).ser(se_UpdateCostCategoryDefinitionCommand).de(de_UpdateCostCategoryDefinitionCommand).build() {
+};
+__name(_UpdateCostCategoryDefinitionCommand, "UpdateCostCategoryDefinitionCommand");
+var UpdateCostCategoryDefinitionCommand = _UpdateCostCategoryDefinitionCommand;
+
+// src/CostExplorer.ts
+var commands = {
+  CreateAnomalyMonitorCommand,
+  CreateAnomalySubscriptionCommand,
+  CreateCostCategoryDefinitionCommand,
+  DeleteAnomalyMonitorCommand,
+  DeleteAnomalySubscriptionCommand,
+  DeleteCostCategoryDefinitionCommand,
+  DescribeCostCategoryDefinitionCommand,
+  GetAnomaliesCommand,
+  GetAnomalyMonitorsCommand,
+  GetAnomalySubscriptionsCommand,
+  GetCostAndUsageCommand,
+  GetCostAndUsageWithResourcesCommand,
+  GetCostCategoriesCommand,
+  GetCostForecastCommand,
+  GetDimensionValuesCommand,
+  GetReservationCoverageCommand,
+  GetReservationPurchaseRecommendationCommand,
+  GetReservationUtilizationCommand,
+  GetRightsizingRecommendationCommand,
+  GetSavingsPlanPurchaseRecommendationDetailsCommand,
+  GetSavingsPlansCoverageCommand,
+  GetSavingsPlansPurchaseRecommendationCommand,
+  GetSavingsPlansUtilizationCommand,
+  GetSavingsPlansUtilizationDetailsCommand,
+  GetTagsCommand,
+  GetUsageForecastCommand,
+  ListCostAllocationTagsCommand,
+  ListCostCategoryDefinitionsCommand,
+  ListSavingsPlansPurchaseRecommendationGenerationCommand,
+  ListTagsForResourceCommand,
+  ProvideAnomalyFeedbackCommand,
+  StartSavingsPlansPurchaseRecommendationGenerationCommand,
+  TagResourceCommand,
+  UntagResourceCommand,
+  UpdateAnomalyMonitorCommand,
+  UpdateAnomalySubscriptionCommand,
+  UpdateCostAllocationTagsStatusCommand,
+  UpdateCostCategoryDefinitionCommand
+};
+var _CostExplorer = class _CostExplorer extends CostExplorerClient {
+};
+__name(_CostExplorer, "CostExplorer");
+var CostExplorer = _CostExplorer;
+(0, import_smithy_client.createAggregatedClient)(commands, CostExplorer);
+
+// src/pagination/GetSavingsPlansCoveragePaginator.ts
+var import_core = require("@smithy/core");
+var paginateGetSavingsPlansCoverage = (0, import_core.createPaginator)(CostExplorerClient, GetSavingsPlansCoverageCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/GetSavingsPlansUtilizationDetailsPaginator.ts
+
+var paginateGetSavingsPlansUtilizationDetails = (0, import_core.createPaginator)(CostExplorerClient, GetSavingsPlansUtilizationDetailsCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListCostAllocationTagsPaginator.ts
+
+var paginateListCostAllocationTags = (0, import_core.createPaginator)(CostExplorerClient, ListCostAllocationTagsCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListCostCategoryDefinitionsPaginator.ts
+
+var paginateListCostCategoryDefinitions = (0, import_core.createPaginator)(CostExplorerClient, ListCostCategoryDefinitionsCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/index.ts
+var import_util_endpoints = require("@aws-sdk/util-endpoints");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AccountScope,
+  AnomalyFeedbackType,
+  AnomalySubscriptionFrequency,
+  BillExpirationException,
+  Context,
+  CostAllocationTagStatus,
+  CostAllocationTagType,
+  CostCategoryInheritedValueDimensionName,
+  CostCategoryRuleType,
+  CostCategoryRuleVersion,
+  CostCategorySplitChargeMethod,
+  CostCategorySplitChargeRuleParameterType,
+  CostCategoryStatus,
+  CostCategoryStatusComponent,
+  CostExplorer,
+  CostExplorerClient,
+  CostExplorerServiceException,
+  CreateAnomalyMonitorCommand,
+  CreateAnomalySubscriptionCommand,
+  CreateCostCategoryDefinitionCommand,
+  DataUnavailableException,
+  DeleteAnomalyMonitorCommand,
+  DeleteAnomalySubscriptionCommand,
+  DeleteCostCategoryDefinitionCommand,
+  DescribeCostCategoryDefinitionCommand,
+  Dimension,
+  FindingReasonCode,
+  GenerationExistsException,
+  GenerationStatus,
+  GetAnomaliesCommand,
+  GetAnomalyMonitorsCommand,
+  GetAnomalySubscriptionsCommand,
+  GetCostAndUsageCommand,
+  GetCostAndUsageWithResourcesCommand,
+  GetCostCategoriesCommand,
+  GetCostForecastCommand,
+  GetDimensionValuesCommand,
+  GetReservationCoverageCommand,
+  GetReservationPurchaseRecommendationCommand,
+  GetReservationUtilizationCommand,
+  GetRightsizingRecommendationCommand,
+  GetSavingsPlanPurchaseRecommendationDetailsCommand,
+  GetSavingsPlansCoverageCommand,
+  GetSavingsPlansPurchaseRecommendationCommand,
+  GetSavingsPlansUtilizationCommand,
+  GetSavingsPlansUtilizationDetailsCommand,
+  GetTagsCommand,
+  GetUsageForecastCommand,
+  Granularity,
+  GroupDefinitionType,
+  InvalidNextTokenException,
+  LimitExceededException,
+  ListCostAllocationTagsCommand,
+  ListCostCategoryDefinitionsCommand,
+  ListSavingsPlansPurchaseRecommendationGenerationCommand,
+  ListTagsForResourceCommand,
+  LookbackPeriodInDays,
+  MatchOption,
+  Metric,
+  MonitorDimension,
+  MonitorType,
+  NumericOperator,
+  OfferingClass,
+  PaymentOption,
+  PlatformDifference,
+  ProvideAnomalyFeedbackCommand,
+  RecommendationTarget,
+  RequestChangedException,
+  ResourceNotFoundException,
+  RightsizingType,
+  SavingsPlansDataType,
+  ServiceQuotaExceededException,
+  SortOrder,
+  StartSavingsPlansPurchaseRecommendationGenerationCommand,
+  SubscriberStatus,
+  SubscriberType,
+  SupportedSavingsPlansType,
+  TagResourceCommand,
+  TermInYears,
+  TooManyTagsException,
+  UnknownMonitorException,
+  UnknownSubscriptionException,
+  UnresolvableUsageUnitException,
+  UntagResourceCommand,
+  UpdateAnomalyMonitorCommand,
+  UpdateAnomalySubscriptionCommand,
+  UpdateCostAllocationTagsStatusCommand,
+  UpdateCostCategoryDefinitionCommand,
+  __Client,
+  paginateGetSavingsPlansCoverage,
+  paginateGetSavingsPlansUtilizationDetails,
+  paginateListCostAllocationTags,
+  paginateListCostCategoryDefinitions
+});