@aws-sdk/client-frauddetector 3.48.0 → 3.52.0

package/dist-es/commands/GetEventPredictionMetadataCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetEventPredictionMetadataRequest, GetEventPredictionMetadataResult } from "../models/models_0";
+import { deserializeAws_json1_1GetEventPredictionMetadataCommand, serializeAws_json1_1GetEventPredictionMetadataCommand, } from "../protocols/Aws_json1_1";
+var GetEventPredictionMetadataCommand = (function (_super) {
+    __extends(GetEventPredictionMetadataCommand, _super);
+    function GetEventPredictionMetadataCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetEventPredictionMetadataCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "FraudDetectorClient";
+        var commandName = "GetEventPredictionMetadataCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetEventPredictionMetadataRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetEventPredictionMetadataResult.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetEventPredictionMetadataCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1GetEventPredictionMetadataCommand(input, context);
+    };
+    GetEventPredictionMetadataCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1GetEventPredictionMetadataCommand(output, context);
+    };
+    return GetEventPredictionMetadataCommand;
+}($Command));
+export { GetEventPredictionMetadataCommand };

package/dist-es/commands/ListEventPredictionsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListEventPredictionsRequest, ListEventPredictionsResult } from "../models/models_0";
+import { deserializeAws_json1_1ListEventPredictionsCommand, serializeAws_json1_1ListEventPredictionsCommand, } from "../protocols/Aws_json1_1";
+var ListEventPredictionsCommand = (function (_super) {
+    __extends(ListEventPredictionsCommand, _super);
+    function ListEventPredictionsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListEventPredictionsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "FraudDetectorClient";
+        var commandName = "ListEventPredictionsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListEventPredictionsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListEventPredictionsResult.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListEventPredictionsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ListEventPredictionsCommand(input, context);
+    };
+    ListEventPredictionsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ListEventPredictionsCommand(output, context);
+    };
+    return ListEventPredictionsCommand;
+}($Command));
+export { ListEventPredictionsCommand };

package/dist-es/commands/index.js

@@ -34,6 +34,7 @@ export * from "./GetDetectorsCommand";
 export * from "./GetEntityTypesCommand";
 export * from "./GetEventCommand";
 export * from "./GetEventPredictionCommand";
+export * from "./GetEventPredictionMetadataCommand";
 export * from "./GetEventTypesCommand";
 export * from "./GetExternalModelsCommand";
 export * from "./GetKMSEncryptionKeyCommand";
@@ -43,6 +44,7 @@ export * from "./GetModelsCommand";
 export * from "./GetOutcomesCommand";
 export * from "./GetRulesCommand";
 export * from "./GetVariablesCommand";
+export * from "./ListEventPredictionsCommand";
 export * from "./ListTagsForResourceCommand";
 export * from "./PutDetectorCommand";
 export * from "./PutEntityTypeCommand";

package/dist-es/models/models_0.js

