@aws-sdk/client-frauddetector 3.185.0 → 3.188.0

package/dist-es/FraudDetector.js

@@ -1,4 +1,3 @@
-import { __extends } from "tslib";
 import { BatchCreateVariableCommand, } from "./commands/BatchCreateVariableCommand";
 import { BatchGetVariableCommand, } from "./commands/BatchGetVariableCommand";
 import { CancelBatchImportJobCommand, } from "./commands/CancelBatchImportJobCommand";
@@ -68,963 +67,957 @@ import { UpdateRuleMetadataCommand, } from "./commands/UpdateRuleMetadataCommand
 import { UpdateRuleVersionCommand, } from "./commands/UpdateRuleVersionCommand";
 import { UpdateVariableCommand, } from "./commands/UpdateVariableCommand";
 import { FraudDetectorClient } from "./FraudDetectorClient";
-var FraudDetector = (function (_super) {
-    __extends(FraudDetector, _super);
-    function FraudDetector() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    FraudDetector.prototype.batchCreateVariable = function (args, optionsOrCb, cb) {
-        var command = new BatchCreateVariableCommand(args);
+export class FraudDetector extends FraudDetectorClient {
+    batchCreateVariable(args, optionsOrCb, cb) {
+        const command = new BatchCreateVariableCommand(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);
         }
-    };
-    FraudDetector.prototype.batchGetVariable = function (args, optionsOrCb, cb) {
-        var command = new BatchGetVariableCommand(args);
+    }
+    batchGetVariable(args, optionsOrCb, cb) {
+        const command = new BatchGetVariableCommand(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);
         }
-    };
-    FraudDetector.prototype.cancelBatchImportJob = function (args, optionsOrCb, cb) {
-        var command = new CancelBatchImportJobCommand(args);
+    }
+    cancelBatchImportJob(args, optionsOrCb, cb) {
+        const command = new CancelBatchImportJobCommand(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);
         }
-    };
-    FraudDetector.prototype.cancelBatchPredictionJob = function (args, optionsOrCb, cb) {
-        var command = new CancelBatchPredictionJobCommand(args);
+    }
+    cancelBatchPredictionJob(args, optionsOrCb, cb) {
+        const command = new CancelBatchPredictionJobCommand(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);
         }
-    };
-    FraudDetector.prototype.createBatchImportJob = function (args, optionsOrCb, cb) {
-        var command = new CreateBatchImportJobCommand(args);
+    }
+    createBatchImportJob(args, optionsOrCb, cb) {
+        const command = new CreateBatchImportJobCommand(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);
         }
-    };
-    FraudDetector.prototype.createBatchPredictionJob = function (args, optionsOrCb, cb) {
-        var command = new CreateBatchPredictionJobCommand(args);
+    }
+    createBatchPredictionJob(args, optionsOrCb, cb) {
+        const command = new CreateBatchPredictionJobCommand(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);
         }
-    };
-    FraudDetector.prototype.createDetectorVersion = function (args, optionsOrCb, cb) {
-        var command = new CreateDetectorVersionCommand(args);
+    }
+    createDetectorVersion(args, optionsOrCb, cb) {
+        const command = new CreateDetectorVersionCommand(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);
         }
-    };
-    FraudDetector.prototype.createModel = function (args, optionsOrCb, cb) {
-        var command = new CreateModelCommand(args);
+    }
+    createModel(args, optionsOrCb, cb) {
+        const command = new CreateModelCommand(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);
         }
-    };
-    FraudDetector.prototype.createModelVersion = function (args, optionsOrCb, cb) {
-        var command = new CreateModelVersionCommand(args);
+    }
+    createModelVersion(args, optionsOrCb, cb) {
+        const command = new CreateModelVersionCommand(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);
         }
-    };
-    FraudDetector.prototype.createRule = function (args, optionsOrCb, cb) {
-        var command = new CreateRuleCommand(args);
+    }
+    createRule(args, optionsOrCb, cb) {
+        const command = new CreateRuleCommand(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);
         }
