@aws-sdk/client-frauddetector 3.183.0 → 3.186.0

package/dist-es/FraudDetector.js

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