@aws-sdk/client-config-service 3.181.0 → 3.183.0

package/dist-es/ConfigService.js

@@ -1,4 +1,3 @@
-import { __extends } from "tslib";
 import { BatchGetAggregateResourceConfigCommand, } from "./commands/BatchGetAggregateResourceConfigCommand";
 import { BatchGetResourceConfigCommand, } from "./commands/BatchGetResourceConfigCommand";
 import { DeleteAggregationAuthorizationCommand, } from "./commands/DeleteAggregationAuthorizationCommand";
@@ -89,1257 +88,1251 @@ import { StopConfigurationRecorderCommand, } from "./commands/StopConfigurationR
 import { TagResourceCommand } from "./commands/TagResourceCommand";
 import { UntagResourceCommand, } from "./commands/UntagResourceCommand";
 import { ConfigServiceClient } from "./ConfigServiceClient";
-var ConfigService = (function (_super) {
-    __extends(ConfigService, _super);
-    function ConfigService() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    ConfigService.prototype.batchGetAggregateResourceConfig = function (args, optionsOrCb, cb) {
-        var command = new BatchGetAggregateResourceConfigCommand(args);
+export class ConfigService extends ConfigServiceClient {
+    batchGetAggregateResourceConfig(args, optionsOrCb, cb) {
+        const command = new BatchGetAggregateResourceConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.batchGetResourceConfig = function (args, optionsOrCb, cb) {
-        var command = new BatchGetResourceConfigCommand(args);
+    }
+    batchGetResourceConfig(args, optionsOrCb, cb) {
+        const command = new BatchGetResourceConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.deleteAggregationAuthorization = function (args, optionsOrCb, cb) {
-        var command = new DeleteAggregationAuthorizationCommand(args);
+    }
+    deleteAggregationAuthorization(args, optionsOrCb, cb) {
+        const command = new DeleteAggregationAuthorizationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.deleteConfigRule = function (args, optionsOrCb, cb) {
-        var command = new DeleteConfigRuleCommand(args);
+    }
+    deleteConfigRule(args, optionsOrCb, cb) {
+        const command = new DeleteConfigRuleCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.deleteConfigurationAggregator = function (args, optionsOrCb, cb) {
-        var command = new DeleteConfigurationAggregatorCommand(args);
+    }
+    deleteConfigurationAggregator(args, optionsOrCb, cb) {
+        const command = new DeleteConfigurationAggregatorCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.deleteConfigurationRecorder = function (args, optionsOrCb, cb) {
-        var command = new DeleteConfigurationRecorderCommand(args);
+    }
+    deleteConfigurationRecorder(args, optionsOrCb, cb) {
+        const command = new DeleteConfigurationRecorderCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.deleteConformancePack = function (args, optionsOrCb, cb) {
-        var command = new DeleteConformancePackCommand(args);
+    }
+    deleteConformancePack(args, optionsOrCb, cb) {
+        const command = new DeleteConformancePackCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.deleteDeliveryChannel = function (args, optionsOrCb, cb) {
-        var command = new DeleteDeliveryChannelCommand(args);
+    }
+    deleteDeliveryChannel(args, optionsOrCb, cb) {
+        const command = new DeleteDeliveryChannelCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.deleteEvaluationResults = function (args, optionsOrCb, cb) {
-        var command = new DeleteEvaluationResultsCommand(args);
+    }
+    deleteEvaluationResults(args, optionsOrCb, cb) {
+        const command = new DeleteEvaluationResultsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.deleteOrganizationConfigRule = function (args, optionsOrCb, cb) {
-        var command = new DeleteOrganizationConfigRuleCommand(args);
+    }
+    deleteOrganizationConfigRule(args, optionsOrCb, cb) {
+        const command = new DeleteOrganizationConfigRuleCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.deleteOrganizationConformancePack = function (args, optionsOrCb, cb) {
-        var command = new DeleteOrganizationConformancePackCommand(args);
+    }
+    deleteOrganizationConformancePack(args, optionsOrCb, cb) {
+        const command = new DeleteOrganizationConformancePackCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.deletePendingAggregationRequest = function (args, optionsOrCb, cb) {
-        var command = new DeletePendingAggregationRequestCommand(args);
+    }
+    deletePendingAggregationRequest(args, optionsOrCb, cb) {
+        const command = new DeletePendingAggregationRequestCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.deleteRemediationConfiguration = function (args, optionsOrCb, cb) {
-        var command = new DeleteRemediationConfigurationCommand(args);
+    }
+    deleteRemediationConfiguration(args, optionsOrCb, cb) {
+        const command = new DeleteRemediationConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.deleteRemediationExceptions = function (args, optionsOrCb, cb) {
-        var command = new DeleteRemediationExceptionsCommand(args);
+    }
+    deleteRemediationExceptions(args, optionsOrCb, cb) {
+        const command = new DeleteRemediationExceptionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.deleteResourceConfig = function (args, optionsOrCb, cb) {
-        var command = new DeleteResourceConfigCommand(args);
+    }
+    deleteResourceConfig(args, optionsOrCb, cb) {
+        const command = new DeleteResourceConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.deleteRetentionConfiguration = function (args, optionsOrCb, cb) {
-        var command = new DeleteRetentionConfigurationCommand(args);
+    }
+    deleteRetentionConfiguration(args, optionsOrCb, cb) {
+        const command = new DeleteRetentionConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.deleteStoredQuery = function (args, optionsOrCb, cb) {
-        var command = new DeleteStoredQueryCommand(args);
+    }
+    deleteStoredQuery(args, optionsOrCb, cb) {
+        const command = new DeleteStoredQueryCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.deliverConfigSnapshot = function (args, optionsOrCb, cb) {
-        var command = new DeliverConfigSnapshotCommand(args);
+    }
+    deliverConfigSnapshot(args, optionsOrCb, cb) {
+        const command = new DeliverConfigSnapshotCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.describeAggregateComplianceByConfigRules = function (args, optionsOrCb, cb) {
-        var command = new DescribeAggregateComplianceByConfigRulesCommand(args);
+    }
+    describeAggregateComplianceByConfigRules(args, optionsOrCb, cb) {
+        const command = new DescribeAggregateComplianceByConfigRulesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.describeAggregateComplianceByConformancePacks = function (args, optionsOrCb, cb) {
-        var command = new DescribeAggregateComplianceByConformancePacksCommand(args);
+    }
+    describeAggregateComplianceByConformancePacks(args, optionsOrCb, cb) {
+        const command = new DescribeAggregateComplianceByConformancePacksCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.describeAggregationAuthorizations = function (args, optionsOrCb, cb) {
-        var command = new DescribeAggregationAuthorizationsCommand(args);
+    }
+    describeAggregationAuthorizations(args, optionsOrCb, cb) {
+        const command = new DescribeAggregationAuthorizationsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.describeComplianceByConfigRule = function (args, optionsOrCb, cb) {
-        var command = new DescribeComplianceByConfigRuleCommand(args);
+    }
+    describeComplianceByConfigRule(args, optionsOrCb, cb) {
+        const command = new DescribeComplianceByConfigRuleCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.describeComplianceByResource = function (args, optionsOrCb, cb) {
-        var command = new DescribeComplianceByResourceCommand(args);
+    }
+    describeComplianceByResource(args, optionsOrCb, cb) {
+        const command = new DescribeComplianceByResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.describeConfigRuleEvaluationStatus = function (args, optionsOrCb, cb) {
-        var command = new DescribeConfigRuleEvaluationStatusCommand(args);
+    }
+    describeConfigRuleEvaluationStatus(args, optionsOrCb, cb) {
+        const command = new DescribeConfigRuleEvaluationStatusCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.describeConfigRules = function (args, optionsOrCb, cb) {
-        var command = new DescribeConfigRulesCommand(args);
+    }
+    describeConfigRules(args, optionsOrCb, cb) {
+        const command = new DescribeConfigRulesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.describeConfigurationAggregators = function (args, optionsOrCb, cb) {
-        var command = new DescribeConfigurationAggregatorsCommand(args);
+    }
+    describeConfigurationAggregators(args, optionsOrCb, cb) {
+        const command = new DescribeConfigurationAggregatorsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.describeConfigurationAggregatorSourcesStatus = function (args, optionsOrCb, cb) {
-        var command = new DescribeConfigurationAggregatorSourcesStatusCommand(args);
+    }
+    describeConfigurationAggregatorSourcesStatus(args, optionsOrCb, cb) {
+        const command = new DescribeConfigurationAggregatorSourcesStatusCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.describeConfigurationRecorders = function (args, optionsOrCb, cb) {
-        var command = new DescribeConfigurationRecordersCommand(args);
+    }
+    describeConfigurationRecorders(args, optionsOrCb, cb) {
+        const command = new DescribeConfigurationRecordersCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.describeConfigurationRecorderStatus = function (args, optionsOrCb, cb) {
-        var command = new DescribeConfigurationRecorderStatusCommand(args);
+    }
+    describeConfigurationRecorderStatus(args, optionsOrCb, cb) {
+        const command = new DescribeConfigurationRecorderStatusCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.describeConformancePackCompliance = function (args, optionsOrCb, cb) {
-        var command = new DescribeConformancePackComplianceCommand(args);
+    }
+    describeConformancePackCompliance(args, optionsOrCb, cb) {
+        const command = new DescribeConformancePackComplianceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.describeConformancePacks = function (args, optionsOrCb, cb) {
-        var command = new DescribeConformancePacksCommand(args);
+    }
+    describeConformancePacks(args, optionsOrCb, cb) {
+        const command = new DescribeConformancePacksCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.describeConformancePackStatus = function (args, optionsOrCb, cb) {
-        var command = new DescribeConformancePackStatusCommand(args);
+    }
+    describeConformancePackStatus(args, optionsOrCb, cb) {
+        const command = new DescribeConformancePackStatusCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.describeDeliveryChannels = function (args, optionsOrCb, cb) {
-        var command = new DescribeDeliveryChannelsCommand(args);
+    }
+    describeDeliveryChannels(args, optionsOrCb, cb) {
+        const command = new DescribeDeliveryChannelsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.describeDeliveryChannelStatus = function (args, optionsOrCb, cb) {
-        var command = new DescribeDeliveryChannelStatusCommand(args);
+    }
+    describeDeliveryChannelStatus(args, optionsOrCb, cb) {
+        const command = new DescribeDeliveryChannelStatusCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.describeOrganizationConfigRules = function (args, optionsOrCb, cb) {
-        var command = new DescribeOrganizationConfigRulesCommand(args);
+    }
+    describeOrganizationConfigRules(args, optionsOrCb, cb) {
+        const command = new DescribeOrganizationConfigRulesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.describeOrganizationConfigRuleStatuses = function (args, optionsOrCb, cb) {
-        var command = new DescribeOrganizationConfigRuleStatusesCommand(args);
+    }
+    describeOrganizationConfigRuleStatuses(args, optionsOrCb, cb) {
+        const command = new DescribeOrganizationConfigRuleStatusesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.describeOrganizationConformancePacks = function (args, optionsOrCb, cb) {
-        var command = new DescribeOrganizationConformancePacksCommand(args);
+    }
+    describeOrganizationConformancePacks(args, optionsOrCb, cb) {
+        const command = new DescribeOrganizationConformancePacksCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.describeOrganizationConformancePackStatuses = function (args, optionsOrCb, cb) {
-        var command = new DescribeOrganizationConformancePackStatusesCommand(args);
+    }
+    describeOrganizationConformancePackStatuses(args, optionsOrCb, cb) {
+        const command = new DescribeOrganizationConformancePackStatusesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.describePendingAggregationRequests = function (args, optionsOrCb, cb) {
-        var command = new DescribePendingAggregationRequestsCommand(args);
+    }
+    describePendingAggregationRequests(args, optionsOrCb, cb) {
+        const command = new DescribePendingAggregationRequestsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.describeRemediationConfigurations = function (args, optionsOrCb, cb) {
-        var command = new DescribeRemediationConfigurationsCommand(args);
+    }
+    describeRemediationConfigurations(args, optionsOrCb, cb) {
+        const command = new DescribeRemediationConfigurationsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.describeRemediationExceptions = function (args, optionsOrCb, cb) {
-        var command = new DescribeRemediationExceptionsCommand(args);
+    }
+    describeRemediationExceptions(args, optionsOrCb, cb) {
+        const command = new DescribeRemediationExceptionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.describeRemediationExecutionStatus = function (args, optionsOrCb, cb) {
-        var command = new DescribeRemediationExecutionStatusCommand(args);
+    }
+    describeRemediationExecutionStatus(args, optionsOrCb, cb) {
+        const command = new DescribeRemediationExecutionStatusCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.describeRetentionConfigurations = function (args, optionsOrCb, cb) {
-        var command = new DescribeRetentionConfigurationsCommand(args);
+    }
+    describeRetentionConfigurations(args, optionsOrCb, cb) {
+        const command = new DescribeRetentionConfigurationsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.getAggregateComplianceDetailsByConfigRule = function (args, optionsOrCb, cb) {
-        var command = new GetAggregateComplianceDetailsByConfigRuleCommand(args);
+    }
+    getAggregateComplianceDetailsByConfigRule(args, optionsOrCb, cb) {
+        const command = new GetAggregateComplianceDetailsByConfigRuleCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.getAggregateConfigRuleComplianceSummary = function (args, optionsOrCb, cb) {
-        var command = new GetAggregateConfigRuleComplianceSummaryCommand(args);
+    }
+    getAggregateConfigRuleComplianceSummary(args, optionsOrCb, cb) {
+        const command = new GetAggregateConfigRuleComplianceSummaryCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.getAggregateConformancePackComplianceSummary = function (args, optionsOrCb, cb) {
-        var command = new GetAggregateConformancePackComplianceSummaryCommand(args);
+    }
+    getAggregateConformancePackComplianceSummary(args, optionsOrCb, cb) {
+        const command = new GetAggregateConformancePackComplianceSummaryCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.getAggregateDiscoveredResourceCounts = function (args, optionsOrCb, cb) {
-        var command = new GetAggregateDiscoveredResourceCountsCommand(args);
+    }
+    getAggregateDiscoveredResourceCounts(args, optionsOrCb, cb) {
+        const command = new GetAggregateDiscoveredResourceCountsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.getAggregateResourceConfig = function (args, optionsOrCb, cb) {
-        var command = new GetAggregateResourceConfigCommand(args);
+    }
+    getAggregateResourceConfig(args, optionsOrCb, cb) {
+        const command = new GetAggregateResourceConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.getComplianceDetailsByConfigRule = function (args, optionsOrCb, cb) {
-        var command = new GetComplianceDetailsByConfigRuleCommand(args);
+    }
+    getComplianceDetailsByConfigRule(args, optionsOrCb, cb) {
+        const command = new GetComplianceDetailsByConfigRuleCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.getComplianceDetailsByResource = function (args, optionsOrCb, cb) {
-        var command = new GetComplianceDetailsByResourceCommand(args);
+    }
+    getComplianceDetailsByResource(args, optionsOrCb, cb) {
+        const command = new GetComplianceDetailsByResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.getComplianceSummaryByConfigRule = function (args, optionsOrCb, cb) {
-        var command = new GetComplianceSummaryByConfigRuleCommand(args);
+    }
+    getComplianceSummaryByConfigRule(args, optionsOrCb, cb) {
+        const command = new GetComplianceSummaryByConfigRuleCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.getComplianceSummaryByResourceType = function (args, optionsOrCb, cb) {
-        var command = new GetComplianceSummaryByResourceTypeCommand(args);
+    }
+    getComplianceSummaryByResourceType(args, optionsOrCb, cb) {
+        const command = new GetComplianceSummaryByResourceTypeCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.getConformancePackComplianceDetails = function (args, optionsOrCb, cb) {
-        var command = new GetConformancePackComplianceDetailsCommand(args);
+    }
+    getConformancePackComplianceDetails(args, optionsOrCb, cb) {
+        const command = new GetConformancePackComplianceDetailsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.getConformancePackComplianceSummary = function (args, optionsOrCb, cb) {
-        var command = new GetConformancePackComplianceSummaryCommand(args);
+    }
+    getConformancePackComplianceSummary(args, optionsOrCb, cb) {
+        const command = new GetConformancePackComplianceSummaryCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.getCustomRulePolicy = function (args, optionsOrCb, cb) {
-        var command = new GetCustomRulePolicyCommand(args);
+    }
+    getCustomRulePolicy(args, optionsOrCb, cb) {
+        const command = new GetCustomRulePolicyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.getDiscoveredResourceCounts = function (args, optionsOrCb, cb) {
-        var command = new GetDiscoveredResourceCountsCommand(args);
+    }
+    getDiscoveredResourceCounts(args, optionsOrCb, cb) {
+        const command = new GetDiscoveredResourceCountsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.getOrganizationConfigRuleDetailedStatus = function (args, optionsOrCb, cb) {
-        var command = new GetOrganizationConfigRuleDetailedStatusCommand(args);
+    }
+    getOrganizationConfigRuleDetailedStatus(args, optionsOrCb, cb) {
+        const command = new GetOrganizationConfigRuleDetailedStatusCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.getOrganizationConformancePackDetailedStatus = function (args, optionsOrCb, cb) {
-        var command = new GetOrganizationConformancePackDetailedStatusCommand(args);
+    }
+    getOrganizationConformancePackDetailedStatus(args, optionsOrCb, cb) {
+        const command = new GetOrganizationConformancePackDetailedStatusCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.getOrganizationCustomRulePolicy = function (args, optionsOrCb, cb) {
-        var command = new GetOrganizationCustomRulePolicyCommand(args);
+    }
+    getOrganizationCustomRulePolicy(args, optionsOrCb, cb) {
+        const command = new GetOrganizationCustomRulePolicyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.getResourceConfigHistory = function (args, optionsOrCb, cb) {
-        var command = new GetResourceConfigHistoryCommand(args);
+    }
+    getResourceConfigHistory(args, optionsOrCb, cb) {
+        const command = new GetResourceConfigHistoryCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.getStoredQuery = function (args, optionsOrCb, cb) {
-        var command = new GetStoredQueryCommand(args);
+    }
+    getStoredQuery(args, optionsOrCb, cb) {
+        const command = new GetStoredQueryCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.listAggregateDiscoveredResources = function (args, optionsOrCb, cb) {
-        var command = new ListAggregateDiscoveredResourcesCommand(args);
+    }
+    listAggregateDiscoveredResources(args, optionsOrCb, cb) {
+        const command = new ListAggregateDiscoveredResourcesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.listConformancePackComplianceScores = function (args, optionsOrCb, cb) {
-        var command = new ListConformancePackComplianceScoresCommand(args);
+    }
+    listConformancePackComplianceScores(args, optionsOrCb, cb) {
+        const command = new ListConformancePackComplianceScoresCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.listDiscoveredResources = function (args, optionsOrCb, cb) {
-        var command = new ListDiscoveredResourcesCommand(args);
+    }
+    listDiscoveredResources(args, optionsOrCb, cb) {
+        const command = new ListDiscoveredResourcesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.listStoredQueries = function (args, optionsOrCb, cb) {
-        var command = new ListStoredQueriesCommand(args);
+    }
+    listStoredQueries(args, optionsOrCb, cb) {
+        const command = new ListStoredQueriesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.listTagsForResource = function (args, optionsOrCb, cb) {
-        var command = new ListTagsForResourceCommand(args);
+    }
+    listTagsForResource(args, optionsOrCb, cb) {
+        const command = new ListTagsForResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.putAggregationAuthorization = function (args, optionsOrCb, cb) {
-        var command = new PutAggregationAuthorizationCommand(args);
+    }
+    putAggregationAuthorization(args, optionsOrCb, cb) {
+        const command = new PutAggregationAuthorizationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.putConfigRule = function (args, optionsOrCb, cb) {
-        var command = new PutConfigRuleCommand(args);
+    }
+    putConfigRule(args, optionsOrCb, cb) {
+        const command = new PutConfigRuleCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.putConfigurationAggregator = function (args, optionsOrCb, cb) {
-        var command = new PutConfigurationAggregatorCommand(args);
+    }
+    putConfigurationAggregator(args, optionsOrCb, cb) {
+        const command = new PutConfigurationAggregatorCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.putConfigurationRecorder = function (args, optionsOrCb, cb) {
-        var command = new PutConfigurationRecorderCommand(args);
+    }
+    putConfigurationRecorder(args, optionsOrCb, cb) {
+        const command = new PutConfigurationRecorderCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.putConformancePack = function (args, optionsOrCb, cb) {
-        var command = new PutConformancePackCommand(args);
+    }
+    putConformancePack(args, optionsOrCb, cb) {
+        const command = new PutConformancePackCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.putDeliveryChannel = function (args, optionsOrCb, cb) {
-        var command = new PutDeliveryChannelCommand(args);
+    }
+    putDeliveryChannel(args, optionsOrCb, cb) {
+        const command = new PutDeliveryChannelCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.putEvaluations = function (args, optionsOrCb, cb) {
-        var command = new PutEvaluationsCommand(args);
+    }
+    putEvaluations(args, optionsOrCb, cb) {
+        const command = new PutEvaluationsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.putExternalEvaluation = function (args, optionsOrCb, cb) {
-        var command = new PutExternalEvaluationCommand(args);
+    }
+    putExternalEvaluation(args, optionsOrCb, cb) {
+        const command = new PutExternalEvaluationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.putOrganizationConfigRule = function (args, optionsOrCb, cb) {
-        var command = new PutOrganizationConfigRuleCommand(args);
+    }
+    putOrganizationConfigRule(args, optionsOrCb, cb) {
+        const command = new PutOrganizationConfigRuleCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.putOrganizationConformancePack = function (args, optionsOrCb, cb) {
-        var command = new PutOrganizationConformancePackCommand(args);
+    }
+    putOrganizationConformancePack(args, optionsOrCb, cb) {
+        const command = new PutOrganizationConformancePackCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.putRemediationConfigurations = function (args, optionsOrCb, cb) {
-        var command = new PutRemediationConfigurationsCommand(args);
+    }
+    putRemediationConfigurations(args, optionsOrCb, cb) {
+        const command = new PutRemediationConfigurationsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.putRemediationExceptions = function (args, optionsOrCb, cb) {
-        var command = new PutRemediationExceptionsCommand(args);
+    }
+    putRemediationExceptions(args, optionsOrCb, cb) {
+        const command = new PutRemediationExceptionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.putResourceConfig = function (args, optionsOrCb, cb) {
-        var command = new PutResourceConfigCommand(args);
+    }
+    putResourceConfig(args, optionsOrCb, cb) {
+        const command = new PutResourceConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.putRetentionConfiguration = function (args, optionsOrCb, cb) {
-        var command = new PutRetentionConfigurationCommand(args);
+    }
+    putRetentionConfiguration(args, optionsOrCb, cb) {
+        const command = new PutRetentionConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.putStoredQuery = function (args, optionsOrCb, cb) {
-        var command = new PutStoredQueryCommand(args);
+    }
+    putStoredQuery(args, optionsOrCb, cb) {
+        const command = new PutStoredQueryCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.selectAggregateResourceConfig = function (args, optionsOrCb, cb) {
-        var command = new SelectAggregateResourceConfigCommand(args);
+    }
+    selectAggregateResourceConfig(args, optionsOrCb, cb) {
+        const command = new SelectAggregateResourceConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.selectResourceConfig = function (args, optionsOrCb, cb) {
-        var command = new SelectResourceConfigCommand(args);
+    }
+    selectResourceConfig(args, optionsOrCb, cb) {
+        const command = new SelectResourceConfigCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.startConfigRulesEvaluation = function (args, optionsOrCb, cb) {
-        var command = new StartConfigRulesEvaluationCommand(args);
+    }
+    startConfigRulesEvaluation(args, optionsOrCb, cb) {
+        const command = new StartConfigRulesEvaluationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.startConfigurationRecorder = function (args, optionsOrCb, cb) {
-        var command = new StartConfigurationRecorderCommand(args);
+    }
+    startConfigurationRecorder(args, optionsOrCb, cb) {
+        const command = new StartConfigurationRecorderCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.startRemediationExecution = function (args, optionsOrCb, cb) {
-        var command = new StartRemediationExecutionCommand(args);
+    }
+    startRemediationExecution(args, optionsOrCb, cb) {
+        const command = new StartRemediationExecutionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.stopConfigurationRecorder = function (args, optionsOrCb, cb) {
-        var command = new StopConfigurationRecorderCommand(args);
+    }
+    stopConfigurationRecorder(args, optionsOrCb, cb) {
+        const command = new StopConfigurationRecorderCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.tagResource = function (args, optionsOrCb, cb) {
-        var command = new TagResourceCommand(args);
+    }
+    tagResource(args, optionsOrCb, cb) {
+        const command = new TagResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    ConfigService.prototype.untagResource = function (args, optionsOrCb, cb) {
-        var command = new UntagResourceCommand(args);
+    }
+    untagResource(args, optionsOrCb, cb) {
+        const command = new UntagResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    return ConfigService;
-}(ConfigServiceClient));
-export { ConfigService };
+    }
+}