-    };
-    FraudDetector.prototype.createVariable = function (args, optionsOrCb, cb) {
-        var command = new CreateVariableCommand(args);
+    }
+    createVariable(args, optionsOrCb, cb) {
+        const command = new CreateVariableCommand(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);
         }
-    };
-    FraudDetector.prototype.deleteBatchImportJob = function (args, optionsOrCb, cb) {
-        var command = new DeleteBatchImportJobCommand(args);
+    }
+    deleteBatchImportJob(args, optionsOrCb, cb) {
+        const command = new DeleteBatchImportJobCommand(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);
         }
-    };
-    FraudDetector.prototype.deleteBatchPredictionJob = function (args, optionsOrCb, cb) {
-        var command = new DeleteBatchPredictionJobCommand(args);
+    }
+    deleteBatchPredictionJob(args, optionsOrCb, cb) {
+        const command = new DeleteBatchPredictionJobCommand(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);
         }
-    };
-    FraudDetector.prototype.deleteDetector = function (args, optionsOrCb, cb) {
-        var command = new DeleteDetectorCommand(args);
+    }
+    deleteDetector(args, optionsOrCb, cb) {
+        const command = new DeleteDetectorCommand(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);
         }
-    };
-    FraudDetector.prototype.deleteDetectorVersion = function (args, optionsOrCb, cb) {
-        var command = new DeleteDetectorVersionCommand(args);
+    }
+    deleteDetectorVersion(args, optionsOrCb, cb) {
+        const command = new DeleteDetectorVersionCommand(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);
         }
-    };
-    FraudDetector.prototype.deleteEntityType = function (args, optionsOrCb, cb) {
-        var command = new DeleteEntityTypeCommand(args);
+    }
+    deleteEntityType(args, optionsOrCb, cb) {
+        const command = new DeleteEntityTypeCommand(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);
         }
-    };
-    FraudDetector.prototype.deleteEvent = function (args, optionsOrCb, cb) {
-        var command = new DeleteEventCommand(args);
+    }
+    deleteEvent(args, optionsOrCb, cb) {
+        const command = new DeleteEventCommand(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);
         }
-    };
-    FraudDetector.prototype.deleteEventsByEventType = function (args, optionsOrCb, cb) {
-        var command = new DeleteEventsByEventTypeCommand(args);
+    }
+    deleteEventsByEventType(args, optionsOrCb, cb) {
+        const command = new DeleteEventsByEventTypeCommand(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);
         }
-    };
-    FraudDetector.prototype.deleteEventType = function (args, optionsOrCb, cb) {
-        var command = new DeleteEventTypeCommand(args);
+    }
+    deleteEventType(args, optionsOrCb, cb) {
+        const command = new DeleteEventTypeCommand(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);
         }
-    };
-    FraudDetector.prototype.deleteExternalModel = function (args, optionsOrCb, cb) {
-        var command = new DeleteExternalModelCommand(args);
+    }
+    deleteExternalModel(args, optionsOrCb, cb) {
+        const command = new DeleteExternalModelCommand(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);
         }
-    };
-    FraudDetector.prototype.deleteLabel = function (args, optionsOrCb, cb) {
-        var command = new DeleteLabelCommand(args);
+    }
+    deleteLabel(args, optionsOrCb, cb) {
+        const command = new DeleteLabelCommand(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);
         }
-    };
-    FraudDetector.prototype.deleteModel = function (args, optionsOrCb, cb) {
-        var command = new DeleteModelCommand(args);
+    }
+    deleteModel(args, optionsOrCb, cb) {
+        const command = new DeleteModelCommand(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);
         }
-    };
-    FraudDetector.prototype.deleteModelVersion = function (args, optionsOrCb, cb) {
-        var command = new DeleteModelVersionCommand(args);
+    }
+    deleteModelVersion(args, optionsOrCb, cb) {
+        const command = new DeleteModelVersionCommand(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);
         }
-    };
-    FraudDetector.prototype.deleteOutcome = function (args, optionsOrCb, cb) {
-        var command = new DeleteOutcomeCommand(args);
+    }
+    deleteOutcome(args, optionsOrCb, cb) {
+        const command = new DeleteOutcomeCommand(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);
         }