@@ -477,6 +477,48 @@ export var GetEventPredictionResult;
 (function (GetEventPredictionResult) {
     GetEventPredictionResult.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(GetEventPredictionResult || (GetEventPredictionResult = {}));
+export var GetEventPredictionMetadataRequest;
+(function (GetEventPredictionMetadataRequest) {
+    GetEventPredictionMetadataRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(GetEventPredictionMetadataRequest || (GetEventPredictionMetadataRequest = {}));
+export var EvaluatedExternalModel;
+(function (EvaluatedExternalModel) {
+    EvaluatedExternalModel.filterSensitiveLog = function (obj) { return (__assign(__assign(__assign({}, obj), (obj.inputVariables && { inputVariables: SENSITIVE_STRING })), (obj.outputVariables && { outputVariables: SENSITIVE_STRING }))); };
+})(EvaluatedExternalModel || (EvaluatedExternalModel = {}));
+export var VariableImpactExplanation;
+(function (VariableImpactExplanation) {
+    VariableImpactExplanation.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(VariableImpactExplanation || (VariableImpactExplanation = {}));
+export var PredictionExplanations;
+(function (PredictionExplanations) {
+    PredictionExplanations.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(PredictionExplanations || (PredictionExplanations = {}));
+export var ModelVersionEvaluation;
+(function (ModelVersionEvaluation) {
+    ModelVersionEvaluation.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ModelVersionEvaluation || (ModelVersionEvaluation = {}));
+export var EvaluatedModelVersion;
+(function (EvaluatedModelVersion) {
+    EvaluatedModelVersion.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(EvaluatedModelVersion || (EvaluatedModelVersion = {}));
+export var EventVariableSummary;
+(function (EventVariableSummary) {
+    EventVariableSummary.filterSensitiveLog = function (obj) { return (__assign(__assign(__assign(__assign({}, obj), (obj.name && { name: SENSITIVE_STRING })), (obj.value && { value: SENSITIVE_STRING })), (obj.source && { source: SENSITIVE_STRING }))); };
+})(EventVariableSummary || (EventVariableSummary = {}));
+export var EvaluatedRule;
+(function (EvaluatedRule) {
+    EvaluatedRule.filterSensitiveLog = function (obj) { return (__assign(__assign(__assign({}, obj), (obj.expression && { expression: SENSITIVE_STRING })), (obj.expressionWithValues && { expressionWithValues: SENSITIVE_STRING }))); };
+})(EvaluatedRule || (EvaluatedRule = {}));
+export var GetEventPredictionMetadataResult;
+(function (GetEventPredictionMetadataResult) {
+    GetEventPredictionMetadataResult.filterSensitiveLog = function (obj) { return (__assign(__assign(__assign(__assign({}, obj), (obj.eventVariables && {
+        eventVariables: obj.eventVariables.map(function (item) { return EventVariableSummary.filterSensitiveLog(item); }),
+    })), (obj.rules && { rules: obj.rules.map(function (item) { return EvaluatedRule.filterSensitiveLog(item); }) })), (obj.evaluatedExternalModels && {
+        evaluatedExternalModels: obj.evaluatedExternalModels.map(function (item) {
+            return EvaluatedExternalModel.filterSensitiveLog(item);
+        }),
+    }))); };
+})(GetEventPredictionMetadataResult || (GetEventPredictionMetadataResult = {}));
 export var GetEventTypesRequest;
 (function (GetEventTypesRequest) {
     GetEventTypesRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -605,6 +647,26 @@ export var GetVariablesResult;
 (function (GetVariablesResult) {
     GetVariablesResult.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(GetVariablesResult || (GetVariablesResult = {}));
+export var FilterCondition;
+(function (FilterCondition) {
+    FilterCondition.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(FilterCondition || (FilterCondition = {}));
+export var PredictionTimeRange;
+(function (PredictionTimeRange) {
+    PredictionTimeRange.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(PredictionTimeRange || (PredictionTimeRange = {}));
+export var ListEventPredictionsRequest;
+(function (ListEventPredictionsRequest) {
+    ListEventPredictionsRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListEventPredictionsRequest || (ListEventPredictionsRequest = {}));
+export var EventPredictionSummary;
+(function (EventPredictionSummary) {
+    EventPredictionSummary.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(EventPredictionSummary || (EventPredictionSummary = {}));
+export var ListEventPredictionsResult;
+(function (ListEventPredictionsResult) {
+    ListEventPredictionsResult.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListEventPredictionsResult || (ListEventPredictionsResult = {}));
 export var ListTagsForResourceRequest;
 (function (ListTagsForResourceRequest) {
     ListTagsForResourceRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };

package/dist-es/pagination/ListEventPredictionsPaginator.js

@@ -0,0 +1,74 @@
+import { __asyncGenerator, __await, __awaiter, __generator, __read, __spreadArray } from "tslib";
+import { ListEventPredictionsCommand, } from "../commands/ListEventPredictionsCommand";
+import { FraudDetector } from "../FraudDetector";
+import { FraudDetectorClient } from "../FraudDetectorClient";
+var makePagedClientRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.send.apply(client, __spreadArray([new ListEventPredictionsCommand(input)], __read(args)))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+var makePagedRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.listEventPredictions.apply(client, __spreadArray([input], __read(args)))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+export function paginateListEventPredictions(config, input) {
+    var additionalArguments = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        additionalArguments[_i - 2] = arguments[_i];
+    }
+    return __asyncGenerator(this, arguments, function paginateListEventPredictions_1() {
+        var token, hasNext, page;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    token = config.startingToken || undefined;
+                    hasNext = true;
+                    _a.label = 1;
+                case 1:
+                    if (!hasNext) return [3, 9];
+                    input.nextToken = token;
+                    input["maxResults"] = config.pageSize;
+                    if (!(config.client instanceof FraudDetector)) return [3, 3];
+                    return [4, __await(makePagedRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments))))];
+                case 2:
+                    page = _a.sent();
+                    return [3, 6];
+                case 3:
+                    if (!(config.client instanceof FraudDetectorClient)) return [3, 5];
+                    return [4, __await(makePagedClientRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments))))];
+                case 4:
+                    page = _a.sent();
+                    return [3, 6];
+                case 5: throw new Error("Invalid client, expected FraudDetector | FraudDetectorClient");
+                case 6: return [4, __await(page)];
+                case 7: return [4, _a.sent()];
+                case 8:
+                    _a.sent();
+                    token = page.nextToken;
+                    hasNext = !!token;
+                    return [3, 1];
+                case 9: return [4, __await(undefined)];
+                case 10: return [2, _a.sent()];
+            }
+        });
+    });
+}

package/dist-es/pagination/index.js

@@ -11,4 +11,5 @@ export * from "./GetOutcomesPaginator";
 export * from "./Interfaces";
 export * from "./GetRulesPaginator";
 export * from "./GetVariablesPaginator";
+export * from "./ListEventPredictionsPaginator";
 export * from "./ListTagsForResourcePaginator";