-    };
-    FraudDetector.prototype.deleteRule = function (args, optionsOrCb, cb) {
-        var command = new DeleteRuleCommand(args);
+    }
+    deleteRule(args, optionsOrCb, cb) {
+        const command = new DeleteRuleCommand(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);
         }
-    };
-    FraudDetector.prototype.deleteVariable = function (args, optionsOrCb, cb) {
-        var command = new DeleteVariableCommand(args);
+    }
+    deleteVariable(args, optionsOrCb, cb) {
+        const command = new DeleteVariableCommand(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);
         }
-    };
-    FraudDetector.prototype.describeDetector = function (args, optionsOrCb, cb) {
-        var command = new DescribeDetectorCommand(args);
+    }
+    describeDetector(args, optionsOrCb, cb) {
+        const command = new DescribeDetectorCommand(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);
         }
-    };
-    FraudDetector.prototype.describeModelVersions = function (args, optionsOrCb, cb) {
-        var command = new DescribeModelVersionsCommand(args);
+    }
+    describeModelVersions(args, optionsOrCb, cb) {
+        const command = new DescribeModelVersionsCommand(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);
         }
-    };
-    FraudDetector.prototype.getBatchImportJobs = function (args, optionsOrCb, cb) {
-        var command = new GetBatchImportJobsCommand(args);
+    }
+    getBatchImportJobs(args, optionsOrCb, cb) {
+        const command = new GetBatchImportJobsCommand(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);
         }
-    };
-    FraudDetector.prototype.getBatchPredictionJobs = function (args, optionsOrCb, cb) {
-        var command = new GetBatchPredictionJobsCommand(args);
+    }
+    getBatchPredictionJobs(args, optionsOrCb, cb) {
+        const command = new GetBatchPredictionJobsCommand(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);
         }
-    };
-    FraudDetector.prototype.getDeleteEventsByEventTypeStatus = function (args, optionsOrCb, cb) {
-        var command = new GetDeleteEventsByEventTypeStatusCommand(args);
+    }
+    getDeleteEventsByEventTypeStatus(args, optionsOrCb, cb) {
+        const command = new GetDeleteEventsByEventTypeStatusCommand(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);
         }
-    };
-    FraudDetector.prototype.getDetectors = function (args, optionsOrCb, cb) {
-        var command = new GetDetectorsCommand(args);
+    }
+    getDetectors(args, optionsOrCb, cb) {
+        const command = new GetDetectorsCommand(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);
         }
-    };
-    FraudDetector.prototype.getDetectorVersion = function (args, optionsOrCb, cb) {
-        var command = new GetDetectorVersionCommand(args);
+    }
+    getDetectorVersion(args, optionsOrCb, cb) {
+        const command = new GetDetectorVersionCommand(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);
         }
-    };
-    FraudDetector.prototype.getEntityTypes = function (args, optionsOrCb, cb) {
-        var command = new GetEntityTypesCommand(args);
+    }
+    getEntityTypes(args, optionsOrCb, cb) {
+        const command = new GetEntityTypesCommand(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);
         }
-    };
-    FraudDetector.prototype.getEvent = function (args, optionsOrCb, cb) {
-        var command = new GetEventCommand(args);
+    }
+    getEvent(args, optionsOrCb, cb) {
+        const command = new GetEventCommand(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);
         }
-    };
-    FraudDetector.prototype.getEventPrediction = function (args, optionsOrCb, cb) {
-        var command = new GetEventPredictionCommand(args);
+    }
+    getEventPrediction(args, optionsOrCb, cb) {
+        const command = new GetEventPredictionCommand(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);
         }
-    };
-    FraudDetector.prototype.getEventPredictionMetadata = function (args, optionsOrCb, cb) {
-        var command = new GetEventPredictionMetadataCommand(args);
+    }
+    getEventPredictionMetadata(args, optionsOrCb, cb) {
+        const command = new GetEventPredictionMetadataCommand(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);
         }
-    };
-    FraudDetector.prototype.getEventTypes = function (args, optionsOrCb, cb) {
-        var command = new GetEventTypesCommand(args);
+    }
+    getEventTypes(args, optionsOrCb, cb) {
+        const command = new GetEventTypesCommand(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);
         }
-    };
-    FraudDetector.prototype.getExternalModels = function (args, optionsOrCb, cb) {
-        var command = new GetExternalModelsCommand(args);
+    }
+    getExternalModels(args, optionsOrCb, cb) {
+        const command = new GetExternalModelsCommand(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);
         }
-    };
-    FraudDetector.prototype.getKMSEncryptionKey = function (args, optionsOrCb, cb) {
-        var command = new GetKMSEncryptionKeyCommand(args);
+    }
+    getKMSEncryptionKey(args, optionsOrCb, cb) {
+        const command = new GetKMSEncryptionKeyCommand(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);
         }
-    };
-    FraudDetector.prototype.getLabels = function (args, optionsOrCb, cb) {
-        var command = new GetLabelsCommand(args);
+    }
+    getLabels(args, optionsOrCb, cb) {
+        const command = new GetLabelsCommand(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);
         }
-    };
-    FraudDetector.prototype.getModels = function (args, optionsOrCb, cb) {
-        var command = new GetModelsCommand(args);
+    }
+    getModels(args, optionsOrCb, cb) {
+        const command = new GetModelsCommand(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);
         }
-    };
-    FraudDetector.prototype.getModelVersion = function (args, optionsOrCb, cb) {
-        var command = new GetModelVersionCommand(args);
+    }
+    getModelVersion(args, optionsOrCb, cb) {
+        const command = new GetModelVersionCommand(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);
         }
-    };
-    FraudDetector.prototype.getOutcomes = function (args, optionsOrCb, cb) {
-        var command = new GetOutcomesCommand(args);
+    }
+    getOutcomes(args, optionsOrCb, cb) {
+        const command = new GetOutcomesCommand(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);
         }
-    };
-    FraudDetector.prototype.getRules = function (args, optionsOrCb, cb) {
-        var command = new GetRulesCommand(args);
+    }
+    getRules(args, optionsOrCb, cb) {
+        const command = new GetRulesCommand(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);
         }
-    };
-    FraudDetector.prototype.getVariables = function (args, optionsOrCb, cb) {
-        var command = new GetVariablesCommand(args);
+    }
+    getVariables(args, optionsOrCb, cb) {
+        const command = new GetVariablesCommand(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);
         }
-    };
-    FraudDetector.prototype.listEventPredictions = function (args, optionsOrCb, cb) {
-        var command = new ListEventPredictionsCommand(args);
+    }
+    listEventPredictions(args, optionsOrCb, cb) {
+        const command = new ListEventPredictionsCommand(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);
         }
-    };
-    FraudDetector.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);
         }
-    };
-    FraudDetector.prototype.putDetector = function (args, optionsOrCb, cb) {
-        var command = new PutDetectorCommand(args);
+    }
+    putDetector(args, optionsOrCb, cb) {
+        const command = new PutDetectorCommand(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);
         }
-    };
-    FraudDetector.prototype.putEntityType = function (args, optionsOrCb, cb) {
-        var command = new PutEntityTypeCommand(args);
+    }
+    putEntityType(args, optionsOrCb, cb) {
+        const command = new PutEntityTypeCommand(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);
         }
-    };
-    FraudDetector.prototype.putEventType = function (args, optionsOrCb, cb) {
-        var command = new PutEventTypeCommand(args);
+    }
+    putEventType(args, optionsOrCb, cb) {
+        const command = new PutEventTypeCommand(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);
         }
-    };
-    FraudDetector.prototype.putExternalModel = function (args, optionsOrCb, cb) {
-        var command = new PutExternalModelCommand(args);
+    }
+    putExternalModel(args, optionsOrCb, cb) {
+        const command = new PutExternalModelCommand(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);
         }
-    };
-    FraudDetector.prototype.putKMSEncryptionKey = function (args, optionsOrCb, cb) {
-        var command = new PutKMSEncryptionKeyCommand(args);
+    }
+    putKMSEncryptionKey(args, optionsOrCb, cb) {
+        const command = new PutKMSEncryptionKeyCommand(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);
         }
-    };
-    FraudDetector.prototype.putLabel = function (args, optionsOrCb, cb) {
-        var command = new PutLabelCommand(args);
+    }
+    putLabel(args, optionsOrCb, cb) {
+        const command = new PutLabelCommand(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);
         }
-    };
-    FraudDetector.prototype.putOutcome = function (args, optionsOrCb, cb) {
-        var command = new PutOutcomeCommand(args);
+    }
+    putOutcome(args, optionsOrCb, cb) {
+        const command = new PutOutcomeCommand(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);
         }
-    };
-    FraudDetector.prototype.sendEvent = function (args, optionsOrCb, cb) {
-        var command = new SendEventCommand(args);
+    }
+    sendEvent(args, optionsOrCb, cb) {
+        const command = new SendEventCommand(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);
         }
-    };
-    FraudDetector.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);
         }
-    };
-    FraudDetector.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);
         }
-    };
-    FraudDetector.prototype.updateDetectorVersion = function (args, optionsOrCb, cb) {
-        var command = new UpdateDetectorVersionCommand(args);
+    }
+    updateDetectorVersion(args, optionsOrCb, cb) {
+        const command = new UpdateDetectorVersionCommand(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);
         }
-    };
-    FraudDetector.prototype.updateDetectorVersionMetadata = function (args, optionsOrCb, cb) {
-        var command = new UpdateDetectorVersionMetadataCommand(args);
+    }
+    updateDetectorVersionMetadata(args, optionsOrCb, cb) {
+        const command = new UpdateDetectorVersionMetadataCommand(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);
         }
-    };
-    FraudDetector.prototype.updateDetectorVersionStatus = function (args, optionsOrCb, cb) {
-        var command = new UpdateDetectorVersionStatusCommand(args);
+    }
+    updateDetectorVersionStatus(args, optionsOrCb, cb) {
+        const command = new UpdateDetectorVersionStatusCommand(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);
         }
-    };
-    FraudDetector.prototype.updateEventLabel = function (args, optionsOrCb, cb) {
-        var command = new UpdateEventLabelCommand(args);
+    }
+    updateEventLabel(args, optionsOrCb, cb) {
+        const command = new UpdateEventLabelCommand(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);
         }
-    };
-    FraudDetector.prototype.updateModel = function (args, optionsOrCb, cb) {
-        var command = new UpdateModelCommand(args);
+    }
+    updateModel(args, optionsOrCb, cb) {
+        const command = new UpdateModelCommand(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);
         }
-    };
-    FraudDetector.prototype.updateModelVersion = function (args, optionsOrCb, cb) {
-        var command = new UpdateModelVersionCommand(args);
+    }
+    updateModelVersion(args, optionsOrCb, cb) {
+        const command = new UpdateModelVersionCommand(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);
         }
-    };
-    FraudDetector.prototype.updateModelVersionStatus = function (args, optionsOrCb, cb) {
-        var command = new UpdateModelVersionStatusCommand(args);
+    }
+    updateModelVersionStatus(args, optionsOrCb, cb) {
+        const command = new UpdateModelVersionStatusCommand(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);
         }
-    };
-    FraudDetector.prototype.updateRuleMetadata = function (args, optionsOrCb, cb) {
-        var command = new UpdateRuleMetadataCommand(args);
+    }
+    updateRuleMetadata(args, optionsOrCb, cb) {
+        const command = new UpdateRuleMetadataCommand(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);
         }
-    };
-    FraudDetector.prototype.updateRuleVersion = function (args, optionsOrCb, cb) {
-        var command = new UpdateRuleVersionCommand(args);
+    }
+    updateRuleVersion(args, optionsOrCb, cb) {
+        const command = new UpdateRuleVersionCommand(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);
         }
-    };
-    FraudDetector.prototype.updateVariable = function (args, optionsOrCb, cb) {
-        var command = new UpdateVariableCommand(args);
+    }
+    updateVariable(args, optionsOrCb, cb) {
+        const command = new UpdateVariableCommand(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 FraudDetector;
-}(FraudDetectorClient));
-export { FraudDetector };
+    }
+}